@jsenv/test 3.7.2 → 3.7.4

package/dist/exception.js

@@ -633,7 +633,7 @@ const isDev = process.execArgv.some(
 const createException = (
   reason,
   {
-    jsenvCoreDirectoryUrl = new URL("../../../../../", import.meta.url),
+    jsenvCoreDirectoryUrl = import.meta.resolve("../../../../"),
     rootDirectoryUrl,
     errorTransform = () => {},
   } = {},

package/dist/js/importmap_hooks.mjs

@@ -1,6 +1,23 @@
 import { readFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 
+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}`,
+    );
+  }
+};
+
 // duplicated from @jsenv/log to avoid the dependency
 const createDetailedMessage = (message, details = {}) => {
   let string = `${message}`;
@@ -17,89 +34,72 @@ const createDetailedMessage = (message, details = {}) => {
     }`;
   });
 
-  return string
+  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}`)
-  }
+const hasScheme = (string) => {
+  return /^[a-zA-Z]{2,}:/.test(string);
+};
 
-  if (Array.isArray(value)) {
-    throw new TypeError(
-      `an importMap must be an object, received array ${value}`,
-    )
+const pathnameToParentPathname = (pathname) => {
+  const slashLastIndex = pathname.lastIndexOf("/");
+  if (slashLastIndex === -1) {
+    return "/";
   }
-};
 
-const hasScheme = (string) => {
-  return /^[a-zA-Z]{2,}:/.test(string)
+  return pathname.slice(0, slashLastIndex + 1);
 };
 
 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 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 urlToPathname = (urlString) => {
-  return ressourceToPathname(urlToRessource(urlString))
+  return ressourceToPathname(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 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)
+    : ressource.slice(0, searchSeparatorIndex);
 };
 
 // could be useful: https://url.spec.whatwg.org/#url-miscellaneous
@@ -108,29 +108,29 @@ const pathnameToParentPathname = (pathname) => {
 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);
@@ -138,13 +138,13 @@ const resolveUrl = (specifier, 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
@@ -165,17 +165,17 @@ const resolveUrl = (specifier, baseUrl) => {
     const resolvedPathname = `${importerFolders.join(
       "/",
     )}/${unresolvedPathname}`;
-    return `${baseOrigin}${resolvedPathname}`
+    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 = ({
@@ -207,7 +207,7 @@ ${specifier}`;
 
 const tryUrlResolution = (string, url) => {
   const result = resolveUrl(string, url);
-  return hasScheme(result) ? result : null
+  return hasScheme(result) ? result : null;
 };
 
 const resolveSpecifier = (specifier, importer) => {
@@ -217,14 +217,14 @@ const resolveSpecifier = (specifier, importer) => {
     specifier.startsWith("./") ||
     specifier.startsWith("../")
   ) {
-    return resolveUrl(specifier, importer)
+    return resolveUrl(specifier, importer);
   }
 
   if (hasScheme(specifier)) {
-    return specifier
+    return specifier;
   }
 
-  return null
+  return null;
 };
 
 const applyImportMap = ({
@@ -237,7 +237,7 @@ const applyImportMap = ({
         specifier,
         importer,
       }),
-    )
+    );
   },
   onImportMapping = () => {},
 }) => {
@@ -248,7 +248,7 @@ const applyImportMap = ({
         specifier,
         importer,
       }),
-    )
+    );
   }
   if (importer) {
     if (typeof importer !== "string") {
@@ -257,7 +257,7 @@ const applyImportMap = ({
           importer,
           specifier,
         }),
-      )
+      );
     }
     if (!hasScheme(importer)) {
       throw new Error(
@@ -265,7 +265,7 @@ const applyImportMap = ({
           importer,
           specifier,
         }),
-      )
+      );
     }
   }
 
@@ -279,7 +279,7 @@ const applyImportMap = ({
         return (
           scopeSpecifier === importer ||
           specifierIsPrefixOf(scopeSpecifier, importer)
-        )
+        );
       },
     );
     if (scopeSpecifierMatching) {
@@ -291,7 +291,7 @@ const applyImportMap = ({
         onImportMapping,
       );
       if (mappingFromScopes !== null) {
-        return mappingFromScopes
+        return mappingFromScopes;
       }
     }
   }
