@jsenv/core 36.3.1 → 37.0.1

package/src/plugins/autoreload/jsenv_plugin_autoreload_server.js

@@ -1,8 +1,4 @@
-import {
-  urlIsInsideOf,
-  urlToRelativeUrl,
-  asUrlWithoutSearch,
-} from "@jsenv/urls";
+import { urlIsInsideOf, urlToRelativeUrl } from "@jsenv/urls";
 
 export const jsenvPluginAutoreloadServer = ({
   clientFileChangeCallbackList,
@@ -12,27 +8,26 @@ export const jsenvPluginAutoreloadServer = ({
     name: "jsenv:autoreload_server",
     appliesDuring: "dev",
     serverEvents: {
-      reload: ({ sendServerEvent, rootDirectoryUrl, urlGraph }) => {
+      reload: (serverEventInfo) => {
         const formatUrlForClient = (url) => {
-          if (urlIsInsideOf(url, rootDirectoryUrl)) {
-            return urlToRelativeUrl(url, rootDirectoryUrl);
+          if (urlIsInsideOf(url, serverEventInfo.rootDirectoryUrl)) {
+            return urlToRelativeUrl(url, serverEventInfo.rootDirectoryUrl);
           }
           if (url.startsWith("file:")) {
             return `/@fs/${url.slice("file:///".length)}`;
           }
           return url;
         };
-
-        const notifyDeclined = ({ cause, reason, declinedBy }) => {
-          sendServerEvent({
+        const notifyFullReload = ({ cause, reason, declinedBy }) => {
+          serverEventInfo.sendServerEvent({
             cause,
             type: "full",
             typeReason: reason,
             declinedBy,
           });
         };
-        const notifyAccepted = ({ cause, reason, instructions }) => {
-          sendServerEvent({
+        const notifyPartialReload = ({ cause, reason, instructions }) => {
+          serverEventInfo.sendServerEvent({
             cause,
             type: "hot",
             typeReason: reason,
@@ -40,7 +35,7 @@ export const jsenvPluginAutoreloadServer = ({
           });
         };
         const propagateUpdate = (firstUrlInfo) => {
-          if (!urlGraph.getUrlInfo(firstUrlInfo.url)) {
+          if (!serverEventInfo.kitchen.graph.getUrlInfo(firstUrlInfo.url)) {
             return {
               declined: true,
               reason: `url not in the url graph`,
@@ -63,37 +58,40 @@ export const jsenvPluginAutoreloadServer = ({
                 ],
               };
             }
-            const { dependents } = urlInfo;
             const instructions = [];
-            for (const dependentUrl of dependents) {
-              const dependentUrlInfo = urlGraph.getUrlInfo(dependentUrl);
-              if (dependentUrlInfo.data.hotDecline) {
+            for (const referenceFromOther of urlInfo.referenceFromOthersSet) {
+              if (referenceFromOther.isImplicit && referenceFromOther.isWeak) {
+                continue;
+              }
+              const urlInfoReferencingThisOne = referenceFromOther.ownerUrlInfo;
+              if (urlInfoReferencingThisOne.data.hotDecline) {
                 return {
                   declined: true,
                   reason: `a dependent file declines hot reload`,
-                  declinedBy: dependentUrl,
+                  declinedBy: urlInfoReferencingThisOne.url,
                 };
               }
-              const { hotAcceptDependencies = [] } = dependentUrlInfo.data;
+              const { hotAcceptDependencies = [] } =
+                urlInfoReferencingThisOne.data;
               if (hotAcceptDependencies.includes(urlInfo.url)) {
                 instructions.push({
-                  type: dependentUrlInfo.type,
-                  boundary: formatUrlForClient(dependentUrl),
+                  type: urlInfoReferencingThisOne.type,
+                  boundary: formatUrlForClient(urlInfoReferencingThisOne.url),
                   acceptedBy: formatUrlForClient(urlInfo.url),
                 });
                 continue;
               }
-              if (seen.includes(dependentUrl)) {
+              if (seen.includes(urlInfoReferencingThisOne.url)) {
                 return {
                   declined: true,
                   reason: "circular dependency",
-                  declinedBy: formatUrlForClient(dependentUrl),
+                  declinedBy: formatUrlForClient(urlInfoReferencingThisOne.url),
                 };
               }
-              const dependentPropagationResult = iterate(dependentUrlInfo, [
-                ...seen,
-                dependentUrl,
-              ]);
+              const dependentPropagationResult = iterate(
+                urlInfoReferencingThisOne,
+                [...seen, urlInfoReferencingThisOne.url],
+              );
               if (dependentPropagationResult.accepted) {
                 instructions.push(...dependentPropagationResult.instructions);
                 continue;
@@ -123,57 +121,61 @@ export const jsenvPluginAutoreloadServer = ({
         };
         clientFileChangeCallbackList.push(({ url, event }) => {
           const onUrlInfo = (urlInfo) => {
+            if (!urlInfo.isUsed()) {
+              return false;
+            }
             const relativeUrl = formatUrlForClient(urlInfo.url);
             const hotUpdate = propagateUpdate(urlInfo);
             if (hotUpdate.declined) {
-              notifyDeclined({
+              notifyFullReload({
                 cause: `${relativeUrl} ${event}`,
                 reason: hotUpdate.reason,
                 declinedBy: hotUpdate.declinedBy,
               });
-            } else {
-              notifyAccepted({
-                cause: `${relativeUrl} ${event}`,
-                reason: hotUpdate.reason,
-                instructions: hotUpdate.instructions,
-              });
+              return true;
             }
+            notifyPartialReload({
+              cause: `${relativeUrl} ${event}`,
+              reason: hotUpdate.reason,
+              instructions: hotUpdate.instructions,
+            });
+            return true;
           };
-          const exactUrlInfo = urlGraph.getUrlInfo(url);
-          if (exactUrlInfo) {
-            onUrlInfo(exactUrlInfo);
-          }
-          urlGraph.urlInfoMap.forEach((urlInfo) => {
-            if (urlInfo === exactUrlInfo) return;
-            const urlWithoutSearch = asUrlWithoutSearch(urlInfo.url);
-            if (urlWithoutSearch !== url) return;
-            if (exactUrlInfo && exactUrlInfo.dependents.has(urlInfo.url))
+
+          const urlInfo = serverEventInfo.kitchen.graph.getUrlInfo(url);
+          if (urlInfo) {
+            if (onUrlInfo(urlInfo)) {
               return;
-            onUrlInfo(urlInfo);
-          });
-        });
-        clientFilesPruneCallbackList.push((prunedUrlInfos, firstUrlInfo) => {
-          const mainHotUpdate = propagateUpdate(firstUrlInfo);
-          const cause = `following files are no longer referenced: ${prunedUrlInfos.map(
-            (prunedUrlInfo) => formatUrlForClient(prunedUrlInfo.url),
-          )}`;
-          // now check if we can hot update the main resource
-          // then if we can hot update all dependencies
-          if (mainHotUpdate.declined) {
-            notifyDeclined({
-              cause,
-              reason: mainHotUpdate.reason,
-              declinedBy: mainHotUpdate.declinedBy,
-            });
-            return;
+            }
+            for (const searchParamVariant of urlInfo.searchParamVariantSet) {
+              if (onUrlInfo(searchParamVariant)) {
+                return;
+              }
+            }
           }
-          // main can hot update
-          let i = 0;
-          const instructions = [];
-          while (i < prunedUrlInfos.length) {
-            const prunedUrlInfo = prunedUrlInfos[i++];
+        });
+        clientFilesPruneCallbackList.push(
+          (prunedUrlInfo, lastReferenceFromOther) => {
+            const parentHotUpdate = propagateUpdate(
+              lastReferenceFromOther.ownerUrlInfo,
+            );
+            const cause = `following file is no longer referenced: ${formatUrlForClient(
+              prunedUrlInfo.url,
+            )}`;
+            // now check if we can hot update the parent resource
+            // then if we can hot update all dependencies
+            if (parentHotUpdate.declined) {
+              notifyFullReload({
+                cause,
+                reason: parentHotUpdate.reason,
+                declinedBy: parentHotUpdate.declinedBy,
+              });
+              return;
+            }
+            // parent can hot update
+            const instructions = [];
             if (prunedUrlInfo.data.hotDecline) {
-              notifyDeclined({
+              notifyFullReload({
                 cause,
                 reason: `a pruned file declines hot reload`,
                 declinedBy: formatUrlForClient(prunedUrlInfo.url),
@@ -183,20 +185,24 @@ export const jsenvPluginAutoreloadServer = ({
             instructions.push({
               type: "prune",
               boundary: formatUrlForClient(prunedUrlInfo.url),
-              acceptedBy: formatUrlForClient(firstUrlInfo.url),
+              acceptedBy: formatUrlForClient(
+                lastReferenceFromOther.ownerUrlInfo.url,
+              ),
             });
-          }
-          notifyAccepted({
-            cause,
-            reason: mainHotUpdate.reason,
-            instructions,
-          });
-        });
+            notifyPartialReload({
+              cause,
+              reason: parentHotUpdate.reason,
+              instructions,
+            });
+          },
+        );
       },
     },
-    serve: (request, { rootDirectoryUrl, urlGraph }) => {
-      if (request.pathname === "/__graph__") {
-        const graphJson = JSON.stringify(urlGraph.toJSON(rootDirectoryUrl));
+    serve: (serveInfo) => {
+      if (serveInfo.request.pathname === "/__graph__") {
+        const graphJson = JSON.stringify(
+          serveInfo.kitchen.graph.toJSON(serveInfo.rootDirectoryUrl),
+        );
         return {
           status: 200,
           headers: {

package/src/plugins/autoreload/jsenv_plugin_hot_search_param.js

@@ -0,0 +1,52 @@
+export const jsenvPluginHotSearchParam = () => {
+  const shouldInjectHotSearchParam = (reference) => {
+    if (reference.isImplicit) {
+      return false;
+    }
+    if (reference.original && reference.original.searchParams.has("hot")) {
+      return true;
+    }
+    // parent is using ?hot -> propagate
+    const { ownerUrlInfo } = reference;
+    const lastReference = ownerUrlInfo.context.reference;
+    if (
+      lastReference &&
+      lastReference.original &&
+      lastReference.original.searchParams.has("hot")
+    ) {
+      return true;
+    }
+    return false;
+  };
+
+  return {
+    name: "jsenv:hot_search_param",
+    appliesDuring: "dev",
+    redirectReference: (reference) => {
+      if (!reference.searchParams.has("hot")) {
+        return null;
+      }
+      const urlObject = new URL(reference.url);
+      // "hot" search param goal is to invalide url in browser cache:
+      // this goal is achieved when we reach this part of the code
+      // We get rid of this params so that urlGraph and other parts of the code
+      // recognize the url (it is not considered as a different url)
+      urlObject.searchParams.delete("hot");
+      urlObject.searchParams.delete("v");
+      return urlObject.href;
+    },
+    transformReferenceSearchParams: (reference) => {
+      if (!shouldInjectHotSearchParam(reference)) {
+        return null;
+      }
+      const referencedUrlInfo = reference.urlInfo;
+      if (!referencedUrlInfo.modifiedTimestamp) {
+        return null;
+      }
+      return {
+        hot: "",
+        v: referencedUrlInfo.modifiedTimestamp,
+      };
+    },
+  };
+};

package/src/plugins/cache_control/jsenv_plugin_cache_control.js

@@ -9,7 +9,7 @@ export const jsenvPluginCacheControl = ({
       if (
         versionedUrls &&
         reference.searchParams.has("v") &&
-        !reference.searchParams.has("hmr")
+        !reference.searchParams.has("hot")
       ) {
         return {
           headers: {

package/src/plugins/commonjs_globals/jsenv_plugin_commonjs_globals.js

@@ -11,7 +11,7 @@ import { createMagicSource } from "@jsenv/sourcemap";
 import { applyBabelPlugins } from "@jsenv/ast";
 
 export const jsenvPluginCommonJsGlobals = () => {
-  const transformCommonJsGlobals = async (urlInfo, context) => {
+  const transformCommonJsGlobals = async (urlInfo) => {
     if (
       !urlInfo.content.includes("process.env.NODE_ENV") &&
       !urlInfo.content.includes("__filename") &&
@@ -22,7 +22,7 @@ export const jsenvPluginCommonJsGlobals = () => {
     const isJsModule = urlInfo.type === "js_module";
     const replaceMap = {
       "process.env.NODE_ENV": `("${
-        context.dev ? "development" : "production"
+        urlInfo.context.dev ? "development" : "production"
       }")`,
       "global": "globalThis",
       "__filename": isJsModule

package/src/plugins/global_scenarios/jsenv_plugin_global_scenarios.js

@@ -8,10 +8,10 @@
 import { replacePlaceholders } from "@jsenv/plugin-placeholders";
 
 export const jsenvPluginGlobalScenarios = () => {
-  const transformIfNeeded = (urlInfo, context) => {
+  const transformIfNeeded = (urlInfo) => {
     return replacePlaceholders(urlInfo, {
-      __DEV__: context.dev,
-      __BUILD__: context.build,
+      __DEV__: urlInfo.context.dev,
+      __BUILD__: urlInfo.context.build,
     });
   };
 

package/src/plugins/import_meta_hot/client/import_meta_hot.js

@@ -7,7 +7,7 @@ export const urlHotMetas = {};
 
 export const createImportMetaHot = (importMetaUrl) => {
   const data = {};
-  const url = asUrlWithoutHmrQuery(importMetaUrl);
+  const url = asUrlWithoutHotSearchParam(importMetaUrl);
 
   return {
     data,
@@ -71,10 +71,10 @@ const addUrlMeta = (url, meta) => {
   };
 };
 
-const asUrlWithoutHmrQuery = (url) => {
+const asUrlWithoutHotSearchParam = (url) => {
   const urlObject = new URL(url);
-  if (urlObject.searchParams.has("hmr")) {
-    urlObject.searchParams.delete("hmr");
+  if (urlObject.searchParams.has("hot")) {
+    urlObject.searchParams.delete("hot");
     urlObject.searchParams.delete("v");
     return urlObject.href;
   }

package/src/plugins/import_meta_hot/jsenv_plugin_import_meta_hot.js

@@ -14,9 +14,9 @@ export const jsenvPluginImportMetaHot = () => {
     name: "jsenv:import_meta_hot",
     appliesDuring: "*",
     transformUrlContent: {
-      html: (htmlUrlInfo, context) => {
+      html: (htmlUrlInfo) => {
         // during build we don't really care to parse html hot dependencies
-        if (context.build) {
+        if (htmlUrlInfo.context.build) {
           return;
         }
         const htmlAst = parseHtmlString(htmlUrlInfo.content);
@@ -25,18 +25,20 @@ export const jsenvPluginImportMetaHot = () => {
         htmlUrlInfo.data.hotAcceptSelf = false;
         htmlUrlInfo.data.hotAcceptDependencies = hotReferences.map(
           ({ type, specifier }) => {
-            const existingReference = context.referenceUtils.find(
-              (existingReference) => {
-                return (
-                  existingReference.type === type &&
-                  existingReference.specifier === specifier
-                );
-              },
-            );
+            let existingReference = null;
+            for (const referenceToOther of htmlUrlInfo.referenceToOthersSet) {
+              if (
+                referenceToOther.type === type &&
+                referenceToOther.specifier === specifier
+              ) {
+                existingReference = referenceToOther;
+                break;
+              }
+            }
             if (existingReference) {
               return existingReference.url;
             }
-            const [reference] = context.referenceUtils.found({
+            const reference = htmlUrlInfo.dependencies.found({
               type,
               specifier,
             });
@@ -49,7 +51,7 @@ export const jsenvPluginImportMetaHot = () => {
         cssUrlInfo.data.hotAcceptSelf = false;
         cssUrlInfo.data.hotAcceptDependencies = [];
       },
-      js_module: async (urlInfo, context) => {
+      js_module: async (urlInfo) => {
         if (!urlInfo.content.includes("import.meta.hot")) {
           return null;
         }
@@ -72,14 +74,10 @@ export const jsenvPluginImportMetaHot = () => {
         if (importMetaHotPaths.length === 0) {
           return null;
         }
-        if (context.build) {
+        if (urlInfo.context.build) {
           return removeImportMetaHots(urlInfo, importMetaHotPaths);
         }
-        return injectImportMetaHot(
-          urlInfo,
-          context,
-          importMetaHotClientFileUrl,
-        );
+        return injectImportMetaHot(urlInfo, importMetaHotClientFileUrl);
       },
     },
   };
@@ -101,8 +99,8 @@ const removeImportMetaHots = (urlInfo, importMetaHotPaths) => {
 // better sourcemap than doing the equivalent with babel
 // I suspect it's because I was doing injectAstAfterImport(programPath, ast.program.body[0])
 // which is likely not well supported by babel
-const injectImportMetaHot = (urlInfo, context, importMetaHotClientFileUrl) => {
-  const [importMetaHotClientFileReference] = context.referenceUtils.inject({
+const injectImportMetaHot = (urlInfo, importMetaHotClientFileUrl) => {
+  const importMetaHotClientFileReference = urlInfo.dependencies.inject({
     parentUrl: urlInfo.url,
     type: "js_import",
     expectedType: "js_module",

package/src/plugins/import_meta_scenarios/jsenv_plugin_import_meta_scenarios.js

@@ -16,7 +16,7 @@ export const jsenvPluginImportMetaScenarios = () => {
     name: "jsenv:import_meta_scenario",
     appliesDuring: "*",
     transformUrlContent: {
-      js_module: async (urlInfo, context) => {
+      js_module: async (urlInfo) => {
         if (
           !urlInfo.content.includes("import.meta.dev") &&
           !urlInfo.content.includes("import.meta.test") &&
@@ -36,7 +36,7 @@ export const jsenvPluginImportMetaScenarios = () => {
         const replace = (path, value) => {
           replacements.push({ path, value });
         };
-        if (context.build) {
+        if (urlInfo.context.build) {
           // during build ensure replacement for tree-shaking
           dev.forEach((path) => {
             replace(path, "undefined");

package/src/plugins/importmap/jsenv_plugin_importmap.js

@@ -66,7 +66,7 @@ export const jsenvPluginImportmap = () => {
           let fromMapping = false;
           const result = resolveImport({
             specifier: reference.specifier,
-            importer: reference.parentUrl,
+            importer: reference.ownerUrlInfo.url,
             importMap: finalImportmap,
             onImportMapping: () => {
               fromMapping = true;
@@ -90,7 +90,7 @@ export const jsenvPluginImportmap = () => {
       },
     },
     transformUrlContent: {
-      html: async (htmlUrlInfo, context) => {
+      html: async (htmlUrlInfo) => {
         const htmlAst = parseHtmlString(htmlUrlInfo.content);
         const importmap = findHtmlNode(htmlAst, (node) => {
           if (node.nodeName !== "script") {
@@ -119,8 +119,8 @@ export const jsenvPluginImportmap = () => {
             lineEnd,
             columnEnd,
           });
-          const [inlineImportmapReference, inlineImportmapUrlInfo] =
-            context.referenceUtils.foundInline({
+          const inlineImportmapReference = htmlUrlInfo.dependencies.foundInline(
+            {
               type: "script",
               isOriginalPosition: isOriginal,
               specifierLine: line - 1,
@@ -128,10 +128,10 @@ export const jsenvPluginImportmap = () => {
               specifier: inlineImportmapUrl,
               contentType: "application/importmap+json",
               content: htmlNodeText,
-            });
-          await context.cook(inlineImportmapUrlInfo, {
-            reference: inlineImportmapReference,
-          });
+            },
+          );
+          const inlineImportmapUrlInfo = inlineImportmapReference.urlInfo;
+          await inlineImportmapUrlInfo.cook();
           setHtmlNodeText(importmap, inlineImportmapUrlInfo.content, {
             indentation: "auto",
           });
@@ -149,33 +149,18 @@ export const jsenvPluginImportmap = () => {
           // We must precook the importmap to know its content and inline it into the HTML
           // In this situation the ref to the importmap was already discovered
           // when parsing the HTML
-          const importmapReference = context.referenceUtils.find(
-            (ref) => ref.generatedSpecifier === src,
-          );
-          const importmapUrlInfo = context.urlGraph.getUrlInfo(
-            importmapReference.url,
-          );
-          await context.cook(importmapUrlInfo, {
-            reference: importmapReference,
-          });
-          onHtmlImportmapParsed(
-            JSON.parse(importmapUrlInfo.content),
-            htmlUrlInfo.url,
-          );
-          setHtmlNodeText(importmap, importmapUrlInfo.content, {
-            indentation: "auto",
-          });
-          setHtmlNodeAttributes(importmap, {
-            "src": undefined,
-            "jsenv-inlined-by": "jsenv:importmap",
-            "inlined-from-src": src,
-          });
-
+          let importmapReference = null;
+          for (const referenceToOther of htmlUrlInfo.referenceToOthersSet) {
+            if (referenceToOther.generatedSpecifier === src) {
+              importmapReference = referenceToOther;
+              break;
+            }
+          }
           const { line, column, lineEnd, columnEnd, isOriginal } =
             getHtmlNodePosition(importmap, {
               preferOriginal: true,
             });
-          const inlineImportmapUrl = generateInlineContentUrl({
+          const importmapInlineUrl = generateInlineContentUrl({
             url: htmlUrlInfo.url,
             extension: ".importmap",
             line,
@@ -183,13 +168,26 @@ export const jsenvPluginImportmap = () => {
             lineEnd,
             columnEnd,
           });
-          context.referenceUtils.becomesInline(importmapReference, {
-            specifierLine: line - 1,
-            specifierColumn: column,
+          const importmapReferenceInlined = importmapReference.inline({
+            line: line - 1,
+            column,
             isOriginal,
-            specifier: inlineImportmapUrl,
+            specifier: importmapInlineUrl,
             contentType: "application/importmap+json",
-            content: importmapUrlInfo.content,
+          });
+          const importmapInlineUrlInfo = importmapReferenceInlined.urlInfo;
+          await importmapInlineUrlInfo.cook();
+          onHtmlImportmapParsed(
+            JSON.parse(importmapInlineUrlInfo.content),
+            htmlUrlInfo.url,
+          );
+          setHtmlNodeText(importmap, importmapInlineUrlInfo.content, {
+            indentation: "auto",
+          });
+          setHtmlNodeAttributes(importmap, {
+            "src": undefined,
+            "jsenv-inlined-by": "jsenv:importmap",
+            "inlined-from-src": src,
           });
         };
 
@@ -207,7 +205,7 @@ export const jsenvPluginImportmap = () => {
         // by "formatReferencedUrl" making the importmap presence useless.
         // In dev/test we keep importmap into the HTML to see it even if useless
         // Duing build we get rid of it
-        if (context.build) {
+        if (htmlUrlInfo.context.build) {
           removeHtmlNode(importmap);
         }
         return {

package/src/plugins/inlining/jsenv_plugin_inlining.js

@@ -2,21 +2,5 @@ import { jsenvPluginInliningAsDataUrl } from "./jsenv_plugin_inlining_as_data_ur
 import { jsenvPluginInliningIntoHtml } from "./jsenv_plugin_inlining_into_html.js";
 
 export const jsenvPluginInlining = () => {
-  return [
-    {
-      name: "jsenv:inlining",
-      appliesDuring: "*",
-      redirectReference: (reference) => {
-        const { searchParams } = reference;
-        if (searchParams.has("inline")) {
-          const urlObject = new URL(reference.url);
-          urlObject.searchParams.delete("inline");
-          return urlObject.href;
-        }
-        return null;
-      },
-    },
-    jsenvPluginInliningAsDataUrl(),
-    jsenvPluginInliningIntoHtml(),
-  ];
+  return [jsenvPluginInliningAsDataUrl(), jsenvPluginInliningIntoHtml()];
 };