@jsenv/test 3.5.45 → 3.6.0

package/dist/js/importmap_hooks.mjs

@@ -1,607 +1,7 @@
+import { normalizeImportMap, resolveImport } from "./vendors.js";
 import { readFileSync } from "node:fs";
 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) => {
-    const value = details[key];
-    string += `
-    --- ${key} ---
-    ${
-      Array.isArray(value)
-        ? value.join(`
-    `)
-        : value
-    }`;
-  });
-
-  return string
-};
-
-const assertImportMap = (value) => {
-  if (value === 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}`)
-  }
-
-  if (Array.isArray(value)) {
-    throw new TypeError(
-      `an importMap must be an object, received array ${value}`,
-    )
-  }
-};
-
-const hasScheme = (string) => {
-  return /^[a-zA-Z]{2,}:/.test(string)
-};
-
-const urlToScheme = (urlString) => {
-  const colonIndex = urlString.indexOf(":");
-  if (colonIndex === -1) return ""
-  return urlString.slice(0, colonIndex)
-};
-
-const urlToPathname = (urlString) => {
-  return ressourceToPathname(urlToRessource(urlString))
-};
-
-const urlToRessource = (urlString) => {
-  const scheme = urlToScheme(urlString);
-
-  if (scheme === "file") {
-    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 urlString.slice(scheme.length + 1)
-};
-
-const ressourceToPathname = (ressource) => {
-  const searchSeparatorIndex = ressource.indexOf("?");
-  return searchSeparatorIndex === -1
-    ? ressource
-    : ressource.slice(0, searchSeparatorIndex)
-};
-
-const urlToOrigin = (urlString) => {
-  const scheme = urlToScheme(urlString);
-
-  if (scheme === "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)
-  }
-
-  return urlString.slice(0, scheme.length + 1)
-};
-
-const pathnameToParentPathname = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/");
-  if (slashLastIndex === -1) {
-    return "/"
-  }
-
-  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 }))
-    }
-    if (!hasScheme(baseUrl)) {
-      throw new Error(writeBaseUrlMustBeAbsolute({ baseUrl, specifier }))
-    }
-  }
-
-  if (hasScheme(specifier)) {
-    return specifier
-  }
-
-  if (!baseUrl) {
-    throw new Error(writeBaseUrlRequired({ baseUrl, specifier }))
-  }
-
-  // scheme relative
-  if (specifier.slice(0, 2) === "//") {
-    return `${urlToScheme(baseUrl)}:${specifier}`
-  }
-
-  // origin relative
-  if (specifier[0] === "/") {
-    return `${urlToOrigin(baseUrl)}${specifier}`
-  }
-
-  const baseOrigin = urlToOrigin(baseUrl);
-  const basePathname = urlToPathname(baseUrl);
-
-  if (specifier === ".") {
-    const baseDirectoryPathname = pathnameToParentPathname(basePathname);
-    return `${baseOrigin}${baseDirectoryPathname}`
-  }
-
-  // pathname relative inside
-  if (specifier.slice(0, 2) === "./") {
-    const baseDirectoryPathname = pathnameToParentPathname(basePathname);
-    return `${baseOrigin}${baseDirectoryPathname}${specifier.slice(2)}`
-  }
-
-  // pathname relative outside
-  if (specifier.slice(0, 3) === "../") {
-    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
-      // we just ignore '../'
-      if (importerFolders.length) {
-        importerFolders.pop();
-      }
-    }
-
-    const resolvedPathname = `${importerFolders.join(
-      "/",
-    )}/${unresolvedPathname}`;
-    return `${baseOrigin}${resolvedPathname}`
-  }
-
-  // bare
-  if (basePathname === "") {
-    return `${baseOrigin}/${specifier}`
-  }
-  if (basePathname[basePathname.length] === "/") {
-    return `${baseOrigin}${basePathname}${specifier}`
-  }
-  return `${baseOrigin}${pathnameToParentPathname(basePathname)}${specifier}`
-};
-
-const writeBaseUrlMustBeAString = ({
-  baseUrl,
-  specifier,
-}) => `baseUrl must be a string.
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-
-const writeBaseUrlMustBeAbsolute = ({
-  baseUrl,
-  specifier,
-}) => `baseUrl must be absolute.
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-
-const writeBaseUrlRequired = ({
-  baseUrl,
-  specifier,
-}) => `baseUrl required to resolve relative specifier.
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-
-const tryUrlResolution = (string, url) => {
-  const result = resolveUrl(string, url);
-  return hasScheme(result) ? result : null
-};
-
-const resolveSpecifier = (specifier, importer) => {
-  if (
-    specifier === "." ||
-    specifier[0] === "/" ||
-    specifier.startsWith("./") ||
-    specifier.startsWith("../")
-  ) {
-    return resolveUrl(specifier, importer)
-  }
-
-  if (hasScheme(specifier)) {
-    return specifier
-  }
-
-  return null
-};
-
-const applyImportMap = ({
-  importMap,
-  specifier,
-  importer,
-  createBareSpecifierError = ({ specifier, importer }) => {
-    return new Error(
-      createDetailedMessage(`Unmapped bare specifier.`, {
-        specifier,
-        importer,
-      }),
-    )
-  },
-  onImportMapping = () => {},
-}) => {
-  assertImportMap(importMap);
-  if (typeof specifier !== "string") {
-    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,
-        }),
-      )
-    }
-    if (!hasScheme(importer)) {
-      throw new Error(
-        createDetailedMessage(`importer must be an absolute url.`, {
-          importer,
-          specifier,
-        }),
-      )
-    }
-  }
-
-  const specifierUrl = resolveSpecifier(specifier, importer);
-  const specifierNormalized = specifierUrl || specifier;
-
-  const { scopes } = importMap;
-  if (scopes && 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,
-      );
-      if (mappingFromScopes !== null) {
-        return mappingFromScopes
-      }
-    }
-  }
-
-  const { imports } = importMap;
-  if (imports) {
-    const mappingFromImports = applyMappings(
-      imports,
-      specifierNormalized,
-      undefined,
-      onImportMapping,
-    );
-    if (mappingFromImports !== null) {
-      return mappingFromImports
-    }
-  }
-
-  if (specifierUrl) {
-    return specifierUrl
-  }
-
-  throw createBareSpecifierError({ specifier, importer })
-};
-
-const applyMappings = (
-  mappings,
-  specifierNormalized,
-  scope,
-  onImportMapping,
-) => {
-  const specifierCandidates = Object.keys(mappings);
-
-  let i = 0;
-  while (i < specifierCandidates.length) {
-    const specifierCandidate = specifierCandidates[i];
-    i++;
-    if (specifierCandidate === specifierNormalized) {
-      const address = mappings[specifierCandidate];
-      onImportMapping({
-        scope,
-        from: specifierCandidate,
-        to: address,
-        before: specifierNormalized,
-        after: address,
-      });
-      return address
-    }
-    if (specifierIsPrefixOf(specifierCandidate, specifierNormalized)) {
-      const address = mappings[specifierCandidate];
-      const afterSpecifier = specifierNormalized.slice(
-        specifierCandidate.length,
-      );
-      const addressFinal = tryUrlResolution(afterSpecifier, address);
-      onImportMapping({
-        scope,
-        from: specifierCandidate,
-        to: address,
-        before: specifierNormalized,
-        after: addressFinal,
-      });
-      return addressFinal
-    }
-  }
-
-  return null
-};
-
-const specifierIsPrefixOf = (specifierHref, href) => {
-  return (
-    specifierHref[specifierHref.length - 1] === "/" &&
-    href.startsWith(specifierHref)
-  )
-};
-
-const sortImports = (imports) => {
-  const mappingsSorted = {};
-
-  Object.keys(imports)
-    .sort(compareLengthOrLocaleCompare)
-    .forEach((name) => {
-      mappingsSorted[name] = imports[name];
-    });
-
-  return mappingsSorted
-};
-
-const sortScopes = (scopes) => {
-  const 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)
-};
-
-const normalizeImportMap = (importMap, baseUrl) => {
-  assertImportMap(importMap);
-
-  if (!isStringOrUrl(baseUrl)) {
-    throw new TypeError(formulateBaseUrlMustBeStringOrUrl({ baseUrl }))
-  }
-
-  const { imports, scopes } = importMap;
-
-  return {
-    imports: imports ? normalizeMappings(imports, baseUrl) : undefined,
-    scopes: scopes ? normalizeScopes(scopes, baseUrl) : undefined,
-  }
-};
-
-const isStringOrUrl = (value) => {
-  if (typeof value === "string") {
-    return true
-  }
-
-  if (typeof URL === "function" && value instanceof URL) {
-    return true
-  }
-
-  return false
-};
-
-const normalizeMappings = (mappings, baseUrl) => {
-  const mappingsNormalized = {};
-
-  Object.keys(mappings).forEach((specifier) => {
-    const address = mappings[specifier];
-
-    if (typeof address !== "string") {
-      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
-    }
-
-    if (specifier.endsWith("/") && !addressUrl.endsWith("/")) {
-      console.warn(
-        formulateAddressUrlRequiresTrailingSlash({
-          addressUrl,
-          address,
-          specifier,
-        }),
-      );
-      return
-    }
-    mappingsNormalized[specifierResolved] = addressUrl;
-  });
-
-  return sortImports(mappingsNormalized)
-};
-
-const normalizeScopes = (scopes, baseUrl) => {
-  const scopesNormalized = {};
-
-  Object.keys(scopes).forEach((scopeSpecifier) => {
-    const scopeMappings = scopes[scopeSpecifier];
-    const scopeUrl = tryUrlResolution(scopeSpecifier, baseUrl);
-    if (scopeUrl === null) {
-      console.warn(
-        formulateScopeResolutionFailed({
-          scope: scopeSpecifier,
-          baseUrl,
-        }),
-      );
-      return
-    }
-    const scopeValueNormalized = normalizeMappings(scopeMappings, baseUrl);
-    scopesNormalized[scopeUrl] = scopeValueNormalized;
-  });
-
-  return sortScopes(scopesNormalized)
-};
-
-const formulateBaseUrlMustBeStringOrUrl = ({
-  baseUrl,
-}) => `baseUrl must be a string or an url.
---- base url ---
-${baseUrl}`;
-
-const formulateAddressMustBeAString = ({
-  specifier,
-  address,
-}) => `Address must be a string.
---- address ---
-${address}
---- specifier ---
-${specifier}`;
-
-const formulateAdressResolutionFailed = ({
-  address,
-  baseUrl,
-  specifier,
-}) => `Address url resolution failed.
---- address ---
-${address}
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-
-const formulateAddressUrlRequiresTrailingSlash = ({
-  addressURL,
-  address,
-  specifier,
-}) => `Address must end with /.
---- address url ---
-${addressURL}
---- address ---
-${address}
---- specifier ---
-${specifier}`;
-
-const formulateScopeResolutionFailed = ({
-  scope,
-  baseUrl,
-}) => `Scope url resolution failed.
---- scope ---
-${scope}
---- base url ---
-${baseUrl}`;
-
-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 === pathname.length - 1) return ""
-  return pathname.slice(dotLastIndex)
-};
-
-const resolveImport = ({
-  specifier,
-  importer,
-  importMap,
-  defaultExtension = false,
-  createBareSpecifierError,
-  onImportMapping = () => {},
-}) => {
-  let url;
-  if (importMap) {
-    url = applyImportMap({
-      importMap,
-      specifier,
-      importer,
-      createBareSpecifierError,
-      onImportMapping,
-    });
-  } else {
-    url = resolveUrl(specifier, importer);
-  }
-
-  if (defaultExtension) {
-    url = applyDefaultExtension({ url, importer, defaultExtension });
-  }
-
-  return url
-};
-
-const applyDefaultExtension = ({ url, importer, defaultExtension }) => {
-  if (urlToPathname(url).endsWith("/")) {
-    return url
-  }
-
-  if (typeof defaultExtension === "string") {
-    const extension = pathnameToExtension(url);
-    if (extension === "") {
-      return `${url}${defaultExtension}`
-    }
-    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
-};
-
 let importMap;
 
 const cwdUrl = `${String(pathToFileURL(process.cwd()))}/`;

package/dist/js/importmap_node_loader.mjs

@@ -0,0 +1,3 @@
+import { register } from "node:module";
+
+register(new URL("./importmap_hooks.mjs", import.meta.url));

package/dist/{node_child_process_controlled.mjs → js/node_child_process_controlled.mjs}

@@ -1,6 +1,6 @@
 import { createException } from "@jsenv/exception";
 import { memoryUsage } from "node:process";
-import { executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
+import { executeUsingDynamicImport } from "./execute_using_dynamic_import.js";
 import "node:fs";
 import "node:perf_hooks";
 import "node:inspector";

package/dist/{node_worker_thread_controlled.mjs → js/node_worker_thread_controlled.mjs}

@@ -3,7 +3,7 @@ import { memoryUsage } from "node:process";
 import { setFlagsFromString } from "node:v8";
 import { runInNewContext } from "node:vm";
 import { parentPort } from "node:worker_threads";
-import { executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
+import { executeUsingDynamicImport } from "./execute_using_dynamic_import.js";
 import "node:fs";
 import "node:perf_hooks";
 import "node:inspector";