parentURL, responseURL -> parentUrl, responseUrl

Author: guybedford

doc/api/esm.md

@@ -749,7 +749,7 @@ changes:
 * `context` {Object}
   * `conditions` {string\[]} Export conditions of the relevant `package.json`
   * `importAssertions` {Object}
-  * `parentURL` {string|undefined} The module importing this one, or undefined
+  * `parentUrl` {string|undefined} The module importing this one, or undefined
     if this is the Node.js entry point
 * `nextResolve` {Function} The subsequent `resolve` hook in the chain, or the
   Node.js default `resolve` hook after the last user-supplied `resolve` hook
@@ -790,15 +790,15 @@ Node.js module specifier resolution behavior_ when calling `defaultResolve`, the
 
 ```js
 export async function resolve(specifier, context, nextResolve) {
-  const { parentURL = null } = context;
+  const { parentUrl = null } = context;
 
   if (Math.random() > 0.5) { // Some condition.
     // For some or all specifiers, do some custom logic for resolving.
     // Always return an object of the form {url: <string>}.
     return {
       shortCircuit: true,
-      url: parentURL ?
-        new URL(specifier, parentURL).href :
+      url: parentUrl ?
+        new URL(specifier, parentUrl).href :
         new URL(specifier).href,
     };
   }
@@ -1007,7 +1007,7 @@ and there is no security.
 import { get } from 'node:https';
 
 export function resolve(specifier, context, nextResolve) {
-  const { parentURL = null } = context;
+  const { parentUrl = null } = context;
 
   // Normally Node.js would error on specifiers starting with 'https://', so
   // this hook intercepts them and converts them into absolute URLs to be
@@ -1017,10 +1017,10 @@ export function resolve(specifier, context, nextResolve) {
       shortCircuit: true,
       url: specifier
     };
-  } else if (parentURL && parentURL.startsWith('https://')) {
+  } else if (parentUrl && parentUrl.startsWith('https://')) {
     return {
       shortCircuit: true,
-      url: new URL(specifier, parentURL).href,
+      url: new URL(specifier, parentUrl).href,
     };
   }
 
@@ -1083,20 +1083,20 @@ import { cwd } from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import CoffeeScript from 'coffeescript';
 
-const baseURL = pathToFileURL(`${cwd()}/`).href;
+const baseUrl = pathToFileURL(`${cwd()}/`).href;
 
 // CoffeeScript files end in .coffee, .litcoffee or .coffee.md.
 const extensionsRegex = /\.coffee$|\.litcoffee$|\.coffee\.md$/;
 
 export async function resolve(specifier, context, nextResolve) {
   if (extensionsRegex.test(specifier)) {
-    const { parentURL = baseURL } = context;
+    const { parentUrl = baseUrl } = context;
 
     // Node.js normally errors on unknown file extensions, so return a URL for
     // specifiers ending in the CoffeeScript file extensions.
     return {
       shortCircuit: true,
-      url: new URL(specifier, parentURL).href
+      url: new URL(specifier, parentUrl).href
     };
   }
 

lib/internal/modules/esm/fetch_module.js

@@ -217,7 +217,7 @@ async function isLocalAddress(hostname) {
  * @param {ESModuleContext} context
  * @returns {ReturnType<typeof fetchWithRedirects>}
  */
-function fetchModule(parsed, { parentURL }) {
+function fetchModule(parsed, { parentUrl }) {
   const { href } = parsed;
   const existing = cacheForGET.get(href);
   if (existing) {
@@ -228,7 +228,7 @@ function fetchModule(parsed, { parentURL }) {
       if (is !== true) {
         throw new ERR_NETWORK_IMPORT_DISALLOWED(
           href,
-          parentURL,
+          parentUrl,
           'http can only be used to load local resources (use https instead).'
         );
       }

lib/internal/modules/esm/get_format.js

@@ -48,7 +48,7 @@ function getDataProtocolModuleFormat(parsed) {
 
 /**
  * @param {URL} url
- * @param {{parentURL: string}} context
+ * @param {{parentUrl: string}} context
  * @param {boolean} ignoreErrors
  * @returns {string}
  */
@@ -85,7 +85,7 @@ function getFileProtocolModuleFormat(url, context, ignoreErrors) {
 
 /**
  * @param {URL} url
- * @param {{parentURL: string}} context
+ * @param {{parentUrl: string}} context
  * @returns {Promise<string> | undefined} only works when enabled
  */
 function getHttpProtocolModuleFormat(url, context) {
@@ -101,7 +101,7 @@ function getHttpProtocolModuleFormat(url, context) {
 
 /**
  * @param {URL | URL['href']} url
- * @param {{parentURL: string}} context
+ * @param {{parentUrl: string}} context
  * @returns {Promise<string> | string | undefined} only works when enabled
  */
 function defaultGetFormatWithoutErrors(url, context) {
@@ -113,7 +113,7 @@ function defaultGetFormatWithoutErrors(url, context) {
 
 /**
  * @param {URL | URL['href']} url
- * @param {{parentURL: string}} context
+ * @param {{parentUrl: string}} context
  * @returns {Promise<string> | string | undefined} only works when enabled
  */
 function defaultGetFormat(url, context) {

lib/internal/modules/esm/load.js

@@ -31,7 +31,7 @@ const DATA_URL_PATTERN = /^[^/]+\/[^,;]+(?:[^,]*?)(;base64)?,([\s\S]*)$/;
 
 async function getSource(url, context) {
   const parsed = new URL(url);
-  let responseURL = url;
+  let responseUrl = url;
   let source;
   if (parsed.protocol === 'file:') {
     source = await readFileAsync(parsed);
@@ -48,7 +48,7 @@ async function getSource(url, context) {
   )) {
     const res = await fetchModule(parsed, context);
     source = await res.body;
-    responseURL = res.resolvedHREF;
+    responseUrl = res.resolvedHREF;
   } else {
     const supportedSchemes = ['file', 'data'];
     if (experimentalNetworkImports) {
@@ -59,7 +59,7 @@ async function getSource(url, context) {
   if (policy?.manifest) {
     policy.manifest.assertIntegrity(parsed, source);
   }
-  return { responseURL, source };
+  return { responseUrl, source };
 }
 
 
@@ -70,7 +70,7 @@ async function getSource(url, context) {
  * @returns {object}
  */
 async function defaultLoad(url, context) {
-  let responseURL = url;
+  let responseUrl = url;
   const { importAssertions } = context;
   let {
     format,
@@ -89,12 +89,12 @@ async function defaultLoad(url, context) {
   ) {
     source = null;
   } else if (source == null) {
-    ({ responseURL, source } = await getSource(url, context));
+    ({ responseUrl, source } = await getSource(url, context));
   }
 
   return {
     format,
-    responseURL,
+    responseUrl,
     source,
   };
 }

lib/internal/modules/esm/loader.js

@@ -321,14 +321,14 @@ class ESMLoader {
    * @param {string} specifier The string after `from` in an `import` statement,
    *                           or the first parameter of an `import()`
    *                           expression
-   * @param {string | undefined} parentURL The URL of the module importing this
+   * @param {string | undefined} parentUrl The URL of the module importing this
    *                                     one, unless this is the Node.js entry
    *                                     point.
    * @param {Record<string, string>} importAssertions Validations for the
    *                                                  module import.
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
-  async getModuleJob(specifier, parentURL, importAssertions) {
+  async getModuleJob(specifier, parentUrl, importAssertions) {
     let importAssertionsForResolve;
 
     // By default, `this.#loaders` contains just the Node default load hook
