Function preload

packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js:6309–6509

(href: string, as: string, options?: ?PreloadImplOptions)

}

function preload(href: string, as: string, options?: ?PreloadImplOptions) {
  const request = resolveRequest();
  if (!request) {
    // In async contexts we can sometimes resolve resources from AsyncLocalStorage. If we can't we can also
    // possibly get them from the stack if we are not in an async context. Since we were not able to resolve
    // the resources for this call in either case we opt to do nothing. We can consider making this a warning
    // but there may be times where calling a function outside of render is intentional (i.e. to warm up data
    // fetching) and we don't want to warn in those cases.
    previousDispatcher.L(/* preload */ href, as, options);
    return;
  }
  const resumableState = getResumableState(request);
  const renderState = getRenderState(request);
  if (as && href) {
    switch (as) {
      case 'image': {
        let imageSrcSet, imageSizes, fetchPriority;
        if (options) {
          imageSrcSet = options.imageSrcSet;
          imageSizes = options.imageSizes;
          fetchPriority = options.fetchPriority;
        }
        const key = getImageResourceKey(href, imageSrcSet, imageSizes);
        if (resumableState.imageResources.hasOwnProperty(key)) {
          // we can return if we already have this resource
          return;
        }
        resumableState.imageResources[key] = PRELOAD_NO_CREDS;

        const headers = renderState.headers;
        let header: string;
        if (
          headers &&
          headers.remainingCapacity > 0 &&
          // browsers today don't support preloading responsive images from link headers so we bail out
          // if the img has srcset defined
          typeof imageSrcSet !== 'string' &&
          // We only include high priority images in the link header
          fetchPriority === 'high' &&
          // Compute the header since we might be able to fit it in the max length
          ((header = getPreloadAsHeader(href, as, options)),
          // We always consume the header length since once we find one header that doesn't fit
          // we assume all the rest won't as well. This is to avoid getting into a situation
          // where we have a very small remaining capacity but no headers will ever fit and we end
          // up constantly trying to see if the next resource might make it. In the future we can
          // make this behavior different between render and prerender since in the latter case
          // we are less sensitive to the current requests runtime per and more sensitive to maximizing
          // headers.
          (headers.remainingCapacity -= header.length + 2) >= 0)
        ) {
          // If we postpone in the shell we will still emit a preload as a header so we
          // track this to make sure we don't reset it.
          renderState.resets.image[key] = PRELOAD_NO_CREDS;
          if (headers.highImagePreloads) {
            headers.highImagePreloads += ', ';
          }
          // $FlowFixMe[unsafe-addition]: we assign header during the if condition
          headers.highImagePreloads += header;