@jsenv/core 38.2.10 → 38.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "38.2.10",
+  "version": "38.3.0",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -61,20 +61,20 @@
   "dependencies": {
     "@financial-times/polyfill-useragent-normaliser": "1.10.2",
     "@jsenv/abort": "4.2.4",
-    "@jsenv/ast": "5.1.4",
+    "@jsenv/ast": "5.2.0",
     "@jsenv/filesystem": "4.3.2",
     "@jsenv/importmap": "1.2.1",
     "@jsenv/integrity": "0.0.1",
+    "@jsenv/js-module-fallback": "1.3.6",
     "@jsenv/log": "3.4.1",
     "@jsenv/node-esm-resolution": "1.0.1",
-    "@jsenv/js-module-fallback": "1.3.5",
-    "@jsenv/runtime-compat": "1.2.0",
-    "@jsenv/server": "15.1.3",
-    "@jsenv/sourcemap": "1.2.3",
     "@jsenv/plugin-bundling": "2.5.7",
     "@jsenv/plugin-minification": "1.5.3",
-    "@jsenv/plugin-transpilation": "1.3.4",
-    "@jsenv/plugin-supervisor": "1.3.5",
+    "@jsenv/plugin-supervisor": "1.3.6",
+    "@jsenv/plugin-transpilation": "1.3.5",
+    "@jsenv/runtime-compat": "1.2.0",
+    "@jsenv/server": "15.1.4",
+    "@jsenv/sourcemap": "1.2.3",
     "@jsenv/url-meta": "8.1.0",
     "@jsenv/urls": "2.2.1",
     "@jsenv/utils": "2.0.1"
@@ -82,22 +82,22 @@
   "devDependencies": {
     "@babel/eslint-parser": "7.22.15",
     "@babel/plugin-syntax-import-assertions": "7.22.5",
-    "babel-plugin-transform-async-to-promises": "0.8.18",
     "@jsenv/assert": "./packages/independent/assert/",
     "@jsenv/core": "./",
     "@jsenv/eslint-config": "./packages/independent/eslint-config/",
-    "@jsenv/file-size-impact": "14.1.2",
+    "@jsenv/file-size-impact": "14.1.3",
     "@jsenv/https-local": "3.0.7",
     "@jsenv/package-workspace": "0.5.3",
-    "@jsenv/performance-impact": "4.1.2",
+    "@jsenv/performance-impact": "4.1.3",
     "@jsenv/plugin-as-js-classic": "./packages/related/plugin-as-js-classic/",
     "@jsenv/test": "./packages/related/test/",
-    "eslint": "8.51.0",
+    "babel-plugin-transform-async-to-promises": "0.8.18",
+    "eslint": "8.52.0",
     "eslint-plugin-html": "7.1.0",
-    "eslint-plugin-import": "2.28.1",
+    "eslint-plugin-import": "2.29.0",
     "eslint-plugin-react": "7.33.2",
     "open": "9.1.0",
-    "playwright": "1.38.1",
+    "playwright": "1.39.0",
     "prettier": "3.0.3"
   }
 }

package/src/dev/file_service.js

@@ -135,7 +135,7 @@ export const createFileService = ({
         associations: watchAssociations,
       });
       urlInfoCreated.isWatched = watch;
