@jsenv/core 36.2.1 → 36.3.1

package/src/kitchen/prepend_content.js

@@ -0,0 +1,135 @@
+import { createMagicSource, composeTwoSourcemaps } from "@jsenv/sourcemap";
+import {
+  parseHtmlString,
+  stringifyHtmlAst,
+  createHtmlNode,
+  injectHtmlNodeAsEarlyAsPossible,
+  applyBabelPlugins,
+} from "@jsenv/ast";
+
+export const prependContent = (
+  urlInfoTransformer,
+  urlInfoReceivingCode,
+  urlInfoToPrepend,
+) => {
+  // we could also implement:
+  // - prepend svg in html
+  // - prepend css in html
+  // - prepend css in css
+  // - maybe more?
+  // but no need for now
+  if (
+    urlInfoReceivingCode.type === "html" &&
+    urlInfoToPrepend.type === "js_classic"
+  ) {
+    return prependJsClassicInHtml(
+      urlInfoTransformer,
+      urlInfoReceivingCode,
+      urlInfoToPrepend,
+    );
+  }
+  if (
+    urlInfoReceivingCode.type === "js_classic" &&
+    urlInfoToPrepend.type === "js_classic"
+  ) {
+    return prependJsClassicInJsClassic(
+      urlInfoTransformer,
+      urlInfoReceivingCode,
+      urlInfoToPrepend,
+    );
+  }
+  if (
+    urlInfoReceivingCode.type === "js_module" &&
+    urlInfoToPrepend.type === "js_classic"
+  ) {
+    return prependJsClassicInJsModule(
+      urlInfoTransformer,
+      urlInfoReceivingCode,
+      urlInfoToPrepend,
+    );
+  }
+  throw new Error(
+    `cannot prepend content from "${urlInfoToPrepend.type}" into "${urlInfoReceivingCode.type}"`,
+  );
+};
+
+const prependJsClassicInHtml = (
+  urlInfoTransformer,
+  htmlUrlInfo,
+  urlInfoToPrepend,
+) => {
+  const htmlAst = parseHtmlString(htmlUrlInfo.content);
+  injectHtmlNodeAsEarlyAsPossible(
+    htmlAst,
+    createHtmlNode({
+      tagName: "script",
+      textContent: urlInfoToPrepend.content,
+      ...(urlInfoToPrepend.url
+        ? { "inlined-from-src": urlInfoToPrepend.url }
+        : {}),
+    }),
+    "jsenv:core",
+  );
+  const content = stringifyHtmlAst(htmlAst);
+  urlInfoTransformer.applyTransformations(htmlUrlInfo, { content });
+};
+
+const prependJsClassicInJsClassic = (
+  urlInfoTransformer,
+  jsUrlInfo,
+  urlInfoToPrepend,
+) => {
+  const magicSource = createMagicSource(jsUrlInfo.content);
+  magicSource.prepend(`${urlInfoToPrepend.content}\n\n`);
+  const magicResult = magicSource.toContentAndSourcemap();
+  const sourcemap = composeTwoSourcemaps(
+    jsUrlInfo.sourcemap,
+    magicResult.sourcemap,
+  );
+  urlInfoTransformer.applyTransformations(jsUrlInfo, {
+    content: magicResult.content,
+    sourcemap,
+  });
+};
+
+const prependJsClassicInJsModule = async (
+  urlInfoTransformer,
+  jsUrlInfo,
+  urlInfoToPrepend,
+) => {
+  const { code, map } = await applyBabelPlugins({
+    babelPlugins: [
+      [
+        babelPluginPrependCodeInJsModule,
+        { codeToPrepend: urlInfoToPrepend.content },
+      ],
+    ],
+    input: jsUrlInfo.content,
+    inputIsJsModule: true,
+    inputUrl: jsUrlInfo.originalUrl,
+  });
+  urlInfoTransformer.applyTransformations(jsUrlInfo, {
+    content: code,
+    sourcemap: map,
+  });
+};
+const babelPluginPrependCodeInJsModule = (babel) => {
+  return {
+    name: "prepend-code-in-js-module",
+    visitor: {
+      Program: (programPath, state) => {
+        const { codeToPrepend } = state.opts;
+        const astToPrepend = babel.parse(codeToPrepend);
+        const bodyNodePaths = programPath.get("body");
+        for (const bodyNodePath of bodyNodePaths) {
+          if (bodyNodePath.node.type === "ImportDeclaration") {
+            continue;
+          }
+          bodyNodePath.insertBefore(astToPrepend.program.body);
+          return;
+        }
+        bodyNodePaths.unshift(astToPrepend.program.body);
+      },
+    },
+  };
+};