@@ -305,15 +305,15 @@ const applyImportMap = ({
       onImportMapping,
     );
     if (mappingFromImports !== null) {
-      return mappingFromImports
+      return mappingFromImports;
     }
   }
 
   if (specifierUrl) {
-    return specifierUrl
+    return specifierUrl;
   }
 
-  throw createBareSpecifierError({ specifier, importer })
+  throw createBareSpecifierError({ specifier, importer });
 };
 
 const applyMappings = (
@@ -337,7 +337,7 @@ const applyMappings = (
         before: specifierNormalized,
         after: address,
       });
-      return address
+      return address;
     }
     if (specifierIsPrefixOf(specifierCandidate, specifierNormalized)) {
       const address = mappings[specifierCandidate];
@@ -352,18 +352,18 @@ const applyMappings = (
         before: specifierNormalized,
         after: addressFinal,
       });
-      return addressFinal
+      return addressFinal;
     }
   }
 
-  return null
+  return null;
 };
 
 const specifierIsPrefixOf = (specifierHref, href) => {
   return (
     specifierHref[specifierHref.length - 1] === "/" &&
     href.startsWith(specifierHref)
-  )
+  );
 };
 
 const sortImports = (imports) => {
@@ -375,7 +375,7 @@ const sortImports = (imports) => {
       mappingsSorted[name] = imports[name];
     });
 
-  return mappingsSorted
+  return mappingsSorted;
 };
 
 const sortScopes = (scopes) => {
@@ -387,18 +387,18 @@ const sortScopes = (scopes) => {
       scopesSorted[scopeSpecifier] = sortImports(scopes[scopeSpecifier]);
     });
 
-  return scopesSorted
+  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 }))
+    throw new TypeError(formulateBaseUrlMustBeStringOrUrl({ baseUrl }));
   }
 
   const { imports, scopes } = importMap;
@@ -406,19 +406,19 @@ const normalizeImportMap = (importMap, baseUrl) => {
   return {
     imports: imports ? normalizeMappings(imports, baseUrl) : undefined,
     scopes: scopes ? normalizeScopes(scopes, baseUrl) : undefined,
-  }
+  };
 };
 
 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) => {
@@ -434,7 +434,7 @@ const normalizeMappings = (mappings, baseUrl) => {
           specifier,
         }),
       );
-      return
+      return;
     }
 
     const specifierResolved = resolveSpecifier(specifier, baseUrl) || specifier;
@@ -448,7 +448,7 @@ const normalizeMappings = (mappings, baseUrl) => {
           specifier,
         }),
       );
-      return
+      return;
     }
 
     if (specifier.endsWith("/") && !addressUrl.endsWith("/")) {
@@ -458,12 +458,12 @@ const normalizeMappings = (mappings, baseUrl) => {
           specifier,
         }),
       );
-      return
+      return;
     }
     mappingsNormalized[specifierResolved] = addressUrl;
   });
 
-  return sortImports(mappingsNormalized)
+  return sortImports(mappingsNormalized);
 };
 
 const normalizeScopes = (scopes, baseUrl) => {
@@ -479,13 +479,13 @@ const normalizeScopes = (scopes, baseUrl) => {
           baseUrl,
         }),
       );
-      return
+      return;
     }
     const scopeValueNormalized = normalizeMappings(scopeMappings, baseUrl);
     scopesNormalized[scopeUrl] = scopeValueNormalized;
   });
 
