@jsenv/core 41.4.17 → 41.4.19

package/src/helpers/watch_source_files.js

@@ -2,24 +2,27 @@ import {
   lookupPackageDirectory,
   registerDirectoryLifecycle,
 } from "@jsenv/filesystem";
-import { urlToRelativeUrl } from "@jsenv/urls";
+import { urlIsOrIsInsideOf, urlToRelativeUrl } from "@jsenv/urls";
 import { readFileSync } from "node:fs";
 
 export const getDirectoryWatchPatterns = (
   directoryUrl,
   watchedDirectoryUrl,
-  { sourceFilesConfig },
+  { sourceFilesConfig, defaultPatterns = true },
 ) => {
   const directoryUrlRelativeToWatchedDirectory = urlToRelativeUrl(
     directoryUrl,
     watchedDirectoryUrl,
   );
-  const watchPatterns = {
-    [`${directoryUrlRelativeToWatchedDirectory}**/*`]: true, // by default watch everything inside the source directory
-    [`${directoryUrlRelativeToWatchedDirectory}**/.*`]: false, // file starting with a dot -> do not watch
-    [`${directoryUrlRelativeToWatchedDirectory}**/.*/`]: false, // directory starting with a dot -> do not watch
-    [`${directoryUrlRelativeToWatchedDirectory}**/node_modules/`]: false, // node_modules directory -> do not watch
-  };
+  const watchPatterns = {};
+  if (defaultPatterns) {
+    Object.assign(watchPatterns, {
+      [`${directoryUrlRelativeToWatchedDirectory}**/*`]: true, // by default watch everything inside the source directory
+      [`${directoryUrlRelativeToWatchedDirectory}**/.*`]: false, // file starting with a dot -> do not watch
+      [`${directoryUrlRelativeToWatchedDirectory}**/.*/`]: false, // directory starting with a dot -> do not watch
+      [`${directoryUrlRelativeToWatchedDirectory}**/node_modules/`]: false, // node_modules directory -> do not watch
+    });
+  }
   for (const key of Object.keys(sourceFilesConfig)) {
     watchPatterns[`${directoryUrlRelativeToWatchedDirectory}${key}`] =
       sourceFilesConfig[key];
@@ -40,11 +43,12 @@ export const watchSourceFiles = (
   // And jsenv should not consider these as source files and watch them (to not hurt performances)
   const watchPatterns = {};
   let watchedDirectoryUrl = "";
-  const addDirectoryToWatch = (directoryUrl) => {
+  const addDirectoryToWatch = (directoryUrl, { defaultPatterns } = {}) => {
     Object.assign(
       watchPatterns,
       getDirectoryWatchPatterns(directoryUrl, watchedDirectoryUrl, {
         sourceFilesConfig,
+        defaultPatterns,
       }),
     );
   };
@@ -76,7 +80,6 @@ export const watchSourceFiles = (
         },
       },
     );
-    stopWatchingSourceFiles.watchPatterns = watchPatterns;
     return stopWatchingSourceFiles;
   };
 
@@ -96,16 +99,18 @@ export const watchSourceFiles = (
     }
     watchedDirectoryUrl = packageDirectoryUrl;
     for (const workspace of workspaces) {
-      if (workspace.endsWith("*")) {
-        const workspaceDirectoryUrl = new URL(
-          workspace.slice(0, -1),
-          packageDirectoryUrl,
-        );
-        addDirectoryToWatch(workspaceDirectoryUrl);
-      } else {
-        const workspaceRelativeUrl = new URL(workspace, packageDirectoryUrl);
-        addDirectoryToWatch(workspaceRelativeUrl);
-      }
+      const workspaceDirectoryUrl = workspace.endsWith("*")
+        ? new URL(workspace.slice(0, -1), packageDirectoryUrl)
+        : new URL(workspace, packageDirectoryUrl);
+      addDirectoryToWatch(workspaceDirectoryUrl, {
+        // The source directory patterns already cover a workspace inside it.
+        // Every pattern is tested against every file found while watching, so
+        // the same patterns rooted at each workspace only multiply that work.
+        defaultPatterns: !urlIsOrIsInsideOf(
+          workspaceDirectoryUrl,
+          sourceDirectoryUrl,
+        ),
+      });
     }
     // we are updating the root directory
     // we must make the patterns relative to source directory relative to the new root directory

package/src/kitchen/kitchen.js

@@ -118,6 +118,12 @@ export const createKitchen = ({
       INJECTIONS,
       getPluginMeta: null,
       sourcemaps,
+      // a plugin producing a sourcemap can skip the work when it would be
+      // thrown away (see shouldHandleSourcemap in url_info_transformations.js)
+      sourcemapsEnabled:
+        sourcemaps === "inline" ||
+        sourcemaps === "file" ||
+        sourcemaps === "programmatic",
       outDirectoryUrl,
     },
     resolve: (specifier, importer = rootDirectoryUrl) => {

package/src/kitchen/prepend_content.js

@@ -67,10 +67,9 @@ const prependJsClassicInJsClassic = (jsUrlInfo, urlInfoToPrepend) => {
   const magicSource = createMagicSource(jsUrlInfo.content);
   magicSource.prepend(`${urlInfoToPrepend.content}\n\n`);
   const magicResult = magicSource.toContentAndSourcemap();
-  const sourcemap = composeTwoSourcemaps(
-    jsUrlInfo.sourcemap,
-    magicResult.sourcemap,
-  );
+  const sourcemap = jsUrlInfo.context.sourcemapsEnabled
+    ? composeTwoSourcemaps(jsUrlInfo.sourcemap, magicResult.sourcemap)
+    : null;
   jsUrlInfo.mutateContent({
     content: magicResult.content,
     sourcemap,
@@ -88,6 +87,7 @@ const prependJsClassicInJsModule = async (jsUrlInfo, urlInfoToPrepend) => {
     input: jsUrlInfo.content,
     inputIsJsModule: true,
     inputUrl: jsUrlInfo.originalUrl,
+    options: { sourceMaps: jsUrlInfo.context.sourcemapsEnabled },
   });
   jsUrlInfo.mutateContent({
     content: code,

package/src/kitchen/url_graph/references.js

@@ -634,20 +634,37 @@ const checkForDependencyRemovalEffects = (reference) => {
 };
 
 const traceFromUrlSite = (urlSite) => {
-  const codeFrame = urlSite.content
-    ? generateContentFrame({
-        content: urlSite.content,
-        line: urlSite.line,
-        column: urlSite.column,
-      })
-    : "";
-  return {
-    codeFrame,
-    message: stringifyUrlSite(urlSite),
-    url: urlSite.url,
-    line: urlSite.line,
-    column: urlSite.column,
+  const { url, line, column, content } = urlSite;
+  const trace = { url, line, column };
+  // A file references many urls and an error on one of them is rare: the code
+  // frame (and the message embedding it) is built the first time it is read,
+  // not for every reference found.
+  defineLazyProperty(trace, "codeFrame", () =>
+    content ? generateContentFrame({ content, line, column }) : "",
+  );
+  defineLazyProperty(trace, "message", () => stringifyUrlSite(urlSite));
+  return trace;
+};
+
+const defineLazyProperty = (object, property, compute) => {
+  const setValue = (value) => {
+    Object.defineProperty(object, property, {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value,
+    });
   };
+  Object.defineProperty(object, property, {
+    enumerable: true,
+    configurable: true,
+    get: () => {
+      const value = compute();
+      setValue(value);
+      return value;
+    },
+    set: setValue,
+  });
 };
 
 const adjustUrlSite = (urlInfo, { url, line, column }) => {

package/src/kitchen/url_graph/url_graph.js

@@ -185,7 +185,6 @@ const createUrlInfo = (url, context) => {
     dereferencedTimestamp: 0,
     originalContentEtag: null,
     contentEtag: null,
-    isWatched: false,
     isValid: () => false,
     data: {}, // plugins can put whatever they want here
     referenceToOthersSet: new Set(),

package/src/kitchen/url_graph/url_info_transformations.js

@@ -199,7 +199,6 @@ export const createUrlInfoTransformer = ({
       contentAst, // undefined most of the time
       contentEtag, // in practice always undefined
       contentLength,
-      sourcemap,
       sourcemapIsWrong,
       contentInjections,
     } = transformations;
@@ -226,11 +225,14 @@ export const createUrlInfoTransformer = ({
         contentLength,
       });
     }
-    if (
-      sourcemap &&
-      mayHaveSourcemap(urlInfo) &&
-      shouldHandleSourcemap(urlInfo)
-    ) {
+    // "sourcemap" is read last, and only when it will be used: a plugin can
+    // hand it back as a getter that generates the map on first read, so that
+    // nothing is generated for a kitchen that throws sourcemaps away
+    const sourcemap =
+      mayHaveSourcemap(urlInfo) && shouldHandleSourcemap(urlInfo)
+        ? transformations.sourcemap
+        : null;
+    if (sourcemap) {
       const sourcemapNormalized = normalizeSourcemap(urlInfo, sourcemap);
       let currentSourcemap = urlInfo.sourcemap;
       const finalSourcemap = composeTwoSourcemaps(
@@ -263,6 +265,14 @@ export const createUrlInfoTransformer = ({
     writeInsideOutDirectory(urlInfo);
   };
 
+  // Written synchronously on purpose, and measured: async is the tempting
+  // choice, but here it loses. A cold load cooks hundreds of files; their
+  // synchronous writes block the event loop ~160ms in total, while
+  // asynchronous writes queue in the threadpool behind tens of MB of content
+  // and sourcemaps, and a response that waits for its own write then waits
+  // ~36ms on average (18s summed over 500 responses). Not waiting is not an
+  // option either: the last write lands after the test that cooked it has
+  // ended, and the side-effect snapshots lose it.
   const writeInsideOutDirectory = (urlInfo) => {
     // writing result inside ".jsenv" directory (debug purposes)
     if (!outDirectoryUrl) {

package/src/plugins/import_meta_css/jsenv_plugin_import_meta_css.js

@@ -23,7 +23,11 @@
  *
  */
 
-import { applyBabelPlugins } from "@jsenv/ast";
+import {
+  applyBabelPlugins,
+  getImportMetaPropertyName,
+  visitJsAstUntil,
+} from "@jsenv/ast";
 
 export const jsenvPluginImportMetaCss = () => {
   const importMetaCssDevClientFileUrl = import.meta
@@ -47,15 +51,10 @@ export const jsenvPluginImportMetaCss = () => {
         if (!urlInfo.content.includes("import.meta.css")) {
           return null;
         }
-        const { metadata } = await applyBabelPlugins({
-          babelPlugins: [babelPluginMetadataUsesImportMetaCss],
-          input: urlInfo.content,
-          inputIsJsModule: true,
-          inputUrl: urlInfo.originalUrl,
-          outputUrl: urlInfo.generatedUrl,
+        const importMetaCssNode = visitJsAstUntil(urlInfo.contentAst, {
+          MemberExpression: (node) => getImportMetaPropertyName(node) === "css",
         });
-        const { usesImportMetaCss } = metadata;
-        if (!usesImportMetaCss) {
+        if (!importMetaCssNode) {
           return null;
         }
         if (urlInfo.context.build) {
@@ -76,6 +75,8 @@ export const jsenvPluginImportMetaCss = () => {
             inputIsJsModule: true,
             inputUrl: urlInfo.originalUrl,
             outputUrl: urlInfo.generatedUrl,
+            // the map would be dropped: the content sent back carries none
+            options: { sourceMaps: false },
           });
           if (code === urlInfo.content) {
             // all assignments were already in array form (pre-built file) — nothing to do
@@ -135,37 +136,6 @@ const babelPluginRewriteImportMetaCssAssignment = (
   };
 };
 
-const babelPluginMetadataUsesImportMetaCss = () => {
-  return {
-    name: "metadata-uses-import-meta-css",
-    visitor: {
-      Program(programPath, state) {
-        let usesImportMetaCss = false;
-        programPath.traverse({
-          MemberExpression(path) {
-            const { node } = path;
-            const { object } = node;
-            if (object.type !== "MetaProperty") {
-              return;
-            }
-            const { property: objectProperty } = object;
-            if (objectProperty.name !== "meta") {
-              return;
-            }
-            const { property } = node;
-            const { name } = property;
-            if (name === "css") {
-              usesImportMetaCss = true;
-              path.stop();
-            }
-          },
-        });
-        state.file.metadata.usesImportMetaCss = usesImportMetaCss;
-      },
-    },
-  };
-};
-
 const injectImportMetaCss = (
   urlInfo,
   { content, importFrom, importName, importAs, hot },

package/src/plugins/import_meta_hot/import_meta_hot_analysis.js

@@ -0,0 +1,70 @@
+import { getImportMetaPropertyName, visitJsAst } from "@jsenv/ast";
+
+export const analyzeImportMetaHot = (ast) => {
+  const importMetaHotNodes = [];
+  let hotDecline = false;
+  let hotAcceptSelf = false;
+  let hotAcceptSpecifiers = [];
+  visitJsAst(ast, {
+    MemberExpression: (node) => {
+      if (getImportMetaPropertyName(node) === "hot") {
+        importMetaHotNodes.push(node);
+      }
+    },
+    CallExpression: (node) => {
+      const methodName = getImportMetaHotMethodName(node);
+      if (methodName === "accept") {
+        const args = node.arguments;
+        if (args.length === 0) {
+          hotAcceptSelf = true;
+          return;
+        }
+        const [firstArg] = args;
+        if (isStringLiteral(firstArg)) {
+          hotAcceptSpecifiers = [firstArg.value];
+          return;
+        }
+        if (firstArg.type === "ArrayExpression") {
+          hotAcceptSpecifiers = firstArg.elements.map((element) => {
+            if (!isStringLiteral(element)) {
+              throw new Error(
+                `all array elements must be strings in "import.meta.hot.accept(array)"`,
+              );
+            }
+            return element.value;
+          });
+          return;
+        }
+        // accept first arg can be "anything" such as
+        // `const cb = () => {}; import.meta.hot.accept(cb)`
+        hotAcceptSelf = true;
+        return;
+      }
+      if (methodName === "decline") {
+        hotDecline = true;
+      }
+    },
+  });
+  return {
+    importMetaHotNodes,
+    hotDecline,
+    hotAcceptSelf,
+    hotAcceptSpecifiers,
+  };
+};
+
+// "import.meta.hot.<method>(...)"
+const getImportMetaHotMethodName = (callNode) => {
+  const { callee } = callNode;
+  if (callee.type !== "MemberExpression" || callee.computed) {
+    return null;
+  }
+  if (getImportMetaPropertyName(callee.object) !== "hot") {
+    return null;
+  }
+  return callee.property.name;
+};
+
+const isStringLiteral = (node) => {
+  return node.type === "Literal" && typeof node.value === "string";
+};

package/src/plugins/import_meta_hot/jsenv_plugin_import_meta_hot.js

@@ -1,8 +1,8 @@
-import { applyBabelPlugins, parseHtml } from "@jsenv/ast";
+import { parseHtml } from "@jsenv/ast";
 import { createMagicSource } from "@jsenv/sourcemap";
 
-import { babelPluginMetadataImportMetaHot } from "./babel_plugin_metadata_import_meta_hot.js";
 import { collectHotDataFromHtmlAst } from "./html_hot_dependencies.js";
+import { analyzeImportMetaHot } from "./import_meta_hot_analysis.js";
 
 export const jsenvPluginImportMetaHot = () => {
   const importMetaHotClientFileUrl = import.meta
@@ -52,7 +52,7 @@ export const jsenvPluginImportMetaHot = () => {
         cssUrlInfo.data.hotAcceptSelf = false;
         cssUrlInfo.data.hotAcceptDependencies = [];
       },
-      js_module: async (urlInfo) => {
+      js_module: (urlInfo) => {
         // Do not scan node modules for import.meta.hot
         // - unlikely to be there
         // - we don't watch node modules (too expensive)
@@ -64,27 +64,22 @@ export const jsenvPluginImportMetaHot = () => {
         if (!urlInfo.content.includes("import.meta.hot")) {
           return null;
         }
-        const { metadata } = await applyBabelPlugins({
-          babelPlugins: [babelPluginMetadataImportMetaHot],
-          input: urlInfo.content,
-          inputIsJsModule: true,
-          inputUrl: urlInfo.originalUrl,
-          outputUrl: urlInfo.generatedUrl,
-        });
         const {
-          importMetaHotPaths,
+          importMetaHotNodes,
           hotDecline,
           hotAcceptSelf,
-          hotAcceptDependencies,
-        } = metadata;
+          hotAcceptSpecifiers,
+        } = analyzeImportMetaHot(urlInfo.contentAst);
         urlInfo.data.hotDecline = hotDecline;
         urlInfo.data.hotAcceptSelf = hotAcceptSelf;
-        urlInfo.data.hotAcceptDependencies = hotAcceptDependencies;
-        if (importMetaHotPaths.length === 0) {
+        urlInfo.data.hotAcceptDependencies = hotAcceptSpecifiers.map(
+          (specifier) => resolveHotAcceptSpecifier(urlInfo, specifier),
+        );
+        if (importMetaHotNodes.length === 0) {
           return null;
         }
         if (urlInfo.context.build) {
-          return removeImportMetaHots(urlInfo, importMetaHotPaths);
+          return removeImportMetaHots(urlInfo, importMetaHotNodes);
         }
         return injectImportMetaHot(urlInfo, importMetaHotClientFileUrl);
       },
@@ -92,12 +87,32 @@ export const jsenvPluginImportMetaHot = () => {
   };
 };
 
-const removeImportMetaHots = (urlInfo, importMetaHotPaths) => {
+// The specifier given to import.meta.hot.accept() is one the file imports,
+// so its url is known from that import (autoreload compares urls). A
+// specifier the file does not import accepts nothing: it is kept as a plain
+// url, never resolved as a dependency (that could throw on a bare specifier).
+const resolveHotAcceptSpecifier = (urlInfo, specifier) => {
+  for (const referenceToOther of urlInfo.referenceToOthersSet) {
+    if (
+      referenceToOther.type === "js_import" &&
+      referenceToOther.specifier === specifier
+    ) {
+      return referenceToOther.url;
+    }
+  }
+  try {
+    return new URL(specifier, urlInfo.url).href;
+  } catch {
+    return specifier;
+  }
+};
+
+const removeImportMetaHots = (urlInfo, importMetaHotNodes) => {
   const magicSource = createMagicSource(urlInfo.content);
-  importMetaHotPaths.forEach((path) => {
+  importMetaHotNodes.forEach((node) => {
     magicSource.replace({
-      start: path.node.start,
-      end: path.node.end,
+      start: node.start,
+      end: node.end,
       replacement: "undefined",
     });
   });

package/src/plugins/import_meta_scenarios/jsenv_plugin_import_meta_scenarios.js

@@ -10,7 +10,7 @@
  * TODO: ideally during dev we would keep import.meta.dev and ensure we set it to true rather than replacing it with true?
  */
 
-import { applyBabelPlugins } from "@jsenv/ast";
+import { getImportMetaPropertyName, visitJsAst } from "@jsenv/ast";
 import { createMagicSource } from "@jsenv/sourcemap";
 
 export const jsenvPluginImportMetaScenarios = () => {
@@ -18,7 +18,7 @@ export const jsenvPluginImportMetaScenarios = () => {
     name: "jsenv:import_meta_scenario",
     appliesDuring: "*",
     transformUrlContent: {
-      js_module: async (urlInfo) => {
+      js_module: (urlInfo) => {
         // Do not scan node modules for import.meta.dev/import.meta.build
         // - node modules won't have this in their code
         // - ;or should use other an other technic as this one won't be available
@@ -34,40 +34,42 @@ export const jsenvPluginImportMetaScenarios = () => {
         ) {
           return null;
         }
-        const { metadata } = await applyBabelPlugins({
-          babelPlugins: [babelPluginMetadataImportMetaScenarios],
-          input: urlInfo.content,
-          inputIsJsModule: true,
-          inputUrl: urlInfo.originalUrl,
-          outputUrl: urlInfo.generatedUrl,
+        const importMetaScenarioNodes = { dev: [], build: [] };
+        visitJsAst(urlInfo.contentAst, {
+          MemberExpression: (node) => {
+            const name = getImportMetaPropertyName(node);
+            if (name === "dev" || name === "build") {
+              importMetaScenarioNodes[name].push(node);
+            }
+          },
         });
-        const { dev = [], build = [] } = metadata.importMetaScenarios;
+        const { dev, build } = importMetaScenarioNodes;
         const replacements = [];
-        const replace = (path, value) => {
-          replacements.push({ path, value });
+        const replace = (node, value) => {
+          replacements.push({ node, value });
         };
         if (urlInfo.context.build) {
           // during build ensure replacement for tree-shaking
-          dev.forEach((path) => {
-            replace(path, "undefined");
+          dev.forEach((node) => {
+            replace(node, "undefined");
           });
-          build.forEach((path) => {
-            replace(path, "true");
+          build.forEach((node) => {
+            replace(node, "true");
           });
         } else {
           // during dev we can let "import.meta.build" untouched
           // it will be evaluated to undefined.
           // Moreover it can be surprising to see some "undefined"
           // when source file contains "import.meta.build"
-          dev.forEach((path) => {
-            replace(path, "true");
+          dev.forEach((node) => {
+            replace(node, "true");
           });
         }
         const magicSource = createMagicSource(urlInfo.content);
-        replacements.forEach(({ path, value }) => {
+        replacements.forEach(({ node, value }) => {
           magicSource.replace({
-            start: path.node.start,
-            end: path.node.end,
+            start: node.start,
+            end: node.end,
             replacement: value,
           });
         });
@@ -76,39 +78,3 @@ export const jsenvPluginImportMetaScenarios = () => {
     },
   };
 };
-
-const babelPluginMetadataImportMetaScenarios = () => {
-  return {
-    name: "metadata-import-meta-scenarios",
-    visitor: {
-      Program(programPath, state) {
-        const importMetas = {};
-        programPath.traverse({
-          MemberExpression(path) {
-            const { node } = path;
-            const { object } = node;
-            if (object.type !== "MetaProperty") {
-              return;
-            }
-            const { property: objectProperty } = object;
-            if (objectProperty.name !== "meta") {
-              return;
-            }
-            const { property } = node;
-            const { name } = property;
-            const importMetaPaths = importMetas[name];
-            if (importMetaPaths) {
-              importMetaPaths.push(path);
-            } else {
-              importMetas[name] = [path];
-            }
-          },
-        });
-        state.file.metadata.importMetaScenarios = {
-          dev: importMetas.dev,
-          build: importMetas.build,
-        };
-      },
-    },
-  };
-};