package/src/kitchen/url_graph/url_graph_visitor.js

@@ -0,0 +1,99 @@
+export const GRAPH_VISITOR = {};
+
+GRAPH_VISITOR.map = (graph, callback) => {
+  const array = [];
+  graph.urlInfoMap.forEach((urlInfo) => {
+    array.push(callback(urlInfo));
+  });
+  return array;
+};
+GRAPH_VISITOR.forEach = (graph, callback) => {
+  graph.urlInfoMap.forEach(callback);
+};
+GRAPH_VISITOR.filter = (graph, callback) => {
+  const urlInfos = [];
+  graph.urlInfoMap.forEach((urlInfo) => {
+    if (callback(urlInfo)) {
+      urlInfos.push(urlInfo);
+    }
+  });
+  return urlInfos;
+};
+GRAPH_VISITOR.find = (graph, callback) => {
+  let found = null;
+  for (const urlInfo of graph.urlInfoMap.values()) {
+    if (callback(urlInfo)) {
+      found = urlInfo;
+      break;
+    }
+  }
+  return found;
+};
+GRAPH_VISITOR.findDependent = (graph, urlInfo, visitor) => {
+  const seen = new Set();
+  seen.add(urlInfo.url);
+  let found = null;
+  const visit = (dependentUrlInfo) => {
+    if (seen.has(dependentUrlInfo.url)) {
+      return false;
+    }
+    seen.add(dependentUrlInfo.url);
+    if (visitor(dependentUrlInfo)) {
+      found = dependentUrlInfo;
+    }
+    return true;
+  };
+  const iterate = (currentUrlInfo) => {
+    // When cookin html inline content, html references are not yet updated
+    // consequently htmlUrlInfo.dependencies is empty
+    // and inlineContentUrlInfo.dependents is empty as well
+    // in that case we resort to isInline + inlineUrlSite to establish the dependency
+    if (currentUrlInfo.isInline) {
+      const parentUrl = currentUrlInfo.inlineUrlSite.url;
+      const parentUrlInfo = graph.getUrlInfo(parentUrl);
+      visit(parentUrlInfo);
+      if (found) {
+        return;
+      }
+    }
+    for (const dependentUrl of currentUrlInfo.dependents) {
+      const dependentUrlInfo = graph.getUrlInfo(dependentUrl);
+      if (visit(dependentUrlInfo)) {
+        if (found) {
+          break;
+        }
+        iterate(dependentUrlInfo);
+      }
+    }
+  };
+  iterate(urlInfo);
+  return found;
+};
+GRAPH_VISITOR.findDependency = (graph, urlInfo, visitor) => {
+  const seen = new Set();
+  seen.add(urlInfo.url);
+  let found = null;
+  const visit = (dependencyUrlInfo) => {
+    if (seen.has(dependencyUrlInfo.url)) {
+      return false;
+    }
+    seen.add(dependencyUrlInfo.url);
+    if (visitor(dependencyUrlInfo)) {
+      found = dependencyUrlInfo;
+    }
+    return true;
+  };
+  const iterate = (currentUrlInfo) => {
+    for (const dependencyUrl of currentUrlInfo.dependencies) {
+      const dependencyUrlInfo = graph.getUrlInfo(dependencyUrl);
+      if (visit(dependencyUrlInfo)) {
+        if (found) {
+          break;
+        }
+        iterate(dependencyUrlInfo);
+      }
+    }
+  };
+  iterate(urlInfo);
+  return found;
+};

package/src/kitchen/url_graph/url_info_transformations.js

@@ -1,4 +1,5 @@
 import { pathToFileURL } from "node:url";