@@ -342,7 +342,7 @@ class ESMLoader {
     }
 
     const { format, url } =
-      await this.resolve(specifier, parentURL, importAssertionsForResolve);
+      await this.resolve(specifier, parentUrl, importAssertionsForResolve);
 
     let job = this.moduleMap.get(url, importAssertions.type);
 
@@ -352,7 +352,7 @@ class ESMLoader {
     }
 
     if (job === undefined) {
-      job = this.#createModuleJob(url, importAssertions, parentURL, format);
+      job = this.#createModuleJob(url, importAssertions, parentUrl, format);
     }
 
     return job;
@@ -363,17 +363,17 @@ class ESMLoader {
    * @param {string} url The absolute URL that was resolved for this module
    * @param {Record<string, string>} importAssertions Validations for the
    *                                                  module import.
-   * @param {string} [parentURL] The absolute URL of the module importing this
+   * @param {string} [parentUrl] The absolute URL of the module importing this
    *                             one, unless this is the Node.js entry point
    * @param {string} [format] The format hint possibly returned by the
    *                          `resolve` hook
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
-  #createModuleJob(url, importAssertions, parentURL, format) {
+  #createModuleJob(url, importAssertions, parentUrl, format) {
     const moduleProvider = async (url, isMain) => {
       const {
         format: finalFormat,
-        responseURL,
+        responseUrl,
         source,
       } = await this.load(url, {
         format,
@@ -383,14 +383,14 @@ class ESMLoader {
       const translator = translators.get(finalFormat);
 
       if (!translator) {
-        throw new ERR_UNKNOWN_MODULE_FORMAT(finalFormat, responseURL);
+        throw new ERR_UNKNOWN_MODULE_FORMAT(finalFormat, responseUrl);
       }
 
-      return FunctionPrototypeCall(translator, this, responseURL, source, isMain);
+      return FunctionPrototypeCall(translator, this, responseUrl, source, isMain);
     };
 
     const inspectBrk = (
-      parentURL === undefined &&
+      parentUrl === undefined &&
       getOptionValue('--inspect-brk')
     );
 
@@ -399,7 +399,7 @@ class ESMLoader {
       url,
       importAssertions,
       moduleProvider,
-      parentURL === undefined,
+      parentUrl === undefined,
       inspectBrk
     );
 
@@ -416,14 +416,14 @@ class ESMLoader {
    * loader module.
    *
    * @param {string | string[]} specifiers Path(s) to the module.
-   * @param {string} parentURL Path of the parent importing the module.
+   * @param {string} parentUrl Path of the parent importing the module.
    * @param {Record<string, string>} importAssertions Validations for the
    *                                                  module import.
    * @returns {Promise<ExportedHooks | KeyedExports[]>}
    *  A collection of module export(s) or a list of collections of module
    *  export(s).
    */
-  async import(specifiers, parentURL, importAssertions) {
+  async import(specifiers, parentUrl, importAssertions) {
     // For loaders, `import` is passed multiple things to process, it returns a
     // list pairing the url and exports collected. This is especially useful for
     // error messaging, to identity from where an export came. But, in most
@@ -439,7 +439,7 @@ class ESMLoader {
     const jobs = new Array(count);
 
     for (let i = 0; i < count; i++) {
-      jobs[i] = this.getModuleJob(specifiers[i], parentURL, importAssertions)
+      jobs[i] = this.getModuleJob(specifiers[i], parentUrl, importAssertions)
         .then((job) => job.run())
         .then(({ module }) => module.getNamespace());
     }
@@ -550,27 +550,27 @@ class ESMLoader {
       format,
       source,
     } = loaded;
-    let responseURL = loaded.responseURL;
+    let responseUrl = loaded.responseUrl;
 
-    if (responseURL === undefined) {
-      responseURL = url;
+    if (responseUrl === undefined) {
+      responseUrl = url;
     }
 
-    let responseURLObj;
-    if (typeof responseURL === 'string') {
+    let responseURL;
+    if (typeof responseUrl === 'string') {
       try {
-        responseURLObj = new URL(responseURL);
+        responseURL = new URL(responseUrl);
       } catch {
-        // responseURLObj not defined will throw in next branch.
+        // responseURL not defined will throw in next branch.
       }
     }
 
-    if (responseURLObj?.href !== responseURL) {
+    if (responseURL?.href !== responseUrl) {
       throw new ERR_INVALID_RETURN_PROPERTY_VALUE(
         'undefined or a fully resolved URL string',
         hookErrIdentifier,
-        'responseURL',
-        responseURL,
+        'responseUrl',
+        responseUrl,
       );
     }
 
@@ -610,7 +610,7 @@ class ESMLoader {
 
     return {
       format,
-      responseURL,
+      responseUrl,
       source,
     };
   }
@@ -713,27 +713,27 @@ class ESMLoader {
    *
    * @param {string} originalSpecifier The specified URL path of the module to
    *                                   be resolved.
-   * @param {string} [parentURL] The URL path of the module's parent.
+   * @param {string} [parentUrl] The URL path of the module's parent.
    * @param {ImportAssertions} [importAssertions] Assertions from the import
    *                                              statement or expression.
    * @returns {{ format: string, url: URL['href'] }}
    */
   async resolve(
     originalSpecifier,
-    parentURL,
+    parentUrl,
     importAssertions = ObjectCreate(null)
   ) {
-    const isMain = parentURL === undefined;
+    const isMain = parentUrl === undefined;
 
     if (
       !isMain &&
-      typeof parentURL !== 'string' &&
-      !isURLInstance(parentURL)
+      typeof parentUrl !== 'string' &&
+      !isURLInstance(parentUrl)
     ) {
       throw new ERR_INVALID_ARG_TYPE(
-        'parentURL',
+        'parentUrl',
         ['string', 'URL'],
-        parentURL,
+        parentUrl,
       );
     }
     const resolvers = this.#resolvers;
@@ -749,7 +749,7 @@ class ESMLoader {
     const context = {
       conditions: DEFAULT_CONDITIONS,
       importAssertions,
-      parentURL,
+      parentUrl,
     };
 
     const nextResolve = async (suppliedSpecifier, ctx = context) => {