Function resolveForCJSWithHooks

lib/internal/modules/cjs/loader.js:1167–1224

* Resolve a module request for CommonJS, invoking hooks from module.registerHooks() * if necessary. * @param {string} specifier * @param {Module|undefined} parent * @param {boolean} isMain * @param {CJSModuleLoadInternalOptions} internalOptions * @returns {{url?: string, format?: string, paren

(specifier, parent, isMain, internalOptions)

 * @returns {{url?: string, format?: string, parentURL?: string, filename: string}}
 */
function resolveForCJSWithHooks(specifier, parent, isMain, internalOptions) {
  const { requireResolveOptions, shouldSkipModuleHooks } = internalOptions;
  const defaultResolveImpl = requireResolveOptions ?
    wrapResolveFilename : defaultResolveImplForCJSLoading;
  // Fast path: no hooks, just return simple results.
  if (!resolveHooks.length || shouldSkipModuleHooks) {
    return defaultResolveImpl(specifier, parent, isMain, requireResolveOptions);
  }

  // Slow path: has hooks, do the URL conversions and invoke hooks with contexts.
  let parentURL;
  if (parent) {
    if (!parent[kURL] && parent.filename) {
      parent[kURL] = convertCJSFilenameToURL(parent.filename);
    }
    parentURL = parent[kURL];
  }

  // This is used as the last nextResolve for the resolve hooks.
  function defaultResolve(specifier, context) {
    // TODO(joyeecheung): parent and isMain should be part of context, then we
    // no longer need to use a different defaultResolve for every resolution.
    // In the hooks, context.conditions is passed around as an array, but internally
    // the resolution helpers expect a SafeSet. Do the conversion here.
    let conditionSet;
    const conditions = context.conditions;
    if (conditions !== undefined && conditions !== getCjsConditionsArray()) {
      if (!ArrayIsArray(conditions)) {
        throw new ERR_INVALID_ARG_VALUE('context.conditions', conditions,
                                        'expected an array');
      }
      conditionSet = new SafeSet(conditions);
    } else {
      conditionSet = getCjsConditions();
    }

    const result = defaultResolveImpl(specifier, parent, isMain, {
      __proto__: null,
      paths: requireResolveOptions?.paths,
      conditions: conditionSet,
    });
    // If the default resolver does not return a URL, convert it for the public API.
    result.url ??= convertCJSFilenameToURL(result.filename);

    // Remove filename because it's not part of the public API.
    // TODO(joyeecheung): maybe expose it in the public API to avoid re-conversion for users too.
    return { __proto__: null, url: result.url, format: result.format };
  }

  const resolveResult = resolveWithHooks(specifier, parentURL, /* importAttributes */ undefined,
                                         getCjsConditionsArray(), defaultResolve);
  const { url, format } = resolveResult;
  // Convert the URL from the hook chain back to a filename for internal use.
  const filename = convertURLToCJSFilename(url);
  const result = { __proto__: null, url, format, filename, parentURL };
  debug('resolveForCJSWithHooks', specifier, parent?.id, isMain, shouldSkipModuleHooks, '->', result);
  return result;
}