-  return sortScopes(scopesNormalized)
+  return sortScopes(scopesNormalized);
 };
 
 const formulateBaseUrlMustBeStringOrUrl = ({
@@ -543,9 +543,9 @@ const pathnameToExtension = (pathname) => {
   }
 
   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 = ({
@@ -573,20 +573,20 @@ const resolveImport = ({
     url = applyDefaultExtension({ url, importer, defaultExtension });
   }
 
-  return url
+  return url;
 };
 
 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) {
@@ -594,11 +594,11 @@ const applyDefaultExtension = ({ url, importer, defaultExtension }) => {
     if (extension === "" && importer) {
       const importerPathname = urlToPathname(importer);
       const importerExtension = pathnameToExtension(importerPathname);
-      return `${url}${importerExtension}`
+      return `${url}${importerExtension}`;
     }
   }
 
-  return url
+  return url;
 };
 
 let importMap;

package/dist/jsenv_test.js

@@ -527,6 +527,60 @@ const SIGINT_CALLBACK = {
   },
 };
 
+const isFileSystemPath = (value) => {
+  if (typeof value !== "string") {
+    throw new TypeError(
+      `isFileSystemPath first arg must be a string, got ${value}`,
+    );
+  }
+  if (value[0] === "/") {
+    return true;
+  }
+  return startsWithWindowsDriveLetter(value);
+};
+
+const startsWithWindowsDriveLetter = (string) => {
+  const firstChar = string[0];
+  if (!/[a-zA-Z]/.test(firstChar)) return false;
+
+  const secondChar = string[1];
+  if (secondChar !== ":") return false;
+
+  return true;
+};
+
+const fileSystemPathToUrl = (value) => {
+  if (!isFileSystemPath(value)) {
+    throw new Error(`value must be a filesystem path, got ${value}`);
+  }
+  return String(pathToFileURL(value));
+};
+
+const urlToFileSystemPath = (url) => {
+  const urlObject = new URL(url);
+  let { origin, pathname, hash } = urlObject;
+  if (urlObject.protocol === "file:") {
+    origin = "file://";
+  }
+  pathname = pathname
+    .split("/")
+    .map((part) => {
+      return part.replace(/%(?![0-9A-F][0-9A-F])/g, "%25");
+    })
+    .join("/");
+  if (hash) {
+    pathname += `%23${encodeURIComponent(hash.slice(1))}`;
+  }
+  const urlString = `${origin}${pathname}`;
+  const fileSystemPath = fileURLToPath(urlString);
+  if (fileSystemPath[fileSystemPath.length - 1] === "/") {
+    // remove trailing / so that nodejs path becomes predictable otherwise it logs
+    // the trailing slash on linux but does not on windows
+    return fileSystemPath.slice(0, -1);
+  }
+  return fileSystemPath;
+};
+
 const createDetailedMessage = (message, details = {}) => {
   let text = `${message}`;
   const namedSectionsText = renderNamedSections(details);
@@ -1706,42 +1760,6 @@ const ensurePathnameTrailingSlash = (url) => {
   });
 };
 
-const isFileSystemPath = (value) => {
-  if (typeof value !== "string") {
-    throw new TypeError(
-      `isFileSystemPath first arg must be a string, got ${value}`,
-    );
-  }
-  if (value[0] === "/") {
-    return true;
-  }
-  return startsWithWindowsDriveLetter(value);
-};
-
-const startsWithWindowsDriveLetter = (string) => {
-  const firstChar = string[0];
-  if (!/[a-zA-Z]/.test(firstChar)) return false;
-
-  const secondChar = string[1];
-  if (secondChar !== ":") return false;
-
-  return true;
-};
-
-const fileSystemPathToUrl = (value) => {
-  if (!isFileSystemPath(value)) {
-    throw new Error(`value must be a filesystem path, got ${value}`);
-  }
-  return String(pathToFileURL(value));
-};
-
-const resolveUrl = (specifier, baseUrl) => {
-  if (typeof baseUrl === "undefined") {
-    throw new TypeError(`baseUrl missing to resolve ${specifier}`);
-  }
-  return String(new URL(specifier, baseUrl));
-};
-
 const getCommonPathname = (pathname, otherPathname) => {
   if (pathname === otherPathname) {
     return pathname;
@@ -1851,6 +1869,13 @@ const moveUrl = ({ url, from, to, preferRelative }) => {
   return absoluteUrl;
 };
 
+const resolveUrl = (specifier, baseUrl) => {
+  if (typeof baseUrl === "undefined") {
+    throw new TypeError(`baseUrl missing to resolve ${specifier}`);
+  }
+  return String(new URL(specifier, baseUrl));
+};
+
 const urlIsInsideOf = (url, otherUrl) => {
   const urlObject = new URL(url);
   const otherUrlObject = new URL(otherUrl);
@@ -1869,31 +1894,6 @@ const urlIsInsideOf = (url, otherUrl) => {
   return isInside;
 };
 
-const urlToFileSystemPath = (url) => {
-  const urlObject = new URL(url);
-  let { origin, pathname, hash } = urlObject;
-  if (urlObject.protocol === "file:") {
-    origin = "file://";
-  }
-  pathname = pathname
-    .split("/")
-    .map((part) => {
-      return part.replace(/%(?![0-9A-F][0-9A-F])/g, "%25");
-    })
-    .join("/");
-  if (hash) {
-    pathname += `%23${encodeURIComponent(hash.slice(1))}`;
-  }
-  const urlString = `${origin}${pathname}`;
-  const fileSystemPath = fileURLToPath(urlString);
-  if (fileSystemPath[fileSystemPath.length - 1] === "/") {
-    // remove trailing / so that nodejs path becomes predictable otherwise it logs
-    // the trailing slash on linux but does not on windows
-    return fileSystemPath.slice(0, -1);
-  }
-  return fileSystemPath;
-};
-
 const validateDirectoryUrl = (value) => {
   let urlString;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/test",
-  "version": "3.7.2",
+  "version": "3.7.4",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -45,9 +45,9 @@
   },
   "dependencies": {
     "@c88/v8-coverage": "0.1.1",
-    "@jsenv/ast": "6.7.0",
-    "@jsenv/plugin-supervisor": "1.6.16",
-    "@jsenv/sourcemap": "1.3.7",
+    "@jsenv/ast": "6.7.2",
+    "@jsenv/plugin-supervisor": "1.7.0",
+    "@jsenv/sourcemap": "1.3.8",
     "he": "1.2.0",
     "istanbul-lib-coverage": "3.2.2",
     "istanbul-lib-instrument": "6.0.3",
@@ -57,16 +57,26 @@
     "v8-to-istanbul": "9.3.0"
   },
   "devDependencies": {
-    "@jsenv/abort": "4.3.1",
-    "@jsenv/exception": "1.2.0",
-    "@jsenv/filesystem": "4.15.2",
-    "@jsenv/github-check-run": "0.3.1",
-    "@jsenv/node-esm-resolution": "1.2.1",
-    "@jsenv/url-meta": "8.5.7",
-    "@jsenv/urls": "2.7.4",
-    "@jsenv/utils": "2.3.1",
-    "@jsenv/humanize": "1.5.2",
+    "@jsenv/assert": "../tooling/assert",
+    "@jsenv/snapshot": "../tooling/snapshot",
+    "@jsenv/terminal-recorder": "../tooling/terminal-recorder",
+    "@jsenv/server": "../backend/server",
+    "@jsenv/core": "../../",
+    "@jsenv/os-metrics": "../../tooling/os-metrics",
+    "@jsenv/importmap": "../../tooling/importmap",
+    "@jsenv/plugin-explorer": "../plugin-explorer",
+    "@jsenv/test": "./",
+    "@jsenv/abort": "../../tooling/abort",
+    "@jsenv/exception": "../../backend/exception",
+    "@jsenv/filesystem": "../../backend/filesystem",
+    "@jsenv/github-check-run": "../../tooling/github-check-run",
+    "@jsenv/node-esm-resolution": "../../tooling/node-esm-resolution",
+    "@jsenv/url-meta": "../../tooling/url-meta",
+    "@jsenv/urls": "../../tooling/urls",
+    "@jsenv/utils": "../../tooling/utils",
+    "@jsenv/humanize": "../../tooling/humanize",
     "strip-ansi": "7.1.0",
-    "supports-color": "10.0.0"
+    "supports-color": "10.0.0",
+    "prettier": "3.5.3"
   }
 }