-      // wehn an url depends on many others, we check all these (like package.json)
+      // when an url depends on many others, we check all these (like package.json)
       urlInfoCreated.isValid = () => {
         if (!urlInfoCreated.url.startsWith("file:")) {
           return false;

package/src/kitchen/kitchen.js

@@ -488,7 +488,7 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
           // the HTML in itself it still valid
           // keep the syntax error and continue with the HTML
           const errorInfo =
-            e.code === "PARSE_ERROR"
+            e.code === "PARSE_ERROR" && e.cause
               ? `${e.cause.reasonCode}\n${e.traceMessage}`
               : e.stack;
           logger.error(

package/src/kitchen/url_graph/references.js

@@ -386,12 +386,12 @@ const createReference = ({
     ownerUrlInfo.context.finalizeReference(reference);
   };
 
-  // "formatReferencedUrl" can be async BUT this is an exception
+  // "formatReference" can be async BUT this is an exception
   // for most cases it will be sync. We want to favor the sync signature to keep things simpler
   // The only case where it needs to be async is when
   // the specifier is a `data:*` url
   // in this case we'll wait for the promise returned by
-  // "formatReferencedUrl"
+  // "formatReference"
   reference.readGeneratedSpecifier = () => {
     if (reference.generatedSpecifier.then) {
       return reference.generatedSpecifier.then((value) => {

package/src/kitchen/url_graph/url_graph.js

@@ -181,6 +181,7 @@ const createUrlInfo = (url, context) => {
     context,
     error: null,
     modifiedTimestamp: 0,
+    descendantModifiedTimestamp: 0,
     dereferencedTimestamp: 0,
     originalContentEtag: null,
     contentEtag: null,
@@ -254,6 +255,9 @@ const createUrlInfo = (url, context) => {
         continue;
       }
       if (ref.gotInlined()) {
+        if (ref.ownerUrlInfo.isUsed()) {
+          return true;
+        }
         // the url info was inlined, an other reference is required
         // to consider the non-inlined urlInfo as used
         continue;
@@ -353,7 +357,7 @@ const createUrlInfo = (url, context) => {
   };
   urlInfo.onModified = ({ modifiedTimestamp = Date.now() } = {}) => {
     const visitedSet = new Set();
-    const iterate = (urlInfo) => {
+    const considerModified = (urlInfo) => {
       if (visitedSet.has(urlInfo)) {
         return;
       }
@@ -363,14 +367,21 @@ const createUrlInfo = (url, context) => {
       for (const referenceToOther of urlInfo.referenceToOthersSet) {
         const referencedUrlInfo = referenceToOther.urlInfo;
         if (referencedUrlInfo.isInline) {
-          iterate(referencedUrlInfo);
+          considerModified(referencedUrlInfo);
+        }
+      }
+      for (const referenceFromOther of urlInfo.referenceFromOthersSet) {
+        if (referenceFromOther.gotInlined()) {
+          const urlInfoReferencingThisOne = referenceFromOther.ownerUrlInfo;
+          considerModified(urlInfoReferencingThisOne);
         }
       }
       for (const searchParamVariant of urlInfo.searchParamVariantSet) {
-        iterate(searchParamVariant);
+        considerModified(searchParamVariant);
       }
     };
-    iterate(urlInfo);
+    considerModified(urlInfo);
+    visitedSet.clear();
   };
   urlInfo.onDereferenced = (lastReferenceFromOther) => {
     urlInfo.dereferencedTimestamp = Date.now();

package/src/plugins/autoreload/jsenv_plugin_autoreload_server.js

@@ -18,89 +18,157 @@ export const jsenvPluginAutoreloadServer = ({
           }
           return url;
         };
-        const propagateUpdate = (firstUrlInfo) => {
-          const iterate = (urlInfo, seen) => {
-            if (urlInfo.data.hotAcceptSelf) {
-              return {
-                accepted: true,
-                reason:
-                  urlInfo === firstUrlInfo
-                    ? `file accepts hot reload`
-                    : `a dependent file accepts hot reload`,
-                instructions: [
-                  {
-                    type: urlInfo.type,
-                    boundary: formatUrlForClient(urlInfo.url),
+        const update = (firstUrlInfo) => {
+          const boundaries = new Set();
+          const instructions = [];
+          const propagateUpdate = (firstUrlInfo) => {
+            const iterate = (urlInfo, chain) => {
+              if (urlInfo.data.hotAcceptSelf) {
+                boundaries.add(urlInfo);
+                instructions.push({
+                  type: urlInfo.type,
+                  boundary: formatUrlForClient(urlInfo.url),
+                  acceptedBy: formatUrlForClient(urlInfo.url),
+                });
+                return {
+                  accepted: true,
+                  reason:
+                    urlInfo === firstUrlInfo
+                      ? `file accepts hot reload`
+                      : `a dependent file accepts hot reload`,
+                };
+              }
+              if (urlInfo.data.hotDecline) {
+                return {
+                  declined: true,
+                  reason: `file declines hot reload`,
+                  declinedBy: formatUrlForClient(urlInfo.url),
+                };
+              }
+              let instructionCountBefore = instructions.length;
+              for (const referenceFromOther of urlInfo.referenceFromOthersSet) {
+                if (
+                  referenceFromOther.isImplicit &&
+                  referenceFromOther.isWeak
+                ) {
+                  if (!referenceFromOther.original) {
+                    continue;
+                  }
+                  if (referenceFromOther.original.isWeak) {
+                    continue;
+                  }
+                }
+                const urlInfoReferencingThisOne =
+                  referenceFromOther.ownerUrlInfo;
+                if (urlInfoReferencingThisOne.data.hotDecline) {
+                  return {
+                    declined: true,
+                    reason: `a dependent file declines hot reload`,
+                    declinedBy: formatUrlForClient(
+                      urlInfoReferencingThisOne.url,
+                    ),
+                  };
+                }
+                const { hotAcceptDependencies = [] } =
+                  urlInfoReferencingThisOne.data;
+                if (hotAcceptDependencies.includes(urlInfo.url)) {
+                  boundaries.add(urlInfoReferencingThisOne);
+                  instructions.push({
+                    type: urlInfoReferencingThisOne.type,
+                    boundary: formatUrlForClient(urlInfoReferencingThisOne.url),
                     acceptedBy: formatUrlForClient(urlInfo.url),
-                  },
-                ],
-              };
-            }
-            const instructions = [];
-            for (const referenceFromOther of urlInfo.referenceFromOthersSet) {
-              if (referenceFromOther.isImplicit && referenceFromOther.isWeak) {
-                if (!referenceFromOther.original) {
+                  });
                   continue;
                 }
-                if (referenceFromOther.original.isWeak) {
+                if (chain.includes(urlInfoReferencingThisOne.url)) {
+                  return {
+                    declined: true,
+                    reason: "dead end",
+                    declinedBy: formatUrlForClient(
+                      urlInfoReferencingThisOne.url,
+                    ),
+                  };
+                }
+                const dependentPropagationResult = iterateMemoized(
+                  urlInfoReferencingThisOne,
+                  [...chain, urlInfoReferencingThisOne.url],
+                );
+                if (dependentPropagationResult.accepted) {
                   continue;
                 }
+                if (
+                  // declined explicitely by an other file, it must decline the whole update
+                  dependentPropagationResult.declinedBy
+                ) {
+                  return dependentPropagationResult;
+                }
+                // declined by absence of boundary, we can keep searching
               }
-              const urlInfoReferencingThisOne = referenceFromOther.ownerUrlInfo;
-              if (urlInfoReferencingThisOne.data.hotDecline) {
+              if (instructionCountBefore === instructions.length) {
                 return {
                   declined: true,
-                  reason: `a dependent file declines hot reload`,
-                  declinedBy: urlInfoReferencingThisOne.url,
+                  reason: `there is no file accepting hot reload while propagating update`,
                 };
               }
-              const { hotAcceptDependencies = [] } =
-                urlInfoReferencingThisOne.data;
-              if (hotAcceptDependencies.includes(urlInfo.url)) {
-                instructions.push({
-                  type: urlInfoReferencingThisOne.type,
-                  boundary: formatUrlForClient(urlInfoReferencingThisOne.url),
-                  acceptedBy: formatUrlForClient(urlInfo.url),
-                });
-                continue;
+              return {
+                accepted: true,
+                reason: `${instructions.length} dependent file(s) accepts hot reload`,
+              };
+            };
+
+            const map = new Map();
+            const iterateMemoized = (urlInfo, chain) => {
+              const resultFromCache = map.get(urlInfo.url);
+              if (resultFromCache) {
+                return resultFromCache;
               }
-              if (seen.includes(urlInfoReferencingThisOne.url)) {
-                return {
+              const result = iterate(urlInfo, chain);
+              map.set(urlInfo.url, result);
+              return result;
+            };
+            map.clear();
+            return iterateMemoized(firstUrlInfo, []);
+          };
+
+          let propagationResult = propagateUpdate(firstUrlInfo);
+          const seen = new Set();
+          const invalidateImporters = (urlInfo) => {
+            // to indicate this urlInfo should be modified
+            for (const referenceFromOther of urlInfo.referenceFromOthersSet) {
+              const urlInfoReferencingThisOne = referenceFromOther.ownerUrlInfo;
+              const { hotDecline, hotAcceptDependencies = [] } =
+                urlInfoReferencingThisOne.data;
+              if (hotDecline) {
+                propagationResult = {
                   declined: true,
-                  reason: "circular dependency",
+                  reason: `file declines hot reload`,
                   declinedBy: formatUrlForClient(urlInfoReferencingThisOne.url),
                 };
+                return;
               }
-              const dependentPropagationResult = iterate(
-                urlInfoReferencingThisOne,
-                [...seen, urlInfoReferencingThisOne.url],
-              );
-              if (dependentPropagationResult.accepted) {
-                instructions.push(...dependentPropagationResult.instructions);
+              if (hotAcceptDependencies.includes(urlInfo.url)) {
                 continue;
               }
-              if (
-                // declined explicitely by an other file, it must decline the whole update
-                dependentPropagationResult.declinedBy
-              ) {
-                return dependentPropagationResult;
+              if (seen.has(urlInfoReferencingThisOne)) {
+                continue;
               }
-              // declined by absence of boundary, we can keep searching
-            }
-            if (instructions.length === 0) {
-              return {
-                declined: true,
-                reason: `there is no file accepting hot reload while propagating update`,
-              };
+              seen.add(urlInfoReferencingThisOne);
+              // see https://github.com/vitejs/vite/blob/ab5bb40942c7023046fa6f6d0b49cabc105b6073/packages/vite/src/node/server/moduleGraph.ts#L205C5-L207C6
+              if (boundaries.has(urlInfoReferencingThisOne)) {
+                return;
+              }
+              urlInfoReferencingThisOne.descendantModifiedTimestamp =
+                Date.now();
+              invalidateImporters(urlInfoReferencingThisOne);
             }
-            return {
-              accepted: true,
-              reason: `${instructions.length} dependent file(s) accepts hot reload`,
-              instructions,
-            };
           };
-          const seen = [];
-          return iterate(firstUrlInfo, seen);
+          invalidateImporters(firstUrlInfo);
+          boundaries.clear();
+          seen.clear();
+          return {
+            ...propagationResult,
+            instructions,
+          };
         };
 
         // We are delaying the moment we tell client how to reload because:
@@ -134,7 +202,7 @@ export const jsenvPluginAutoreloadServer = ({
               if (!changedUrlInfo.isUsed()) {
                 continue;
               }
-              const hotUpdate = propagateUpdate(changedUrlInfo);
+              const hotUpdate = update(changedUrlInfo);
               const relativeUrl = formatUrlForClient(changedUrlInfo.url);
               if (hotUpdate.declined) {
                 reloadMessage = {
@@ -171,7 +239,7 @@ export const jsenvPluginAutoreloadServer = ({
               if (!ownerUrlInfo.isUsed()) {
                 continue;
               }
-              const ownerHotUpdate = propagateUpdate(ownerUrlInfo);
+              const ownerHotUpdate = update(ownerUrlInfo);
               const cause = `${formatUrlForClient(
                 prunedUrlInfo.url,
               )} is no longer referenced`;

package/src/plugins/autoreload/jsenv_plugin_hot_search_param.js

@@ -44,8 +44,16 @@ export const jsenvPluginHotSearchParam = () => {
       // At this stage the parent is using ?hot and we are going to decide if
       // we propagate the search param to child.
       const referencedUrlInfo = reference.urlInfo;
-      const { modifiedTimestamp, dereferencedTimestamp } = referencedUrlInfo;
-      if (!modifiedTimestamp && !dereferencedTimestamp) {
+      const {
+        modifiedTimestamp,
+        descendantModifiedTimestamp,
+        dereferencedTimestamp,
+      } = referencedUrlInfo;
+      if (
+        !modifiedTimestamp &&
+        !descendantModifiedTimestamp &&
+        !dereferencedTimestamp
+      ) {
         return null;
       }
       // The goal is to send an url that will bypass client (the browser) cache
@@ -58,10 +66,11 @@ export const jsenvPluginHotSearchParam = () => {
       // We use the latest timestamp to ensure it's fresh
       // The dereferencedTimestamp is needed because when a js module is re-referenced
       // browser must re-execute it, even if the code is not modified
-      const latestTimestamp =
-        dereferencedTimestamp && modifiedTimestamp
-          ? Math.max(dereferencedTimestamp, modifiedTimestamp)
-          : dereferencedTimestamp || modifiedTimestamp;
+      const latestTimestamp = Math.max(
+        modifiedTimestamp,
+        descendantModifiedTimestamp,
+        dereferencedTimestamp,
+      );
       return {
         hot: latestTimestamp,
       };

package/src/plugins/plugins.js

@@ -2,7 +2,6 @@ import { jsenvPluginSupervisor } from "@jsenv/plugin-supervisor";
 import { jsenvPluginTranspilation } from "@jsenv/plugin-transpilation";
 
 import { jsenvPluginReferenceAnalysis } from "./reference_analysis/jsenv_plugin_reference_analysis.js";
-import { jsenvPluginImportmap } from "./importmap/jsenv_plugin_importmap.js";
 import { jsenvPluginNodeEsmResolution } from "./resolution_node_esm/jsenv_plugin_node_esm_resolution.js";
 import { jsenvPluginWebResolution } from "./resolution_web/jsenv_plugin_web_resolution.js";
 import { jsenvPluginVersionSearchParam } from "./version_search_param/jsenv_plugin_version_search_param.js";
@@ -55,7 +54,6 @@ export const getCorePlugins = ({
     jsenvPluginReferenceAnalysis(referenceAnalysis),
     ...(injections ? [jsenvPluginInjections(injections)] : []),
     jsenvPluginTranspilation(transpilation),
-    jsenvPluginImportmap(),
     ...(inlining ? [jsenvPluginInlining()] : []),
     ...(supervisor ? [jsenvPluginSupervisor(supervisor)] : []), // after inline as it needs inline script to be cooked
 

package/src/plugins/protocol_file/jsenv_plugin_protocol_file.js

@@ -1,4 +1,5 @@
-import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { serveDirectory } from "@jsenv/server";
 import { pathToFileURL } from "node:url";
 import {
   urlIsInsideOf,
@@ -98,6 +99,7 @@ export const jsenvPluginProtocolFile = ({
         reference.leadsToADirectory = stat && stat.isDirectory();
         if (reference.leadsToADirectory) {
           const directoryAllowed =
+            reference.type === "http_request" ||
             reference.type === "filesystem" ||
             (typeof directoryReferenceAllowed === "function" &&
               directoryReferenceAllowed(reference)) ||
@@ -163,7 +165,6 @@ export const jsenvPluginProtocolFile = ({
         }
         const urlObject = new URL(urlInfo.url);
         if (urlInfo.firstReference.leadsToADirectory) {
-          const directoryEntries = readdirSync(urlObject);
           if (!urlInfo.filenameHint) {
             if (urlInfo.firstReference.type === "filesystem") {
               urlInfo.filenameHint = `${
@@ -173,10 +174,17 @@ export const jsenvPluginProtocolFile = ({
               urlInfo.filenameHint = `${urlToFilename(urlInfo.url)}/`;
             }
           }
+          const { headers, body } = serveDirectory(urlObject.href, {
+            headers: urlInfo.context.request
+              ? urlInfo.context.request.headers
+              : {},
+            rootDirectoryUrl: urlInfo.context.rootDirectoryUrl,
+          });
           return {
             type: "directory",
-            contentType: "application/json",
-            content: JSON.stringify(directoryEntries, null, "  "),
+            contentType: headers["content-type"],
+            contentLength: headers["content-length"],
+            content: body,
           };
         }
         if (

package/src/plugins/reference_analysis/directory/jsenv_plugin_directory_reference_analysis.js

@@ -11,6 +11,9 @@ export const jsenvPluginDirectoryReferenceAnalysis = () => {
           urlInfo.url,
           urlInfo.context.rootDirectoryUrl,
         );
+        if (urlInfo.contentType !== "application/json") {
+          return null;
+        }
         const entryNames = JSON.parse(urlInfo.content);
         const newEntryNames = [];
         for (const entryName of entryNames) {