@jsenv/core 40.0.10 → 40.1.1

package/src/plugins/directory_reference_effect/jsenv_plugin_directory_reference_effect.js

@@ -1,9 +1,28 @@
+import { URL_META } from "@jsenv/url-meta";
 import { urlToFilename } from "@jsenv/urls";
 import { defineNonEnumerableProperties } from "../../kitchen/errors.js";
 
 export const jsenvPluginDirectoryReferenceEffect = (
   directoryReferenceEffect = "error",
+  { rootDirectoryUrl },
 ) => {
+  let getDirectoryReferenceEffect;
+  if (typeof directoryReferenceEffect === "string") {
+    getDirectoryReferenceEffect = () => directoryReferenceEffect;
+  } else if (typeof directoryReferenceEffect === "function") {
+    getDirectoryReferenceEffect = directoryReferenceEffect;
+  } else if (typeof directoryReferenceEffect === "object") {
+    const associations = URL_META.resolveAssociations(
+      { effect: directoryReferenceEffect },
+      rootDirectoryUrl,
+    );
+    getDirectoryReferenceEffect = (reference) => {
+      const { url } = reference;
+      const meta = URL_META.applyAssociations({ url, associations });
+      return meta.effect || "error";
+    };
+  }
+
   return {
     name: "jsenv:directory_reference_effect",
     appliesDuring: "*",
@@ -41,12 +60,8 @@ export const jsenvPluginDirectoryReferenceEffect = (
         actionForDirectory = "copy";
       } else if (reference.type === "http_request") {
         actionForDirectory = "preserve";
-      } else if (typeof directoryReferenceEffect === "string") {
-        actionForDirectory = directoryReferenceEffect;
-      } else if (typeof directoryReferenceEffect === "function") {
-        actionForDirectory = directoryReferenceEffect(reference);
       } else {
-        actionForDirectory = "error";
+        actionForDirectory = getDirectoryReferenceEffect(reference);
       }
       reference.actionForDirectory = actionForDirectory;
       if (actionForDirectory !== "copy") {

package/src/plugins/plugins.js

@@ -32,6 +32,7 @@ export const getCorePlugins = ({
 
   referenceAnalysis = {},
   nodeEsmResolution = {},
+  packageConditions,
   magicExtensions,
   magicDirectoryIndex,
   directoryListing = true,
@@ -102,10 +103,12 @@ export const getCorePlugins = ({
       },
     },
     ...(nodeEsmResolution
-      ? [jsenvPluginNodeEsmResolution(nodeEsmResolution)]
+      ? [jsenvPluginNodeEsmResolution(nodeEsmResolution, packageConditions)]
       : []),
     jsenvPluginWebResolution(),
-    jsenvPluginDirectoryReferenceEffect(directoryReferenceEffect),
+    jsenvPluginDirectoryReferenceEffect(directoryReferenceEffect, {
+      rootDirectoryUrl,
+    }),
     jsenvPluginVersionSearchParam(),
 
     // "jsenvPluginSupervisor" MUST be after "jsenvPluginInlining" as it needs inline script to be cooked

package/src/plugins/protocol_file/jsenv_plugin_directory_listing.js

@@ -23,7 +23,7 @@
  */
 
 import {
-  comparePathnames,
+  compareFileUrls,
   lookupPackageDirectory,
   readEntryStatSync,
   registerDirectoryLifecycle,
@@ -399,9 +399,8 @@ const getDirectoryContentItems = ({
       fileUrls.push(fileUrlObject);
     }
   }
-  fileUrls.sort((a, b) => {
-    return comparePathnames(a.pathname, b.pathname);
-  });
+  fileUrls.sort(compareFileUrls);
+
   const items = [];
   for (const fileUrl of fileUrls) {
     const urlRelativeToCurrentDirectory = urlToRelativeUrl(

package/src/plugins/reference_analysis/jsenv_plugin_reference_analysis.js

@@ -10,12 +10,9 @@ export const jsenvPluginReferenceAnalysis = ({
   inlineContent = true,
   inlineConvertedScript = false,
   fetchInlineUrls = true,
-  directoryReferenceEffect,
 }) => {
   return [
-    jsenvPluginDirectoryReferenceAnalysis({
-      directoryReferenceEffect,
-    }),
+    jsenvPluginDirectoryReferenceAnalysis(),
     jsenvPluginHtmlReferenceAnalysis({
       inlineContent,
       inlineConvertedScript,

package/src/plugins/resolution_node_esm/jsenv_plugin_node_esm_resolution.js

@@ -1,8 +1,33 @@
 import { createNodeEsmResolver } from "./node_esm_resolver.js";
 
-export const jsenvPluginNodeEsmResolution = (resolutionConfig = {}) => {
+export const jsenvPluginNodeEsmResolution = (
+  resolutionConfig = {},
+  packageConditions,
+) => {
   let nodeEsmResolverDefault;
-  const resolvers = {};
+  const resolverMap = new Map();
+  let anyTypeResolver;
+
+  const resolverFromObject = (
+    { preservesSymlink, ...rest },
+    { kitchenContext, urlType },
+  ) => {
+    const unexpectedKeys = Object.keys(rest);
+    if (unexpectedKeys.length) {
+      throw new TypeError(
+        `${unexpectedKeys.join(
+          ",",
+        )}: there is no such configuration on "${urlType}"`,
+      );
+    }
+    return createNodeEsmResolver({
+      build: kitchenContext.build,
+      runtimeCompat: kitchenContext.runtimeCompat,
+      rootDirectoryUrl: kitchenContext.rootDirectoryUrl,
+      packageConditions,
+      preservesSymlink,
+    });
+  };
 
   return {
     name: "jsenv:node_esm_resolution",
@@ -11,47 +36,38 @@ export const jsenvPluginNodeEsmResolution = (resolutionConfig = {}) => {
       nodeEsmResolverDefault = createNodeEsmResolver({
         build: kitchenContext.build,
         runtimeCompat: kitchenContext.runtimeCompat,
+        rootDirectoryUrl: kitchenContext.rootDirectoryUrl,
         preservesSymlink: true,
+        packageConditions,
       });
-      Object.keys(resolutionConfig).forEach((urlType) => {
+      for (const urlType of Object.keys(resolutionConfig)) {
+        let resolver;
         const config = resolutionConfig[urlType];
         if (config === true) {
-          resolvers[urlType] = (...args) => nodeEsmResolverDefault(...args);
+          resolver = nodeEsmResolverDefault;
         } else if (config === false) {
-          resolvers[urlType] = () => null;
+          // resolverMap.set(urlType, () => null);
+          continue;
         } else if (typeof config === "object") {
-          const {
-            runtimeCompat,
-            packageConditions,
-            preservesSymlink,
-            ...rest
-          } = config;
-          const unexpectedKeys = Object.keys(rest);
-          if (unexpectedKeys.length) {
-            throw new TypeError(
-              `${unexpectedKeys.join(
-                ",",
-              )}: there is no such configuration on "${urlType}"`,
-            );
-          }
-          resolvers[urlType] = createNodeEsmResolver({
-            build: kitchenContext.build,
-            runtimeCompat,
-            packageConditions,
-            preservesSymlink,
-          });
+          resolver = resolverFromObject(config, { kitchenContext, urlType });
         } else {
           throw new TypeError(
-            `config must be true, false or an object, got ${config} on "${urlType}"`,
+            `The value "${config}" for ${urlType} in nodeEsmResolution is invalid: it must be true, false or an object.`,
           );
         }
-      });
 
-      if (resolvers.js_module === undefined) {
-        resolvers.js_module = nodeEsmResolverDefault;
+        if (urlType === "*") {
+          anyTypeResolver = resolver;
+        } else {
+          resolverMap.set(urlType, resolver);
+        }
+      }
+
+      if (!resolverMap.has("js_module")) {
+        resolverMap.set("js_module", nodeEsmResolverDefault);
       }
-      if (resolvers.js_classic === undefined) {
-        resolvers.js_classic = (reference) => {
+      if (!resolverMap.has("js_classic")) {
+        resolverMap.set("js_classic", (reference) => {
           if (reference.subtype === "self_import_scripts_arg") {
             return nodeEsmResolverDefault(reference);
           }
@@ -60,7 +76,7 @@ export const jsenvPluginNodeEsmResolution = (resolutionConfig = {}) => {
             return nodeEsmResolverDefault(reference);
           }
           return null;
-        };
+        });
       }
     },
     resolveReference: (reference) => {
@@ -70,8 +86,14 @@ export const jsenvPluginNodeEsmResolution = (resolutionConfig = {}) => {
         return result;
       }
       const urlType = urlTypeFromReference(reference);
-      const resolver = resolvers[urlType];
-      return resolver ? resolver(reference) : null;
+      const resolver = resolverMap.get(urlType);
+      if (resolver) {
+        return resolver(reference);
+      }
+      if (anyTypeResolver) {
+        return anyTypeResolver(reference);
+      }
+      return null;
     },
     // when specifier is prefixed by "file:///@ignore/"
     // we return an empty js module

package/src/plugins/resolution_node_esm/node_esm_resolver.js

@@ -13,22 +13,23 @@ import {
   defaultReadPackageJson,
   readCustomConditionsFromProcessArgs,
 } from "@jsenv/node-esm-resolution";
+import { URL_META } from "@jsenv/url-meta";
 import { urlToBasename, urlToExtension } from "@jsenv/urls";
 import { readFileSync } from "node:fs";
 
 export const createNodeEsmResolver = ({
-  build,
   runtimeCompat,
-  packageConditions,
+  rootDirectoryUrl,
+  packageConditions = {},
   preservesSymlink,
 }) => {
-  const nodeRuntimeEnabled = Object.keys(runtimeCompat).includes("node");
-  // https://nodejs.org/api/esm.html#resolver-algorithm-specification
-  packageConditions = packageConditions || [
-    ...(build ? [] : readCustomConditionsFromProcessArgs()),
-    nodeRuntimeEnabled ? "node" : "browser",
-    "import",
-  ];
+  const buildPackageConditions = createBuildPackageConditions(
+    packageConditions,
+    {
+      rootDirectoryUrl,
+      runtimeCompat,
+    },
+  );
 
   return (reference) => {
     if (reference.type === "package_json") {
@@ -49,10 +50,12 @@ export const createNodeEsmResolver = ({
     if (!parentUrl.startsWith("file:")) {
       return null; // let it to jsenv_web_resolution
     }
+    const { specifier } = reference;
+    const conditions = buildPackageConditions(specifier, parentUrl);
     const { url, type, isMain, packageDirectoryUrl } = applyNodeEsmResolution({
-      conditions: packageConditions,
+      conditions,
       parentUrl,
-      specifier: reference.specifier,
+      specifier,
       preservesSymlink,
     });
     // try to give a more meaningful filename after build
@@ -116,6 +119,107 @@ export const createNodeEsmResolver = ({
   };
 };
 
+const createBuildPackageConditions = (
+  packageConditions,
+  { rootDirectoryUrl, runtimeCompat },
+) => {
+  const nodeRuntimeEnabled = Object.keys(runtimeCompat).includes("node");
+  // https://nodejs.org/api/esm.html#resolver-algorithm-specification
+  const processArgConditions = readCustomConditionsFromProcessArgs();
+  const packageConditionsDefaultResolvers = {};
+  for (const processArgCondition of processArgConditions) {
+    packageConditionsDefaultResolvers[processArgCondition] = true;
+  }
+  const packageConditionResolvers = {
+    ...packageConditionsDefaultResolvers,
+    development: (specifier, importer) => {
+      if (isBareSpecifier(specifier)) {
+        const { url } = applyNodeEsmResolution({
+          specifier,
+          parentUrl: importer,
+        });
+        return !url.includes("/node_modules/");
+      }
+      return !importer.includes("/node_modules/");
+    },
+    node: nodeRuntimeEnabled,
+    browser: !nodeRuntimeEnabled,
+    import: true,
+  };
+  for (const condition of Object.keys(packageConditions)) {
+    const value = packageConditions[condition];
+    let customResolver;
+    if (typeof value === "object") {
+      const associations = URL_META.resolveAssociations(
+        { applies: value },
+        (pattern) => {
+          if (isBareSpecifier(pattern)) {
+            try {
+              if (pattern.endsWith("/")) {
+                // avoid package path not exported
+                const { packageDirectoryUrl } = applyNodeEsmResolution({
+                  specifier: pattern.slice(0, -1),
+                  parentUrl: rootDirectoryUrl,
+                });
+                return packageDirectoryUrl;
+              }
+              const { url } = applyNodeEsmResolution({
+                specifier: pattern,
+                parentUrl: rootDirectoryUrl,
+              });
+              return url;
+            } catch {
+              return new URL(pattern, rootDirectoryUrl);
+            }
+          }
+          return new URL(pattern, rootDirectoryUrl);
+        },
+      );
+      customResolver = (specifier, importer) => {
+        if (isBareSpecifier(specifier)) {
+          const { url } = applyNodeEsmResolution({
+            specifier,
+            parentUrl: importer,
+          });
+          const { applies } = URL_META.applyAssociations({ url, associations });
+          return applies;
+        }
+        return URL_META.applyAssociations({ url: importer, associations })
+          .applies;
+      };
+    } else if (typeof value === "function") {
+      customResolver = value;
+    } else {
+      customResolver = () => value;
+    }
+    const existing = packageConditionResolvers[condition];
+    if (existing) {
+      packageConditionResolvers[condition] = (...args) => {
+        const customResult = customResolver(...args);
+        return customResult === undefined ? existing(...args) : customResult;
+      };
+    } else {
+      packageConditionResolvers[condition] = customResolver;
+    }
+  }
+
+  return (specifier, importer) => {
+    const conditions = [];
+    for (const conditionCandidate of Object.keys(packageConditionResolvers)) {
+      const packageConditionResolver =
+        packageConditionResolvers[conditionCandidate];
+      if (typeof packageConditionResolver === "function") {
+        if (packageConditionResolver(specifier, importer)) {
+          conditions.push(conditionCandidate);
+        }
+      } else if (packageConditionResolver) {
+        conditions.push(conditionCandidate);
+      }
+    }
+    return conditions;
+  };
+};
+
 const addRelationshipWithPackageJson = ({
   reference,
   packageJsonUrl,
@@ -149,3 +253,20 @@ const addRelationshipWithPackageJson = ({
     );
   }
 };
+
+const isBareSpecifier = (specifier) => {
+  if (
+    specifier[0] === "/" ||
+    specifier.startsWith("./") ||
+    specifier.startsWith("../")
+  ) {
+    return false;
+  }
+  try {
+    // eslint-disable-next-line no-new
+    new URL(specifier);
+    return false;
+  } catch {
+    return true;
+  }
+};

package/src/build/jsenv_plugin_subbuilds.js

@@ -1,76 +0,0 @@
-import { urlToRelativeUrl } from "@jsenv/urls";
-import { defaultRuntimeCompat, getDefaultBase } from "./build_params.js";
-
-export const jsenvPluginSubbuilds = (
-  subBuildParamsArray,
-  { parentBuildParams, onCustomBuildDirectory, buildStart },
-) => {
-  if (subBuildParamsArray.length === 0) {
-    return [];
-  }
-  return subBuildParamsArray.map((subBuildParams, index) => {
-    const defaultChildBuildParams = {};
-    const childBuildParams = {
-      ...parentBuildParams,
-      logs: {
-        level: "warn",
-        disabled: true,
-      },
-      ...defaultChildBuildParams,
-      ...subBuildParams,
-      outDirectoryUrl: new URL(
-        `./subbuild_${index}/`,
-        parentBuildParams.outDirectoryUrl,
-      ),
-    };
-    const subBuildDirectoryUrl = subBuildParams.buildDirectoryUrl;
-    if (subBuildDirectoryUrl) {
-      const subBuildRelativeUrl = urlToRelativeUrl(
-        subBuildDirectoryUrl,
-        parentBuildParams.buildDirectoryUrl,
-      );
-      childBuildParams.base =
-        parentBuildParams.base === "./"
-          ? `./`
-          : subBuildParams.base ||
-            getDefaultBase(
-              childBuildParams.runtimeCompat || defaultRuntimeCompat,
-            );
-      onCustomBuildDirectory(subBuildRelativeUrl);
-    }
-    const buildPromise = buildStart(childBuildParams, index);
-    const entryPointBuildUrlMap = new Map();
-    const entryPointSourceUrlSet = new Set();
-    const entryPointBuildUrlSet = new Set();
-    const childBuildEntryPoints = childBuildParams.entryPoints;
-    for (const key of Object.keys(childBuildEntryPoints)) {
-      const entryPointUrl = new URL(key, childBuildParams.sourceDirectoryUrl)
-        .href;
-      const entryPointBuildUrl = new URL(
-        childBuildEntryPoints[key],
-        childBuildParams.buildDirectoryUrl,
-      ).href;
-      entryPointBuildUrlMap.set(entryPointUrl, entryPointBuildUrl);
-      entryPointSourceUrlSet.add(entryPointUrl);
-      entryPointBuildUrlSet.add(entryPointBuildUrl);
-    }
-
-    return {
-      name: `jsenv:subbuild_${index}`,
-      redirectReference: (reference) => {
-        const entryPointBuildUrl = entryPointBuildUrlMap.get(reference.url);
-        if (!entryPointBuildUrl) {
-          return null;
-        }
-        return entryPointBuildUrl;
-      },
-      fetchUrlContent: async (urlInfo) => {
-        if (!entryPointBuildUrlSet.has(urlInfo.url)) {
-          return;
-        }
-        await buildPromise;
-        urlInfo.typeHint = "asset"; // this ensure the rest of jsenv do not scan or modify the content of this file
-      },
-    };
-  });
-};

package/src/kitchen/url_graph/url_graph_report.js

@@ -1,202 +0,0 @@
-import { ANSI, distributePercentages, humanizeFileSize } from "@jsenv/humanize";
-
-import { GRAPH_VISITOR } from "./url_graph_visitor.js";
-
-export const createUrlGraphSummary = (
-  urlGraph,
-  { title = "graph summary" } = {},
-) => {
-  const graphReport = createUrlGraphReport(urlGraph);
-  return `--- ${title} ---  
-${createRepartitionMessage(graphReport)}
---------------------`;
-};
-
-const createUrlGraphReport = (urlGraph) => {
-  const countGroups = {
-    sourcemaps: 0,
-    html: 0,
-    css: 0,
-    js: 0,
-    json: 0,
-    other: 0,
-    total: 0,
-  };
-  const sizeGroups = {
-    sourcemaps: 0,
-    html: 0,
-    css: 0,
-    js: 0,
-    json: 0,
-    other: 0,
-    total: 0,
-  };
-
-  GRAPH_VISITOR.forEachUrlInfoStronglyReferenced(
-    urlGraph.rootUrlInfo,
-    (urlInfo) => {
-      // ignore:
-      // - ignored files: we don't know their content
-      // - inline files and data files: they are already taken into account in the file where they appear
-      if (urlInfo.url.startsWith("ignore:")) {
-        return;
-      }
-      if (urlInfo.isInline) {
-        return;
-      }
-      if (urlInfo.url.startsWith("data:")) {
-        return;
-      }
-
-      // file loaded via import assertion are already inside the graph
-      // their js module equivalent are ignored to avoid counting it twice
-      // in the build graph the file targeted by import assertion will likely be gone
-      // and only the js module remain (likely bundled)
-      if (
-        urlInfo.searchParams.has("as_json_module") ||
-        urlInfo.searchParams.has("as_css_module") ||
-        urlInfo.searchParams.has("as_text_module")
-      ) {
-        return;
-      }
-
-      const urlContentSize = Buffer.byteLength(urlInfo.content);
-      const category = determineCategory(urlInfo);
-      if (category === "sourcemap") {
-        countGroups.sourcemaps++;
-        sizeGroups.sourcemaps += urlContentSize;
-        return;
-      }
-      countGroups.total++;
-      sizeGroups.total += urlContentSize;
-      if (category === "html") {
-        countGroups.html++;
-        sizeGroups.html += urlContentSize;
-        return;
-      }
-      if (category === "css") {
-        countGroups.css++;
-        sizeGroups.css += urlContentSize;
-        return;
-      }
-      if (category === "js") {
-        countGroups.js++;
-        sizeGroups.js += urlContentSize;
-        return;
-      }
-      if (category === "json") {
-        countGroups.json++;
-        sizeGroups.json += urlContentSize;
-        return;
-      }
-      countGroups.other++;
-      sizeGroups.other += urlContentSize;
-      return;
-    },
-  );
-
-  const sizesToDistribute = {};
-  Object.keys(sizeGroups).forEach((groupName) => {
-    if (groupName !== "sourcemaps" && groupName !== "total") {
-      sizesToDistribute[groupName] = sizeGroups[groupName];
-    }
-  });
-  const percentageGroups = distributePercentages(sizesToDistribute);
-
-  return {
-    // sourcemaps are special, there size are ignored
-    // so there is no "percentage" associated
-    sourcemaps: {
-      count: countGroups.sourcemaps,
-      size: sizeGroups.sourcemaps,
-      percentage: undefined,
-    },
-
-    html: {
-      count: countGroups.html,
-      size: sizeGroups.html,
-      percentage: percentageGroups.html,
-    },
-    css: {
-      count: countGroups.css,
-      size: sizeGroups.css,
-      percentage: percentageGroups.css,
-    },
-    js: {
-      count: countGroups.js,
-      size: sizeGroups.js,
-      percentage: percentageGroups.js,
-    },
-    json: {
-      count: countGroups.json,
-      size: sizeGroups.json,
-      percentage: percentageGroups.json,
-    },
-    other: {
-      count: countGroups.other,
-      size: sizeGroups.other,
-      percentage: percentageGroups.other,
-    },
-    total: {
-      count: countGroups.total,
-      size: sizeGroups.total,
-      percentage: 100,
-    },
-  };
-};
-
-const determineCategory = (urlInfo) => {
-  if (urlInfo.type === "sourcemap") {
-    return "sourcemap";
-  }
-  if (urlInfo.type === "html") {
-    return "html";
-  }
-  if (urlInfo.type === "css") {
-    return "css";
-  }
-  if (urlInfo.type === "js_module" || urlInfo.type === "js_classic") {
-    return "js";
-  }
-  if (urlInfo.type === "json") {
-    return "json";
-  }
-  return "other";
-};
-
-const createRepartitionMessage = ({ html, css, js, json, other, total }) => {
-  const addPart = (name, { count, size, percentage }) => {
-    parts.push(
-      `${ANSI.color(`${name}:`, ANSI.GREY)} ${count} (${humanizeFileSize(
-        size,
-      )} / ${percentage} %)`,
-    );
-  };
-
-  const parts = [];
-  // if (sourcemaps.count) {
-  //   parts.push(
-  //     `${ANSI.color(`sourcemaps:`, ANSI.GREY)} ${
-  //       sourcemaps.count
-  //     } (${humanizeFileSize(sourcemaps.size)})`,
-  //   )
-  // }
-  if (html.count) {
-    addPart("html ", html);
-  }
-  if (css.count) {
-    addPart("css  ", css);
-  }
-  if (js.count) {
-    addPart("js   ", js);
-  }
-  if (json.count) {
-    addPart("json ", json);
-  }
-  if (other.count) {
-    addPart("other", other);
-  }
-  addPart("total", total);
-  return `- ${parts.join(`
-- `)}`;
-};