@jsenv/core 40.12.7 → 40.12.9

package/src/plugins/resolution_node_esm/node_esm_resolver.js

@@ -9,8 +9,6 @@
 
 import {
   applyNodeEsmResolution,
-  defaultLookupPackageScope,
-  defaultReadPackageJson,
   readCustomConditionsFromProcessArgs,
 } from "@jsenv/node-esm-resolution";
 import { URL_META } from "@jsenv/url-meta";
@@ -18,18 +16,27 @@ import { urlToBasename, urlToExtension } from "@jsenv/urls";
 import { readFileSync } from "node:fs";
 
 export const createNodeEsmResolver = ({
+  packageDirectory,
   runtimeCompat,
   rootDirectoryUrl,
   packageConditions = {},
   packageConditionsConfig,
   preservesSymlink,
 }) => {
+  const applyNodeEsmResolutionMemo = (params) =>
+    applyNodeEsmResolution({
+      lookupPackageScope: packageDirectory.find,
+      readPackageJson: packageDirectory.read,
+      preservesSymlink,
+      ...params,
+    });
   const buildPackageConditions = createBuildPackageConditions(
     packageConditions,
     {
       packageConditionsConfig,
       rootDirectoryUrl,
       runtimeCompat,
+      preservesSymlink,
     },
   );
 
@@ -61,7 +68,7 @@ export const createNodeEsmResolver = ({
       reference.type === "sourcemap_comment";
 
     const resolveNodeEsmFallbackOnWeb = createResolverWithFallbackOnError(
-      applyNodeEsmResolution,
+      applyNodeEsmResolutionMemo,
       ({ specifier, parentUrl }) => {
         const url = new URL(specifier, parentUrl).href;
         return { url };
@@ -70,7 +77,7 @@ export const createNodeEsmResolver = ({
     const DELEGATE_TO_WEB_RESOLUTION_PLUGIN = {};
     const resolveNodeEsmFallbackNullToDelegateToWebPlugin =
       createResolverWithFallbackOnError(
-        applyNodeEsmResolution,
+        applyNodeEsmResolutionMemo,
         () => DELEGATE_TO_WEB_RESOLUTION_PLUGIN,
       );
 
@@ -78,11 +85,11 @@ export const createNodeEsmResolver = ({
       webResolutionFallback,
       resolver: webResolutionFallback
         ? resolveNodeEsmFallbackOnWeb
-        : applyNodeEsmResolution,
+        : applyNodeEsmResolutionMemo,
     });
     const resolver = webResolutionFallback
       ? resolveNodeEsmFallbackNullToDelegateToWebPlugin
-      : applyNodeEsmResolution;
+      : applyNodeEsmResolutionMemo;
 
     const result = resolver({
       conditions,
@@ -113,52 +120,79 @@ export const createNodeEsmResolver = ({
     if (ownerUrlInfo.context.build) {
       return url;
     }
-    const dependsOnPackageJson =
-      type !== "relative_specifier" &&
-      type !== "absolute_specifier" &&
-      type !== "node_builtin_specifier";
-    if (dependsOnPackageJson) {
-      // this reference depends on package.json and node_modules
-      // to be resolved. Each file using this specifier
-      // must be invalidated when corresponding package.json changes
-      addRelationshipWithPackageJson({
-        reference,
-        packageJsonUrl: `${packageDirectoryUrl}package.json`,
-        field: type.startsWith("field:")
-          ? `#${type.slice("field:".length)}`
-          : "",
-      });
-    }
-    // without this check a file inside a project without package.json
-    // could be considered as a node module if there is a ancestor package.json
-    // but we want to version only node modules
-    if (url.includes("/node_modules/")) {
-      const packageDirectoryUrl = defaultLookupPackageScope(url);
-      if (
-        packageDirectoryUrl &&
-        packageDirectoryUrl !== ownerUrlInfo.context.rootDirectoryUrl
-      ) {
-        const packageVersion =
-          defaultReadPackageJson(packageDirectoryUrl).version;
-        // package version can be null, see https://github.com/babel/babel/blob/2ce56e832c2dd7a7ed92c89028ba929f874c2f5c/packages/babel-runtime/helpers/esm/package.json#L2
-        if (packageVersion) {
+
+    package_relationships: {
+      if (!url.startsWith("file:")) {
+        // data:, javascript:void(0), etc...
+        break package_relationships;
+      }
+
+      // packageDirectoryUrl can be already known thanks to node resolution
+      // otherwise we look for it
+      const closestPackageDirectoryUrl =
+        packageDirectoryUrl || packageDirectory.find(url);
+      if (!closestPackageDirectoryUrl) {
+        // happens for projects without package.json or some files outside of package scope
+        // (generated files like sourcemaps or cache files for example)
+        break package_relationships;
+      }
+
+      resolution_relationship: {
+        const dependsOnPackageJson = Boolean(packageDirectoryUrl);
+        if (dependsOnPackageJson) {
+          // this reference depends on package.json and node_modules
+          // to be resolved. Each file using this specifier
+          // must be invalidated when corresponding package.json changes
           addRelationshipWithPackageJson({
             reference,
             packageJsonUrl: `${packageDirectoryUrl}package.json`,
-            field: "version",
-            hasVersioningEffect: true,
+            field: type.startsWith("field:")
+              ? `#${type.slice("field:".length)}`
+              : "",
           });
         }
-        reference.version = packageVersion;
+      }
+      version_relationship: {
+        const packageVersion = packageDirectory.read(
+          closestPackageDirectoryUrl,
+        ).version;
+        if (!packageVersion) {
+          // package version can be null, see https://github.com/babel/babel/blob/2ce56e832c2dd7a7ed92c89028ba929f874c2f5c/packages/babel-runtime/helpers/esm/package.json#L2
+          break version_relationship;
+        }
+        // We want the versioning effect
+        // which would put the file in browser cache for 1 year based on that version
+        // only for files we don't control and touch ourselves (node modules)
+        // which would never change until their version change
+        // (minus the case you update them yourselves in your node modules without updating the package version)
+        // (in that case you would have to clear browser cache to use the modified version of the node module files)
+        const hasVersioningEffect =
+          closestPackageDirectoryUrl !== packageDirectory.url &&
+          url.includes("/node_modules/");
+        addRelationshipWithPackageJson({
+          reference,
+          packageJsonUrl: `${closestPackageDirectoryUrl}package.json`,
+          field: "version",
+          hasVersioningEffect,
+        });
+        if (hasVersioningEffect) {
+          reference.version = packageVersion;
+        }
       }
     }
+
     return url;
   };
 };
 
 const createBuildPackageConditions = (
   packageConditions,
-  { packageConditionsConfig, rootDirectoryUrl, runtimeCompat },
+  {
+    packageConditionsConfig,
+    rootDirectoryUrl,
+    runtimeCompat,
+    preservesSymlink,
+  },
 ) => {
   let resolveConditionsFromSpecifier = () => null;
   let resolveConditionsFromContext = () => [];
@@ -185,6 +219,7 @@ const createBuildPackageConditions = (
           const { packageDirectoryUrl } = applyNodeEsmResolution({
             specifier: key.slice(0, -1), // avoid package path not exported
             parentUrl: rootDirectoryUrl,
+            preservesSymlink,
           });
           const url = packageDirectoryUrl;
           associationsRaw[url] = associatedValue;
@@ -193,6 +228,7 @@ const createBuildPackageConditions = (
         const { url } = applyNodeEsmResolution({
           specifier: key,
           parentUrl: rootDirectoryUrl,
+          preservesSymlink,
         });
         associationsRaw[url] = associatedValue;
       } catch {

package/src/plugins/workspace_bundle/jsenv_plugin_workspace_bundle.js

@@ -0,0 +1,119 @@
+import { bundleJsModules } from "@jsenv/plugin-bundling";
+import { injectQueryParams, injectQueryParamsIntoSpecifier } from "@jsenv/urls";
+
+const PACKAGE_BUNDLE_QUERY_PARAM = "package_bundle";
+const PACKAGE_NO_BUNDLE_QUERY_PARAM = "package_no_bundle";
+const DYNAMIC_IMPORT_QUERY_PARAM = "dynamic_import";
+
+export const jsenvPluginWorkspaceBundle = ({ packageDirectory }) => {
+  return {
+    name: "jsenv:workspace_bundle",
+    appliesDuring: "dev",
+    redirectReference: (reference) => {
+      if (!reference.url.startsWith("file:")) {
+        return null;
+      }
+      if (reference.searchParams.has(PACKAGE_BUNDLE_QUERY_PARAM)) {
+        return null;
+      }
+      if (reference.searchParams.has(PACKAGE_NO_BUNDLE_QUERY_PARAM)) {
+        return null;
+      }
+      if (
+        reference.ownerUrlInfo.searchParams.has(PACKAGE_NO_BUNDLE_QUERY_PARAM)
+      ) {
+        // we're cooking the bundle, without this check we would have infinite recursion to try to bundle
+        // we want to propagate the ?package_no_bundle
+        const noBundleUrl = injectQueryParams(reference.url, {
+          v: undefined,
+          [PACKAGE_NO_BUNDLE_QUERY_PARAM]: "",
+        });
+        // console.log(
+        //   `redirecting ${reference.url} to ${noBundleUrl} to cook the bundle`,
+        // );
+        return noBundleUrl;
+      }
+      const packageDirectoryUrl = packageDirectory.find(reference.url);
+      if (!packageDirectoryUrl) {
+        return null;
+      }
+      if (packageDirectoryUrl === packageDirectory.url) {
+        // root package, we don't want to bundle
+        return null;
+      }
+      // we make sure we target the bundle version of the package
+      // otherwise we might execute some parts of the package code multiple times.
+      // so we need to redirect the potential reference to non entry point to the package main entry point
+      const packageJSON = packageDirectory.read(packageDirectoryUrl);
+      const rootReference = reference.ownerUrlInfo.dependencies.inject({
+        type: "js_import",
+        specifier: `${packageJSON.name}?${PACKAGE_BUNDLE_QUERY_PARAM}`,
+      });
+      // console.log(
+      //   `redirecting ${reference.url} to ${rootReference.url} to target the package bundle version of the package`,
+      // );
+      const packageMainUrl = rootReference.url;
+      return packageMainUrl;
+    },
+    fetchUrlContent: async (urlInfo) => {
+      if (!urlInfo.searchParams.has(PACKAGE_BUNDLE_QUERY_PARAM)) {
+        return null;
+      }
+      const noBundleSpecifier = injectQueryParamsIntoSpecifier(
+        urlInfo.firstReference.specifier,
+        {
+          [PACKAGE_BUNDLE_QUERY_PARAM]: undefined,
+          [PACKAGE_NO_BUNDLE_QUERY_PARAM]: "",
+        },
+      );
+      const noBundleUrlInfo = urlInfo.redirect({
+        specifier: noBundleSpecifier,
+      });
+      if (!noBundleUrlInfo) {
+        return null;
+      }
+      await noBundleUrlInfo.cook();
+      await noBundleUrlInfo.cookDependencies({
+        // we ignore dynamic import to cook lazyly (as browser request the server)
+        // these dynamic imports must inherit "?package_bundle"
+        // This is done inside rollup for convenience
+        ignoreDynamicImport: true,
+      });
+      const bundleUrlInfos = await bundleJsModules([noBundleUrlInfo], {
+        chunks: false,
+        buildDirectoryUrl: new URL("./", import.meta.url),
+        preserveDynamicImports: true,
+        augmentDynamicImportUrlSearchParams: () => {
+          return {
+            [DYNAMIC_IMPORT_QUERY_PARAM]: "",
+            [PACKAGE_BUNDLE_QUERY_PARAM]: "",
+          };
+        },
+      });
+      const bundledUrlInfo = bundleUrlInfos[noBundleUrlInfo.url];
+      if (urlInfo.context.dev) {
+        for (const sourceUrl of bundledUrlInfo.sourceUrls) {
+          urlInfo.dependencies.inject({
+            isImplicit: true,
+            type: "js_url",
+            specifier: sourceUrl,
+          });
+        }
+      }
+      return {
+        content: bundledUrlInfo.content,
+        contentType: "text/javascript",
+        type: "js_module",
+        originalUrl: urlInfo.originalUrl,
+        originalContent: bundledUrlInfo.originalContent,
+        sourcemap: bundledUrlInfo.sourcemap,
+        data: bundledUrlInfo.data,
+      };
+    },
+    // transformReferenceSearchParams: () => {
+    //   return {
+    //     [PACKAGE_BUNDLE_QUERY_PARAM]: undefined,
+    //   };
+    // },
+  };
+};