+import { parseJsWithAcorn } from "@jsenv/ast";
 import { bufferToEtag } from "@jsenv/filesystem";
 import { urlToRelativeUrl, isFileSystemPath } from "@jsenv/urls";
 import {
@@ -65,10 +66,80 @@ export const createUrlInfoTransformer = ({
     return sourcemap;
   };
 
-  const initTransformations = async (urlInfo, context) => {
-    urlInfo.originalContentEtag =
-      urlInfo.originalContentEtag ||
-      bufferToEtag(Buffer.from(urlInfo.originalContent));
+  const defineGettersOnPropertiesDerivedFromContent = (urlInfo) => {
+    const contentAstDescriptor = Object.getOwnPropertyDescriptor(
+      urlInfo,
+      "contentAst",
+    );
+    if (contentAstDescriptor.value === undefined) {
+      defineVolaliteGetter(urlInfo, "contentAst", () => {
+        if (urlInfo.content === urlInfo.originalContent) {
+          return urlInfo.originalContentAst;
+        }
+        const ast = getContentAst(urlInfo.content, urlInfo.type, urlInfo.url);
+        return ast;
+      });
+    }
+    const contentEtagDescriptor = Object.getOwnPropertyDescriptor(
+      urlInfo,
+      "contentEtag",
+    );
+    if (contentEtagDescriptor.value === undefined) {
+      defineVolaliteGetter(urlInfo, "contentEtag", () => {
+        if (urlInfo.content === urlInfo.originalContent) {
+          return urlInfo.originalContentEtag;
+        }
+        return getContentEtag(urlInfo.content);
+      });
+    }
+  };
+
+  const initTransformations = async (
+    urlInfo,
+    {
+      content,
+      contentAst, // most of the time will be undefined
+      contentEtag, // in practice it's always undefined
+      originalContent,
+      originalContentAst, // most of the time will be undefined
+      originalContentEtag, // in practice always undefined
+    },
+    context,
+  ) => {
+    urlInfo.contentFinalized = false;
+    urlInfo.originalContentAst = originalContentAst;
+    urlInfo.originalContentEtag = originalContentEtag;
+    if (originalContent !== urlInfo.originalContent) {
+      urlInfo.originalContent = originalContent;
+    }
+    const originalContentAstDescriptor = Object.getOwnPropertyDescriptor(
+      urlInfo,
+      "originalContentAst",
+    );
+    if (originalContentAstDescriptor.value === undefined) {
+      defineVolaliteGetter(urlInfo, "originalContentAst", () => {
+        return getContentAst(
+          urlInfo.originalContent,
+          urlInfo.type,
+          urlInfo.url,
+        );
+      });
+    }
+    const originalContentEtagDescriptor = Object.getOwnPropertyDescriptor(
+      urlInfo,
+      "originalContentEtag",
+    );
+    if (originalContentEtagDescriptor.value === undefined) {
+      defineVolaliteGetter(urlInfo, "originalContentEtag", () => {
+        return bufferToEtag(Buffer.from(urlInfo.originalContent));
+      });
+    }
+
+    urlInfo.contentAst = contentAst;
+    urlInfo.contentEtag = contentEtag;
+    urlInfo.content = content;
+    defineGettersOnPropertiesDerivedFromContent(urlInfo);
+
     if (!sourcemapsEnabled) {
       return;
     }
@@ -92,7 +163,6 @@ export const createUrlInfoTransformer = ({
     generatedUrlObject.searchParams.delete("as_js_classic");
     const urlForSourcemap = generatedUrlObject.href;
     urlInfo.sourcemapGeneratedUrl = generateSourcemapFileUrl(urlForSourcemap);
-
     // already loaded during "load" hook (happens during build)
     if (urlInfo.sourcemap) {
       const [sourcemapReference, sourcemapUrlInfo] = injectSourcemapPlaceholder(
@@ -106,7 +176,6 @@ export const createUrlInfoTransformer = ({
       urlInfo.sourcemap = normalizeSourcemap(urlInfo, urlInfo.sourcemap);
       return;
     }
-
     // check for existing sourcemap for this content
     const sourcemapFound = SOURCEMAP.readComment({
       contentType: urlInfo.contentType,
@@ -139,20 +208,30 @@ export const createUrlInfoTransformer = ({
     }
   };
 
-  const applyIntermediateTransformations = (urlInfo, transformations) => {
+  const applyTransformations = (urlInfo, transformations) => {
     if (!transformations) {
       return;
     }
-    const { type, contentType, content, sourcemap, sourcemapIsWrong } =
-      transformations;
+    const {
+      type,
+      contentType,
+      content,
+      contentAst, // undefined most of the time
+      contentEtag, // in practice always undefined
+      sourcemap,
+      sourcemapIsWrong,
+    } = transformations;
     if (type) {
       urlInfo.type = type;
     }
     if (contentType) {
       urlInfo.contentType = contentType;
     }
-    if (content) {
+    if (content && content !== urlInfo.content) {
       urlInfo.content = content;
+      urlInfo.contentAst = contentAst;
+      urlInfo.contentEtag = contentEtag;
+      defineGettersOnPropertiesDerivedFromContent(urlInfo);
     }
     if (sourcemapsEnabled && sourcemap) {
       const sourcemapNormalized = normalizeSourcemap(urlInfo, sourcemap);
@@ -176,12 +255,14 @@ export const createUrlInfoTransformer = ({
       // "no sourcemap is better than wrong sourcemap"
       urlInfo.sourcemapIsWrong = urlInfo.sourcemapIsWrong || sourcemapIsWrong;
     }
-  };
 
-  const applyFinalTransformations = (urlInfo, transformations) => {
-    if (transformations) {
-      applyIntermediateTransformations(urlInfo, transformations);
+    if (urlInfo.contentFinalized) {
+      applyTransformationsEffects(urlInfo);
     }
+  };
+
+  const applyTransformationsEffects = (urlInfo) => {
+    urlInfo.contentFinalized = true;
     if (urlInfo.sourcemapReference) {
       if (
         sourcemapsEnabled &&
@@ -235,16 +316,54 @@ export const createUrlInfoTransformer = ({
         urlGraph.deleteUrlInfo(urlInfo.sourcemapReference.url);
       }
     }
-
-    urlInfo.contentEtag =
-      urlInfo.content === urlInfo.originalContent
-        ? urlInfo.originalContentEtag
-        : bufferToEtag(Buffer.from(urlInfo.content));
   };
 
   return {
     initTransformations,
-    applyIntermediateTransformations,
-    applyFinalTransformations,
+    applyTransformations,
+    applyTransformationsEffects,
   };
 };
+
+const defineVolaliteGetter = (object, property, getter) => {
+  const restore = (value) => {
+    Object.defineProperty(object, property, {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value,
+    });
+  };
+
+  Object.defineProperty(object, property, {
+    enumerable: true,
+    configurable: true,
+    get: () => {
+      const value = getter();
+      restore(value);
+      return value;
+    },
+    set: restore,
+  });
+};
+
+const getContentAst = (content, type, url) => {
+  if (type === "js_module") {
+    return parseJsWithAcorn({
+      js: content,
+      url,
+      isJsModule: true,
+    });
+  }
+  if (type === "js_classic") {
+    return parseJsWithAcorn({
+      js: content,
+      url,
+    });
+  }
+  return null;
+};
+
+const getContentEtag = (content) => {
+  return bufferToEtag(Buffer.from(content));
+};

package/src/kitchen/url_graph.js

@@ -62,31 +62,6 @@ export const createUrlGraph = ({ name = "anonymous" } = {}) => {
     };
     return search(parentUrlInfo);
   };
-  const findDependent = (urlInfo, visitor) => {
-    const seen = [urlInfo.url];
-    let found = null;
-    const iterate = (currentUrlInfo) => {
-      for (const dependentUrl of currentUrlInfo.dependents) {
-        if (seen.includes(dependentUrl)) {
-          continue;
-        }
-        if (found) {
-          break;
-        }
-        seen.push(dependentUrl);
-        const dependentUrlInfo = getUrlInfo(dependentUrl);
-        if (visitor(dependentUrlInfo)) {
-          found = dependentUrlInfo;
-        }
-        if (found) {
-          break;
-        }
-        iterate(dependentUrlInfo);
-      }
-    };
-    iterate(urlInfo);
-    return found;
-  };
 
   const updateReferences = (urlInfo, references) => {
     const setOfDependencyUrls = new Set();
@@ -103,11 +78,12 @@ export const createUrlGraph = ({ name = "anonymous" } = {}) => {
       }
       const dependencyUrl = reference.url;
       setOfDependencyUrls.add(dependencyUrl);
-      // an implicit reference do not appear in the file but a non-explicited file have an impact on it
-      // (package.json on import resolution for instance)
+      // an implicit reference do not appear in the file but the non explicited file
+      // have an impact on it
+      // -> package.json on import resolution for instance
       // in that case:
       // - file depends on the implicit file (it must autoreload if package.json is modified)
-      // - cache validity for the file depends on the implicit file (it must be re-cooked in package.json is modified)
+      // - cache validity for the file depends on the implicit file (it must be re-cooked if package.json is modified)
       if (reference.isImplicit) {
         setOfImplicitUrls.add(dependencyUrl);
       }
@@ -207,6 +183,55 @@ export const createUrlGraph = ({ name = "anonymous" } = {}) => {
     iterate(urlInfo);
   };
 
+  const getEntryPoints = () => {
+    const entryPoints = [];
+    urlInfoMap.forEach((urlInfo) => {
+      if (urlInfo.isEntryPoint) {
+        entryPoints.push(urlInfo);
+      }
+    });
+    return entryPoints;
+  };
+
+  const hasDependent = (urlInfo) => {
+    for (const dependentUrl of urlInfo.dependents) {
+      const dependentUrlInfo = getUrlInfo(dependentUrl);
+      for (const reference of dependentUrlInfo.references) {
+        if (reference.url === urlInfo.url) {
+          if (
+            !reference.isInline &&
+            reference.next &&
+            reference.next.isInline
+          ) {
+            // the url info was inlined, an other reference is required
+            // to consider the non-inlined urlInfo as used
+            continue;
+          }
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+
+  const isUsed = (urlInfo) => {
+    // nothing uses this url anymore
+    // - versioning update inline content
+    // - file converted for import assertion or js_classic conversion
+    // - urlInfo for a file that is now inlined
+    if (urlInfo.isEntryPoint) {
+      return true;
+    }
+    // if (urlInfo.type === "sourcemap") {
+    //   return true;
+    // }
+    // check if there is a valid reference to this urlInfo
+    if (hasDependent(urlInfo)) {
+      return true;
+    }
+    return false;
+  };
+
   return {
     name,
     createUrlInfoCallbackRef,
@@ -217,11 +242,13 @@ export const createUrlGraph = ({ name = "anonymous" } = {}) => {
     getUrlInfo,
     deleteUrlInfo,
     getParentIfInline,
+    getEntryPoints,
+    hasDependent,
+    isUsed,
 
     inferReference,
     updateReferences,
     considerModified,
-    findDependent,
 
     toObject: () => {
       const data = {};
@@ -269,7 +296,10 @@ const createUrlInfo = (url) => {
     filename: "",
     isEntryPoint: false,
     originalContent: undefined,
+    originalContentAst: undefined,
     content: undefined,
+    contentAst: undefined,
+    contentFinalized: false,
 
     sourcemap: null,
     sourcemapReference: null,

package/src/plugins/autoreload/jsenv_plugin_hmr.js

@@ -18,8 +18,7 @@ export const jsenvPluginHmr = () => {
       return urlObject.href;
     },
     transformReferenceSearchParams: (reference, context) => {
-      if (reference.type === "package_json") {
-        // maybe the if above shoulb be .isImplicit but it's just a detail anyway
+      if (reference.isImplicit) {
         return null;
       }
       if (context.reference && !context.reference.data.hmr) {

package/src/plugins/import_meta_hot/jsenv_plugin_import_meta_hot.js

@@ -110,8 +110,8 @@ const injectImportMetaHot = (urlInfo, context, importMetaHotClientFileUrl) => {
   });
   const magicSource = createMagicSource(urlInfo.content);
   magicSource.prepend(
-    `import { createImportMetaHot } from ${importMetaHotClientFileReference.generatedSpecifier}
-import.meta.hot = createImportMetaHot(import.meta.url)
+    `import { createImportMetaHot } from ${importMetaHotClientFileReference.generatedSpecifier};
+import.meta.hot = createImportMetaHot(import.meta.url);
 `,
   );
   return magicSource.toContentAndSourcemap();

package/src/plugins/importmap/jsenv_plugin_importmap.js

@@ -184,8 +184,8 @@ export const jsenvPluginImportmap = () => {
             columnEnd,
           });
           context.referenceUtils.becomesInline(importmapReference, {
-            line: line - 1,
-            column,
+            specifierLine: line - 1,
+            specifierColumn: column,
             isOriginal,
             specifier: inlineImportmapUrl,
             contentType: "application/importmap+json",

package/src/plugins/inlining/jsenv_plugin_inlining_as_data_url.js

@@ -37,7 +37,7 @@ export const jsenvPluginInliningAsDataUrl = () => {
           const contentAsBase64 = Buffer.from(urlInfo.content).toString(
             "base64",
           );
-          const specifier = DATA_URL.stringify({
+          let specifier = DATA_URL.stringify({
             mediaType: urlInfo.contentType,
             base64Flag: true,
             data: contentAsBase64,