@jsenv/test 1.2.4 → 1.3.1

package/dist/importmap_node_loader.mjs

@@ -4,129 +4,147 @@ import { pathToFileURL } from "node:url";
 // duplicated from @jsenv/log to avoid the dependency
 const createDetailedMessage = (message, details = {}) => {
   let string = `${message}`;
-  Object.keys(details).forEach(key => {
+
+  Object.keys(details).forEach((key) => {
     const value = details[key];
     string += `
     --- ${key} ---
-    ${Array.isArray(value) ? value.join(`
-    `) : value}`;
+    ${
+      Array.isArray(value)
+        ? value.join(`
+    `)
+        : value
+    }`;
   });
-  return string;
+
+  return string
 };
 
-const assertImportMap = value => {
+const assertImportMap = (value) => {
   if (value === null) {
-    throw new TypeError(`an importMap must be an object, got null`);
+    throw new TypeError(`an importMap must be an object, got null`)
   }
+
   const type = typeof value;
   if (type !== "object") {
-    throw new TypeError(`an importMap must be an object, received ${value}`);
+    throw new TypeError(`an importMap must be an object, received ${value}`)
   }
+
   if (Array.isArray(value)) {
-    throw new TypeError(`an importMap must be an object, received array ${value}`);
+    throw new TypeError(
+      `an importMap must be an object, received array ${value}`,
+    )
   }
 };
 
-const hasScheme = string => {
-  return /^[a-zA-Z]{2,}:/.test(string);
+const hasScheme = (string) => {
+  return /^[a-zA-Z]{2,}:/.test(string)
 };
 
-const urlToScheme = urlString => {
+const urlToScheme = (urlString) => {
   const colonIndex = urlString.indexOf(":");
-  if (colonIndex === -1) return "";
-  return urlString.slice(0, colonIndex);
+  if (colonIndex === -1) return ""
+  return urlString.slice(0, colonIndex)
 };
 
-const urlToPathname = urlString => {
-  return ressourceToPathname(urlToRessource(urlString));
+const urlToPathname = (urlString) => {
+  return ressourceToPathname(urlToRessource(urlString))
 };
-const urlToRessource = urlString => {
+
+const urlToRessource = (urlString) => {
   const scheme = urlToScheme(urlString);
+
   if (scheme === "file") {
-    return urlString.slice("file://".length);
+    return urlString.slice("file://".length)
   }
+
   if (scheme === "https" || scheme === "http") {
     // remove origin
     const afterProtocol = urlString.slice(scheme.length + "://".length);
     const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
-    return afterProtocol.slice(pathnameSlashIndex);
+    return afterProtocol.slice(pathnameSlashIndex)
   }
-  return urlString.slice(scheme.length + 1);
+
+  return urlString.slice(scheme.length + 1)
 };
-const ressourceToPathname = ressource => {
+
+const ressourceToPathname = (ressource) => {
   const searchSeparatorIndex = ressource.indexOf("?");
-  return searchSeparatorIndex === -1 ? ressource : ressource.slice(0, searchSeparatorIndex);
+  return searchSeparatorIndex === -1
+    ? ressource
+    : ressource.slice(0, searchSeparatorIndex)
 };
 
-const urlToOrigin = urlString => {
+const urlToOrigin = (urlString) => {
   const scheme = urlToScheme(urlString);
+
   if (scheme === "file") {
-    return "file://";
+    return "file://"
   }
+
   if (scheme === "http" || scheme === "https") {
     const secondProtocolSlashIndex = scheme.length + "://".length;
     const pathnameSlashIndex = urlString.indexOf("/", secondProtocolSlashIndex);
-    if (pathnameSlashIndex === -1) return urlString;
-    return urlString.slice(0, pathnameSlashIndex);
+
+    if (pathnameSlashIndex === -1) return urlString
+    return urlString.slice(0, pathnameSlashIndex)
   }
-  return urlString.slice(0, scheme.length + 1);
+
+  return urlString.slice(0, scheme.length + 1)
 };
 
-const pathnameToParentPathname = pathname => {
+const pathnameToParentPathname = (pathname) => {
   const slashLastIndex = pathname.lastIndexOf("/");
   if (slashLastIndex === -1) {
-    return "/";
+    return "/"
   }
-  return pathname.slice(0, slashLastIndex + 1);
+
+  return pathname.slice(0, slashLastIndex + 1)
 };
 
 // could be useful: https://url.spec.whatwg.org/#url-miscellaneous
 
+
 const resolveUrl = (specifier, baseUrl) => {
   if (baseUrl) {
     if (typeof baseUrl !== "string") {
-      throw new TypeError(writeBaseUrlMustBeAString({
-        baseUrl,
-        specifier
-      }));
+      throw new TypeError(writeBaseUrlMustBeAString({ baseUrl, specifier }))
     }
     if (!hasScheme(baseUrl)) {
-      throw new Error(writeBaseUrlMustBeAbsolute({
-        baseUrl,
-        specifier
-      }));
+      throw new Error(writeBaseUrlMustBeAbsolute({ baseUrl, specifier }))
     }
   }
+
   if (hasScheme(specifier)) {
-    return specifier;
+    return specifier
   }
+
   if (!baseUrl) {
-    throw new Error(writeBaseUrlRequired({
-      baseUrl,
-      specifier
-    }));
+    throw new Error(writeBaseUrlRequired({ baseUrl, specifier }))
   }
 
   // scheme relative
   if (specifier.slice(0, 2) === "//") {
-    return `${urlToScheme(baseUrl)}:${specifier}`;
+    return `${urlToScheme(baseUrl)}:${specifier}`
   }
 
   // origin relative
   if (specifier[0] === "/") {
-    return `${urlToOrigin(baseUrl)}${specifier}`;
+    return `${urlToOrigin(baseUrl)}${specifier}`
   }
+
   const baseOrigin = urlToOrigin(baseUrl);
   const basePathname = urlToPathname(baseUrl);
+
   if (specifier === ".") {
     const baseDirectoryPathname = pathnameToParentPathname(basePathname);
-    return `${baseOrigin}${baseDirectoryPathname}`;
+    return `${baseOrigin}${baseDirectoryPathname}`
   }
 
   // pathname relative inside
   if (specifier.slice(0, 2) === "./") {
     const baseDirectoryPathname = pathnameToParentPathname(basePathname);
-    return `${baseOrigin}${baseDirectoryPathname}${specifier.slice(2)}`;
+    return `${baseOrigin}${baseDirectoryPathname}${specifier.slice(2)}`
   }
 
   // pathname relative outside
@@ -134,6 +152,7 @@ const resolveUrl = (specifier, baseUrl) => {
     let unresolvedPathname = specifier;
     const importerFolders = basePathname.split("/");
     importerFolders.pop();
+
     while (unresolvedPathname.slice(0, 3) === "../") {
       unresolvedPathname = unresolvedPathname.slice(3);
       // when there is no folder left to resolved
@@ -142,38 +161,44 @@ const resolveUrl = (specifier, baseUrl) => {
         importerFolders.pop();
       }
     }
-    const resolvedPathname = `${importerFolders.join("/")}/${unresolvedPathname}`;
-    return `${baseOrigin}${resolvedPathname}`;
+
+    const resolvedPathname = `${importerFolders.join(
+      "/",
+    )}/${unresolvedPathname}`;
+    return `${baseOrigin}${resolvedPathname}`
   }
 
   // bare
   if (basePathname === "") {
-    return `${baseOrigin}/${specifier}`;
+    return `${baseOrigin}/${specifier}`
   }
   if (basePathname[basePathname.length] === "/") {
-    return `${baseOrigin}${basePathname}${specifier}`;
+    return `${baseOrigin}${basePathname}${specifier}`
   }
-  return `${baseOrigin}${pathnameToParentPathname(basePathname)}${specifier}`;
+  return `${baseOrigin}${pathnameToParentPathname(basePathname)}${specifier}`
 };
+
 const writeBaseUrlMustBeAString = ({
   baseUrl,
-  specifier
+  specifier,
 }) => `baseUrl must be a string.
 --- base url ---
 ${baseUrl}
 --- specifier ---
 ${specifier}`;
+
 const writeBaseUrlMustBeAbsolute = ({
   baseUrl,
-  specifier
+  specifier,
 }) => `baseUrl must be absolute.
 --- base url ---
 ${baseUrl}
 --- specifier ---
 ${specifier}`;
+
 const writeBaseUrlRequired = ({
   baseUrl,
-  specifier
+  specifier,
 }) => `baseUrl required to resolve relative specifier.
 --- base url ---
 ${baseUrl}
@@ -182,91 +207,123 @@ ${specifier}`;
 
 const tryUrlResolution = (string, url) => {
   const result = resolveUrl(string, url);
-  return hasScheme(result) ? result : null;
+  return hasScheme(result) ? result : null
 };
 
 const resolveSpecifier = (specifier, importer) => {
-  if (specifier === "." || specifier[0] === "/" || specifier.startsWith("./") || specifier.startsWith("../")) {
-    return resolveUrl(specifier, importer);
+  if (
+    specifier === "." ||
+    specifier[0] === "/" ||
+    specifier.startsWith("./") ||
+    specifier.startsWith("../")
+  ) {
+    return resolveUrl(specifier, importer)
   }
+
   if (hasScheme(specifier)) {
-    return specifier;
+    return specifier
   }
-  return null;
+
+  return null
 };
 
 const applyImportMap = ({
   importMap,
   specifier,
   importer,
-  createBareSpecifierError = ({
-    specifier,
-    importer
-  }) => {
-    return new Error(createDetailedMessage(`Unmapped bare specifier.`, {
-      specifier,
-      importer
-    }));
+  createBareSpecifierError = ({ specifier, importer }) => {
+    return new Error(
+      createDetailedMessage(`Unmapped bare specifier.`, {
+        specifier,
+        importer,
+      }),
+    )
   },
-  onImportMapping = () => {}
+  onImportMapping = () => {},
 }) => {
   assertImportMap(importMap);
   if (typeof specifier !== "string") {
-    throw new TypeError(createDetailedMessage("specifier must be a string.", {
-      specifier,
-      importer
-    }));
+    throw new TypeError(
+      createDetailedMessage("specifier must be a string.", {
+        specifier,
+        importer,
+      }),
+    )
   }
   if (importer) {
     if (typeof importer !== "string") {
-      throw new TypeError(createDetailedMessage("importer must be a string.", {
-        importer,
-        specifier
-      }));
+      throw new TypeError(
+        createDetailedMessage("importer must be a string.", {
+          importer,
+          specifier,
+        }),
+      )
     }
     if (!hasScheme(importer)) {
-      throw new Error(createDetailedMessage(`importer must be an absolute url.`, {
-        importer,
-        specifier
-      }));
+      throw new Error(
+        createDetailedMessage(`importer must be an absolute url.`, {
+          importer,
+          specifier,
+        }),
+      )
     }
   }
+
   const specifierUrl = resolveSpecifier(specifier, importer);
   const specifierNormalized = specifierUrl || specifier;
-  const {
-    scopes
-  } = importMap;
+
+  const { scopes } = importMap;
   if (scopes && importer) {
-    const scopeSpecifierMatching = Object.keys(scopes).find(scopeSpecifier => {
-      return scopeSpecifier === importer || specifierIsPrefixOf(scopeSpecifier, importer);
-    });
+    const scopeSpecifierMatching = Object.keys(scopes).find(
+      (scopeSpecifier) => {
+        return (
+          scopeSpecifier === importer ||
+          specifierIsPrefixOf(scopeSpecifier, importer)
+        )
+      },
+    );
     if (scopeSpecifierMatching) {
       const scopeMappings = scopes[scopeSpecifierMatching];
-      const mappingFromScopes = applyMappings(scopeMappings, specifierNormalized, scopeSpecifierMatching, onImportMapping);
+      const mappingFromScopes = applyMappings(
+        scopeMappings,
+        specifierNormalized,
+        scopeSpecifierMatching,
+        onImportMapping,
+      );
       if (mappingFromScopes !== null) {
-        return mappingFromScopes;
+        return mappingFromScopes
       }
     }
   }
-  const {
-    imports
-  } = importMap;
+
+  const { imports } = importMap;
   if (imports) {
-    const mappingFromImports = applyMappings(imports, specifierNormalized, undefined, onImportMapping);
+    const mappingFromImports = applyMappings(
+      imports,
+      specifierNormalized,
+      undefined,
+      onImportMapping,
+    );
     if (mappingFromImports !== null) {
-      return mappingFromImports;
+      return mappingFromImports
     }
   }
+
   if (specifierUrl) {
-    return specifierUrl;
+    return specifierUrl
   }
-  throw createBareSpecifierError({
-    specifier,
-    importer
-  });
+
+  throw createBareSpecifierError({ specifier, importer })
 };
-const applyMappings = (mappings, specifierNormalized, scope, onImportMapping) => {
+
+const applyMappings = (
+  mappings,
+  specifierNormalized,
+  scope,
+  onImportMapping,
+) => {
   const specifierCandidates = Object.keys(mappings);
+
   let i = 0;
   while (i < specifierCandidates.length) {
     const specifierCandidate = specifierCandidates[i];
@@ -278,140 +335,179 @@ const applyMappings = (mappings, specifierNormalized, scope, onImportMapping) =>
         from: specifierCandidate,
         to: address,
         before: specifierNormalized,
-        after: address
+        after: address,
       });
-      return address;
+      return address
     }
     if (specifierIsPrefixOf(specifierCandidate, specifierNormalized)) {
       const address = mappings[specifierCandidate];
-      const afterSpecifier = specifierNormalized.slice(specifierCandidate.length);
+      const afterSpecifier = specifierNormalized.slice(
+        specifierCandidate.length,
+      );
       const addressFinal = tryUrlResolution(afterSpecifier, address);
       onImportMapping({
         scope,
         from: specifierCandidate,
         to: address,
         before: specifierNormalized,
-        after: addressFinal
+        after: addressFinal,
       });
-      return addressFinal;
+      return addressFinal
     }
   }
-  return null;
+
+  return null
 };
+
 const specifierIsPrefixOf = (specifierHref, href) => {
-  return specifierHref[specifierHref.length - 1] === "/" && href.startsWith(specifierHref);
+  return (
+    specifierHref[specifierHref.length - 1] === "/" &&
+    href.startsWith(specifierHref)
+  )
 };
 
-const sortImports = imports => {
+const sortImports = (imports) => {
   const mappingsSorted = {};
-  Object.keys(imports).sort(compareLengthOrLocaleCompare).forEach(name => {
-    mappingsSorted[name] = imports[name];
-  });
-  return mappingsSorted;
+
+  Object.keys(imports)
+    .sort(compareLengthOrLocaleCompare)
+    .forEach((name) => {
+      mappingsSorted[name] = imports[name];
+    });
+
+  return mappingsSorted
 };
-const sortScopes = scopes => {
+
+const sortScopes = (scopes) => {
   const scopesSorted = {};
-  Object.keys(scopes).sort(compareLengthOrLocaleCompare).forEach(scopeSpecifier => {
-    scopesSorted[scopeSpecifier] = sortImports(scopes[scopeSpecifier]);
-  });
-  return scopesSorted;
+
+  Object.keys(scopes)
+    .sort(compareLengthOrLocaleCompare)
+    .forEach((scopeSpecifier) => {
+      scopesSorted[scopeSpecifier] = sortImports(scopes[scopeSpecifier]);
+    });
+
+  return scopesSorted
 };
+
 const compareLengthOrLocaleCompare = (a, b) => {
-  return b.length - a.length || a.localeCompare(b);
+  return b.length - a.length || a.localeCompare(b)
 };
 
 const normalizeImportMap = (importMap, baseUrl) => {
   assertImportMap(importMap);
+
   if (!isStringOrUrl(baseUrl)) {
-    throw new TypeError(formulateBaseUrlMustBeStringOrUrl({
-      baseUrl
-    }));
-  }
-  const {
-    imports,
-    scopes
-  } = importMap;
+    throw new TypeError(formulateBaseUrlMustBeStringOrUrl({ baseUrl }))
+  }
+
+  const { imports, scopes } = importMap;
+
   return {
     imports: imports ? normalizeMappings(imports, baseUrl) : undefined,
-    scopes: scopes ? normalizeScopes(scopes, baseUrl) : undefined
-  };
+    scopes: scopes ? normalizeScopes(scopes, baseUrl) : undefined,
+  }
 };
-const isStringOrUrl = value => {
+
+const isStringOrUrl = (value) => {
   if (typeof value === "string") {
-    return true;
+    return true
   }
+
   if (typeof URL === "function" && value instanceof URL) {
-    return true;
+    return true
   }
-  return false;
+
+  return false
 };
+
 const normalizeMappings = (mappings, baseUrl) => {
   const mappingsNormalized = {};
-  Object.keys(mappings).forEach(specifier => {
+
+  Object.keys(mappings).forEach((specifier) => {
     const address = mappings[specifier];
+
     if (typeof address !== "string") {
-      console.warn(formulateAddressMustBeAString({
-        address,
-        specifier
-      }));
-      return;
+      console.warn(
+        formulateAddressMustBeAString({
+          address,
+          specifier,
+        }),
+      );
+      return
     }
+
     const specifierResolved = resolveSpecifier(specifier, baseUrl) || specifier;
+
     const addressUrl = tryUrlResolution(address, baseUrl);
     if (addressUrl === null) {
-      console.warn(formulateAdressResolutionFailed({
-        address,
-        baseUrl,
-        specifier
-      }));
-      return;
+      console.warn(
+        formulateAdressResolutionFailed({
+          address,
+          baseUrl,
+          specifier,
+        }),
+      );
+      return
     }
+
     if (specifier.endsWith("/") && !addressUrl.endsWith("/")) {
-      console.warn(formulateAddressUrlRequiresTrailingSlash({
-        addressUrl,
-        address,
-        specifier
-      }));
-      return;
+      console.warn(
+        formulateAddressUrlRequiresTrailingSlash({
+          addressUrl,
+          address,
+          specifier,
+        }),
+      );
+      return
     }
     mappingsNormalized[specifierResolved] = addressUrl;
   });
-  return sortImports(mappingsNormalized);
+
+  return sortImports(mappingsNormalized)
 };
+
 const normalizeScopes = (scopes, baseUrl) => {
   const scopesNormalized = {};
-  Object.keys(scopes).forEach(scopeSpecifier => {
+
+  Object.keys(scopes).forEach((scopeSpecifier) => {
     const scopeMappings = scopes[scopeSpecifier];
     const scopeUrl = tryUrlResolution(scopeSpecifier, baseUrl);
     if (scopeUrl === null) {
-      console.warn(formulateScopeResolutionFailed({
-        scope: scopeSpecifier,
-        baseUrl
-      }));
-      return;
+      console.warn(
+        formulateScopeResolutionFailed({
+          scope: scopeSpecifier,
+          baseUrl,
+        }),
+      );
+      return
     }
     const scopeValueNormalized = normalizeMappings(scopeMappings, baseUrl);
     scopesNormalized[scopeUrl] = scopeValueNormalized;
   });
-  return sortScopes(scopesNormalized);
+
+  return sortScopes(scopesNormalized)
 };
+
 const formulateBaseUrlMustBeStringOrUrl = ({
-  baseUrl
+  baseUrl,
 }) => `baseUrl must be a string or an url.
 --- base url ---
 ${baseUrl}`;
+
 const formulateAddressMustBeAString = ({
   specifier,
-  address
+  address,
 }) => `Address must be a string.
 --- address ---
 ${address}
 --- specifier ---
 ${specifier}`;
+
 const formulateAdressResolutionFailed = ({
   address,
   baseUrl,
-  specifier
+  specifier,
 }) => `Address url resolution failed.
 --- address ---
 ${address}
@@ -419,10 +515,11 @@ ${address}
 ${baseUrl}
 --- specifier ---
 ${specifier}`;
+
 const formulateAddressUrlRequiresTrailingSlash = ({
   addressURL,
   address,
-  specifier
+  specifier,
 }) => `Address must end with /.
 --- address url ---
 ${addressURL}
@@ -430,24 +527,26 @@ ${addressURL}
 ${address}
 --- specifier ---
 ${specifier}`;
+
 const formulateScopeResolutionFailed = ({
   scope,
-  baseUrl
+  baseUrl,
 }) => `Scope url resolution failed.
 --- scope ---
 ${scope}
 --- base url ---
 ${baseUrl}`;
 
-const pathnameToExtension = pathname => {
+const pathnameToExtension = (pathname) => {
   const slashLastIndex = pathname.lastIndexOf("/");
   if (slashLastIndex !== -1) {
     pathname = pathname.slice(slashLastIndex + 1);
   }
+
   const dotLastIndex = pathname.lastIndexOf(".");
-  if (dotLastIndex === -1) return "";
+  if (dotLastIndex === -1) return ""
   // if (dotLastIndex === pathname.length - 1) return ""
-  return pathname.slice(dotLastIndex);
+  return pathname.slice(dotLastIndex)
 };
 
 const resolveImport = ({
@@ -456,7 +555,7 @@ const resolveImport = ({
   importMap,
   defaultExtension = false,
   createBareSpecifierError,
-  onImportMapping = () => {}
+  onImportMapping = () => {},
 }) => {
   let url;
   if (importMap) {
@@ -465,48 +564,48 @@ const resolveImport = ({
       specifier,
       importer,
       createBareSpecifierError,
-      onImportMapping
+      onImportMapping,
     });
   } else {
     url = resolveUrl(specifier, importer);
   }
+
   if (defaultExtension) {
-    url = applyDefaultExtension({
-      url,
-      importer,
-      defaultExtension
-    });
+    url = applyDefaultExtension({ url, importer, defaultExtension });
   }
-  return url;
+
+  return url
 };
-const applyDefaultExtension = ({
-  url,
-  importer,
-  defaultExtension
-}) => {
+
+const applyDefaultExtension = ({ url, importer, defaultExtension }) => {
   if (urlToPathname(url).endsWith("/")) {
-    return url;
+    return url
   }
+
   if (typeof defaultExtension === "string") {
     const extension = pathnameToExtension(url);
     if (extension === "") {
-      return `${url}${defaultExtension}`;
+      return `${url}${defaultExtension}`
     }
-    return url;
+    return url
   }
+
   if (defaultExtension === true) {
     const extension = pathnameToExtension(url);
     if (extension === "" && importer) {
       const importerPathname = urlToPathname(importer);
       const importerExtension = pathnameToExtension(importerPathname);
-      return `${url}${importerExtension}`;
+      return `${url}${importerExtension}`
     }
   }
-  return url;
+
+  return url
 };
 
 let importMap;
+
 const cwdUrl = `${String(pathToFileURL(process.cwd()))}/`;
+
 if (process.env.IMPORT_MAP) {
   importMap = JSON.parse(process.env.IMPORT_MAP);
 } else if (process.env.IMPORT_MAP_PATH) {
@@ -518,8 +617,10 @@ if (process.env.IMPORT_MAP) {
   const importmapFileContentAsString = readFileSync(importmapFileUrl, "utf8");
   importMap = JSON.parse(importmapFileContentAsString);
 }
+
 const importMapBaseUrl = process.env.IMPORT_MAP_BASE_URL || cwdUrl;
 importMap = normalizeImportMap(importMap, importMapBaseUrl);
+
 const resolve = (specifier, context, nextResolve) => {
   try {
     let mapped;
@@ -531,12 +632,12 @@ const resolve = (specifier, context, nextResolve) => {
       defaultExtension: ".js",
       onImportMapping: () => {
         mapped = true;
-      }
+      },
     });
     if (mapped) {
       return {
         shortCircuit: true,
-        url: resolved
+        url: resolved,
       };
     }
   } catch (e) {