@jsenv/core 36.3.0 → 37.0.0

package/src/plugins/reference_analysis/data_urls/jsenv_plugin_data_urls_analysis.js

@@ -2,6 +2,22 @@ import { DATA_URL } from "@jsenv/urls";
 import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
 
 export const jsenvPluginDataUrlsAnalysis = () => {
+  const cookDataUrl = async (reference) => {
+    const urlInfo = reference.urlInfo;
+    await urlInfo.cook();
+    if (urlInfo.originalContent === urlInfo.content) {
+      return reference.generatedUrl;
+    }
+    const specifier = DATA_URL.stringify({
+      contentType: urlInfo.contentType,
+      base64Flag: urlInfo.data.base64Flag,
+      data: urlInfo.data.base64Flag
+        ? dataToBase64(urlInfo.content)
+        : String(urlInfo.content),
+    });
+    return specifier;
+  };
+
   return {
     name: "jsenv:data_urls_analysis",
     appliesDuring: "*",
@@ -11,28 +27,14 @@ export const jsenvPluginDataUrlsAnalysis = () => {
       }
       return reference.specifier;
     },
-    formatReference: (reference, context) => {
+    formatReference: (reference) => {
       if (!reference.generatedUrl.startsWith("data:")) {
         return null;
       }
       if (reference.type === "sourcemap_comment") {
         return null;
       }
-      return (async () => {
-        const urlInfo = context.urlGraph.getUrlInfo(reference.url);
-        await context.cook(urlInfo, { reference });
-        if (urlInfo.originalContent === urlInfo.content) {
-          return reference.generatedUrl;
-        }
-        const specifier = DATA_URL.stringify({
-          contentType: urlInfo.contentType,
-          base64Flag: urlInfo.data.base64Flag,
-          data: urlInfo.data.base64Flag
-            ? dataToBase64(urlInfo.content)
-            : String(urlInfo.content),
-        });
-        return specifier;
-      })();
+      return cookDataUrl(reference);
     },
     fetchUrlContent: (urlInfo) => {
       if (!urlInfo.url.startsWith("data:")) {

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

@@ -4,17 +4,15 @@ export const jsenvPluginDirectoryReferenceAnalysis = () => {
   return {
     name: "jsenv:directory_reference_analysis",
     transformUrlContent: {
-      directory: (urlInfo, context) => {
-        const originalDirectoryReference = findOriginalDirectoryReference(
-          urlInfo,
-          context,
-        );
+      directory: (urlInfo) => {
+        const originalDirectoryReference =
+          findOriginalDirectoryReference(urlInfo);
         const directoryRelativeUrl = urlToRelativeUrl(
           urlInfo.url,
-          context.rootDirectoryUrl,
+          urlInfo.context.rootDirectoryUrl,
         );
         JSON.parse(urlInfo.content).forEach((directoryEntryName) => {
-          context.referenceUtils.found({
+          urlInfo.dependencies.found({
             type: "filesystem",
             subtype: "directory_entry",
             specifier: directoryEntryName,
@@ -28,24 +26,19 @@ export const jsenvPluginDirectoryReferenceAnalysis = () => {
   };
 };
 
-const findOriginalDirectoryReference = (urlInfo, context) => {
+const findOriginalDirectoryReference = (urlInfo) => {
   const findNonFileSystemAncestor = (urlInfo) => {
-    for (const dependentUrl of urlInfo.dependents) {
-      const dependentUrlInfo = context.urlGraph.getUrlInfo(dependentUrl);
-      if (dependentUrlInfo.type !== "directory") {
-        return [dependentUrlInfo, urlInfo];
+    for (const referenceFromOther of urlInfo.referenceFromOthersSet) {
+      const urlInfoReferencingThisOne = referenceFromOther.ownerUrlInfo;
+      if (urlInfoReferencingThisOne.type !== "directory") {
+        return referenceFromOther;
       }
-      const found = findNonFileSystemAncestor(dependentUrlInfo);
+      const found = findNonFileSystemAncestor(urlInfoReferencingThisOne);
       if (found) {
         return found;
       }
     }
-    return [];
-  };
-  const [ancestor, child] = findNonFileSystemAncestor(urlInfo);
-  if (!ancestor) {
     return null;
-  }
-  const ref = ancestor.references.find((ref) => ref.url === child.url);
-  return ref;
+  };
+  return findNonFileSystemAncestor(urlInfo);
 };

package/src/plugins/reference_analysis/html/jsenv_plugin_html_reference_analysis.js

@@ -23,8 +23,8 @@ export const jsenvPluginHtmlReferenceAnalysis = ({
     name: "jsenv:html_reference_analysis",
     appliesDuring: "*",
     transformUrlContent: {
-      html: (urlInfo, context) =>
-        parseAndTransformHtmlReferences(urlInfo, context, {
+      html: (urlInfo) =>
+        parseAndTransformHtmlReferences(urlInfo, {
           inlineContent,
           inlineConvertedScript,
         }),
@@ -34,7 +34,6 @@ export const jsenvPluginHtmlReferenceAnalysis = ({
 
 const parseAndTransformHtmlReferences = async (
   urlInfo,
-  context,
   { inlineContent, inlineConvertedScript },
 ) => {
   const content = urlInfo.content;
@@ -48,7 +47,7 @@ const parseAndTransformHtmlReferences = async (
     node,
     attributeName,
     attributeValue,
-    { type, subtype, expectedType },
+    { type, subtype, expectedType, ...rest },
   ) => {
     let position;
     if (getHtmlNodeAttribute(node, "jsenv-cooked-by")) {
@@ -73,21 +72,39 @@ const parseAndTransformHtmlReferences = async (
       "preload",
       "modulepreload",
     ].includes(subtype);
-    const [reference] = context.referenceUtils.found({
-      node,
+    let attributeLocation = node.sourceCodeLocation.attrs[attributeName];
+    if (
+      !attributeLocation &&
+      attributeName === "href" &&
+      (node.tagName === "use" || node.tagName === "image")
+    ) {
+      attributeLocation = node.sourceCodeLocation.attrs["xlink:href"];
+    }
+    const attributeStart = attributeLocation.startOffset;
+    const attributeValueStart = urlInfo.content.indexOf(
+      attributeValue,
+      attributeStart + `${attributeName}=`.length,
+    );
+    const attributeValueEnd = attributeValueStart + attributeValue.length;
+    const reference = urlInfo.dependencies.found({
       type,
       subtype,
       expectedType,
       specifier: attributeValue,
       specifierLine: line,
       specifierColumn: column,
+      specifierStart: attributeValueStart,
+      specifierEnd: attributeValueEnd,
       isResourceHint,
+      isWeak: isResourceHint,
       crossorigin,
       integrity,
       debug,
+      astInfo: { node, attributeName },
+      ...rest,
     });
     actions.push(async () => {
-      await context.referenceUtils.readGeneratedSpecifier(reference);
+      await reference.readGeneratedSpecifier();
       mutations.push(() => {
         setHtmlNodeAttributes(node, {
           [attributeName]: reference.generatedSpecifier,
@@ -143,23 +160,21 @@ const parseAndTransformHtmlReferences = async (
       columnEnd,
     });
     const debug = getHtmlNodeAttribute(node, "jsenv-debug") !== undefined;
-    const [inlineReference, inlineUrlInfo] = context.referenceUtils.foundInline(
-      {
-        node,
-        type,
-        expectedType,
-        isOriginalPosition: isOriginal,
-        // we remove 1 to the line because imagine the following html:
-        // <style>body { color: red; }</style>
-        // -> content starts same line as <style> (same for <script>)
-        specifierLine: line - 1,
-        specifierColumn: column,
-        specifier: inlineContentUrl,
-        contentType,
-        content: inlineContent,
-        debug,
-      },
-    );
+    const inlineReference = urlInfo.dependencies.foundInline({
+      type,
+      expectedType,
+      isOriginalPosition: isOriginal,
+      // we remove 1 to the line because imagine the following html:
+      // <style>body { color: red; }</style>
+      // -> content starts same line as <style> (same for <script>)
+      specifierLine: line - 1,
+      specifierColumn: column,
+      specifier: inlineContentUrl,
+      contentType,
+      content: inlineContent,
+      debug,
+      astInfo: { node },
+    });
 
     const externalSpecifierAttributeName =
       type === "script"
@@ -174,27 +189,22 @@ const parseAndTransformHtmlReferences = async (
       );
       if (externalSpecifier) {
         // create an external ref
-        // the goal is only to have the url in the graph (and in dependencies/implitic urls for reload)
+        // the goal is only to have the url in the graph (and in dependencies/implicit urls for reload)
         // not to consider the url is actually used (at least during build)
-        // maybe we can just exlcude these urls in a special if during build, we'll see
+        // maybe we can just exclude these urls in a special if during build, we'll see
         const externalRef = createExternalReference(
           node,
           externalSpecifierAttributeName,
           externalSpecifier,
-          { type, subtype, expectedType },
+          { type, subtype, expectedType, next: inlineReference },
         );
         inlineReference.prev = externalRef;
         inlineReference.original = externalRef;
-        externalRef.next = inlineReference;
       }
     }
 
     actions.push(async () => {
-      await cookInlineContent({
-        context,
-        inlineContentUrlInfo: inlineUrlInfo,
-        inlineContentReference: inlineReference,
-      });
+      await inlineReference.urlInfo.cook();
       mutations.push(() => {
         if (hotAccept) {
           removeHtmlNodeText(node);
@@ -202,7 +212,7 @@ const parseAndTransformHtmlReferences = async (
             "jsenv-cooked-by": "jsenv:html_inline_content_analysis",
           });
         } else {
-          setHtmlNodeText(node, inlineUrlInfo.content, {
+          setHtmlNodeText(node, inlineReference.urlInfo.content, {
             indentation: false, // indentation would decrease stack trace precision
           });
           setHtmlNodeAttributes(node, {
@@ -242,7 +252,7 @@ const parseAndTransformHtmlReferences = async (
       });
       if (ref) {
         finalizeCallbacks.push(() => {
-          ref.expectedType = decideLinkExpectedType(ref, context);
+          ref.expectedType = decideLinkExpectedType(ref, urlInfo);
         });
       }
     },
@@ -365,33 +375,6 @@ const parseAndTransformHtmlReferences = async (
   return stringifyHtmlAst(htmlAst);
 };
 
-const cookInlineContent = async ({
-  context,
-  inlineContentUrlInfo,
-  inlineContentReference,
-}) => {
-  try {
-    await context.cook(inlineContentUrlInfo, {
-      reference: inlineContentReference,
-    });
-  } catch (e) {
-    if (e.code === "PARSE_ERROR") {
-      // When something like <style> or <script> contains syntax error
-      // the HTML in itself it still valid
-      // keep the syntax error and continue with the HTML
-      const messageStart =
-        inlineContentUrlInfo.type === "css"
-          ? `Syntax error on css declared inside <style>`
-          : `Syntax error on js declared inside <script>`;
-
-      context.logger.error(`${messageStart}: ${e.cause.reasonCode}
-${e.traceMessage}`);
-    } else {
-      throw e;
-    }
-  }
-};
-
 const crossOriginCompatibleTagNames = ["script", "link", "img", "source"];
 const integrityCompatibleTagNames = ["script", "link", "img", "source"];
 const readFetchMetas = (node) => {
@@ -407,8 +390,8 @@ const readFetchMetas = (node) => {
   return meta;
 };
 
-const decideLinkExpectedType = (linkReference, context) => {
-  const rel = getHtmlNodeAttribute(linkReference.node, "rel");
+const decideLinkExpectedType = (linkReference, htmlUrlInfo) => {
+  const rel = getHtmlNodeAttribute(linkReference.astInfo.node, "rel");
   if (rel === "webmanifest") {
     return "webmanifest";
   }
@@ -420,7 +403,7 @@ const decideLinkExpectedType = (linkReference, context) => {
   }
   if (rel === "preload") {
     // https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload#what_types_of_content_can_be_preloaded
-    const as = getHtmlNodeAttribute(linkReference.node, "as");
+    const as = getHtmlNodeAttribute(linkReference.astInfo.node, "as");
     if (as === "document") {
       return "html";
     }
@@ -428,13 +411,13 @@ const decideLinkExpectedType = (linkReference, context) => {
       return "css";
     }
     if (as === "script") {
-      const firstScriptOnThisUrl = context.referenceUtils.find(
-        (refCandidate) =>
-          refCandidate.url === linkReference.url &&
-          refCandidate.type === "script",
-      );
-      if (firstScriptOnThisUrl) {
-        return firstScriptOnThisUrl.expectedType;
+      for (const referenceToOther of htmlUrlInfo.referenceToOthersSet) {
+        if (
+          referenceToOther.url === linkReference.url &&
+          referenceToOther.type === "script"
+        ) {
+          return referenceToOther.expectedType;
+        }
       }
       return undefined;
     }

package/src/plugins/reference_analysis/js/jsenv_plugin_js_reference_analysis.js

@@ -6,24 +6,23 @@ import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
 
 import { isWebWorkerUrlInfo } from "@jsenv/core/src/kitchen/web_workers.js";
 
-export const jsenvPluginJsReferenceAnalysis = ({
-  inlineContent,
-  allowEscapeForVersioning,
-}) => {
+export const jsenvPluginJsReferenceAnalysis = ({ inlineContent }) => {
   return [
     {
       name: "jsenv:js_reference_analysis",
       appliesDuring: "*",
       transformUrlContent: {
-        js_classic: (urlInfo, context) =>
-          parseAndTransformJsReferences(urlInfo, context, {
+        js_classic: (urlInfo) =>
+          parseAndTransformJsReferences(urlInfo, {
             inlineContent,
-            allowEscapeForVersioning,
+            canUseTemplateLiterals:
+              urlInfo.context.isSupportedOnCurrentClients("template_literals"),
           }),
-        js_module: (urlInfo, context) =>
-          parseAndTransformJsReferences(urlInfo, context, {
+        js_module: (urlInfo) =>
+          parseAndTransformJsReferences(urlInfo, {
             inlineContent,
-            allowEscapeForVersioning,
+            canUseTemplateLiterals:
+              urlInfo.context.isSupportedOnCurrentClients("template_literals"),
           }),
       },
     },
@@ -32,8 +31,7 @@ export const jsenvPluginJsReferenceAnalysis = ({
 
 const parseAndTransformJsReferences = async (
   urlInfo,
-  context,
-  { inlineContent, allowEscapeForVersioning },
+  { inlineContent, canUseTemplateLiterals },
 ) => {
   const magicSource = createMagicSource(urlInfo.content);
   const parallelActions = [];
@@ -49,36 +47,32 @@ const parseAndTransformJsReferences = async (
       columnEnd: inlineReferenceInfo.columnEnd,
     });
     let { quote } = inlineReferenceInfo;
-    if (
-      quote === "`" &&
-      !context.isSupportedOnCurrentClients("template_literals")
-    ) {
+    if (quote === "`" && !canUseTemplateLiterals) {
       // if quote is "`" and template literals are not supported
       // we'll use a regular string (single or double quote)
       // when rendering the string
       quote = JS_QUOTES.pickBest(inlineReferenceInfo.content);
     }
-    const [inlineReference, inlineUrlInfo] = context.referenceUtils.foundInline(
-      {
-        type: "js_inline_content",
-        subtype: inlineReferenceInfo.type, // "new_blob_first_arg", "new_inline_content_first_arg", "json_parse_first_arg"
-        isOriginalPosition: urlInfo.content === urlInfo.originalContent,
-        specifierLine: inlineReferenceInfo.line,
-        specifierColumn: inlineReferenceInfo.column,
-        specifier: inlineUrl,
-        contentType: inlineReferenceInfo.contentType,
-        content: inlineReferenceInfo.content,
-      },
-    );
+    const inlineReference = urlInfo.dependencies.foundInline({
+      type: "js_inline_content",
+      subtype: inlineReferenceInfo.type, // "new_blob_first_arg", "new_inline_content_first_arg", "json_parse_first_arg"
+      isOriginalPosition: urlInfo.content === urlInfo.originalContent,
+      specifierLine: inlineReferenceInfo.line,
+      specifierColumn: inlineReferenceInfo.column,
+      specifier: inlineUrl,
+      contentType: inlineReferenceInfo.contentType,
+      content: inlineReferenceInfo.content,
+    });
+    const inlineUrlInfo = inlineReference.urlInfo;
     inlineUrlInfo.jsQuote = quote;
-    inlineReference.escape = (value) =>
-      JS_QUOTES.escapeSpecialChars(value.slice(1, -1), { quote });
+    inlineReference.escape = (value) => {
+      return JS_QUOTES.escapeSpecialChars(value.slice(1, -1), { quote });
+    };
 
     sequentialActions.push(async () => {
-      await context.cook(inlineUrlInfo, { reference: inlineReference });
+      await inlineUrlInfo.cook();
       const replacement = JS_QUOTES.escapeSpecialChars(inlineUrlInfo.content, {
         quote,
-        allowEscapeForVersioning,
       });
       magicSource.replace({
         start: inlineReferenceInfo.start,
@@ -94,8 +88,7 @@ const parseAndTransformJsReferences = async (
     ) {
       urlInfo.data.usesImport = true;
     }
-    const [reference] = context.referenceUtils.found({
-      node: externalReferenceInfo.node,
+    const reference = urlInfo.dependencies.found({
       type: externalReferenceInfo.type,
       subtype: externalReferenceInfo.subtype,
       expectedType: externalReferenceInfo.expectedType,
@@ -109,26 +102,24 @@ const parseAndTransformJsReferences = async (
       baseUrl: {
         "StringLiteral": externalReferenceInfo.baseUrl,
         "window.location": urlInfo.url,
-        "window.origin": context.rootDirectoryUrl,
+        "window.origin": urlInfo.context.rootDirectoryUrl,
         "import.meta.url": urlInfo.url,
         "context.meta.url": urlInfo.url,
         "document.currentScript.src": urlInfo.url,
       }[externalReferenceInfo.baseUrlType],
-      assert: externalReferenceInfo.assert,
-      assertNode: externalReferenceInfo.assertNode,
-      typePropertyNode: externalReferenceInfo.typePropertyNode,
+      importAttributes: externalReferenceInfo.importAttributes,
+      astInfo: externalReferenceInfo.astInfo,
     });
     parallelActions.push(async () => {
-      const replacement = await context.referenceUtils.readGeneratedSpecifier(
-        reference,
-      );
+      await reference.readGeneratedSpecifier();
+      const replacement = reference.generatedSpecifier;
       magicSource.replace({
         start: externalReferenceInfo.start,
         end: externalReferenceInfo.end,
         replacement,
       });
       if (reference.mutation) {
-        reference.mutation(magicSource);
+        reference.mutation(magicSource, urlInfo);
       }
     });
   };

package/src/plugins/reference_analysis/jsenv_plugin_reference_analysis.js

@@ -10,7 +10,6 @@ export const jsenvPluginReferenceAnalysis = ({
   inlineContent = true,
   inlineConvertedScript = false,
   fetchInlineUrls = true,
-  allowEscapeForVersioning = false,
 }) => {
   return [
     jsenvPluginDirectoryReferenceAnalysis(),
@@ -22,7 +21,6 @@ export const jsenvPluginReferenceAnalysis = ({
     jsenvPluginCssReferenceAnalysis(),
     jsenvPluginJsReferenceAnalysis({
       inlineContent,
-      allowEscapeForVersioning,
     }),
     ...(inlineContent ? [jsenvPluginDataUrlsAnalysis()] : []),
     ...(inlineContent && fetchInlineUrls
@@ -36,15 +34,26 @@ const jsenvPluginInlineContentFetcher = () => {
   return {
     name: "jsenv:inline_content_fetcher",
     appliesDuring: "*",
-    fetchUrlContent: (urlInfo) => {
+    fetchUrlContent: async (urlInfo) => {
       if (!urlInfo.isInline) {
         return null;
       }
+      const { firstReference } = urlInfo;
+      const { prev } = firstReference;
+      if (prev && !prev.isInline) {
+        // got inlined, cook original url
+        if (firstReference.content === undefined) {
+          const originalUrlInfo = prev.urlInfo;
+          await originalUrlInfo.cook();
+          firstReference.content = originalUrlInfo.content;
+          firstReference.contentType = originalUrlInfo.contentType;
+        }
+      }
+
       return {
-        // we want to fetch the original content otherwise we might re-cook
-        // content already cooked
-        content: urlInfo.originalContent,
-        contentType: urlInfo.contentType,
+        originalContent: urlInfo.originalContent,
+        content: firstReference.content,
+        contentType: firstReference.contentType,
       };
     },
   };

package/src/plugins/reference_analysis/webmanifest/jsenv_plugin_webmanifest_reference_analysis.js

@@ -10,18 +10,19 @@ export const jsenvPluginWebmanifestReferenceAnalysis = () => {
   };
 };
 
-const parseAndTransformWebmanifestUrls = async (urlInfo, context) => {
+const parseAndTransformWebmanifestUrls = async (urlInfo) => {
   const content = urlInfo.content;
   const manifest = JSON.parse(content);
   const actions = [];
   const { icons = [] } = manifest;
   icons.forEach((icon) => {
-    const [reference] = context.referenceUtils.found({
+    const iconReference = urlInfo.dependencies.found({
       type: "webmanifest_icon_src",
       specifier: icon.src,
     });
     actions.push(async () => {
-      icon.src = await context.referenceUtils.readGeneratedSpecifier(reference);
+      await iconReference.readGeneratedSpecifier();
+      icon.src = iconReference.generatedSpecifier;
     });
   });
 

package/src/plugins/resolution_node_esm/jsenv_plugin_node_esm_resolution.js

@@ -1,4 +1,3 @@
-import { urlTypeFromReference } from "./url_type_from_reference.js";
 import { createNodeEsmResolver } from "./node_esm_resolver.js";
 
 export const jsenvPluginNodeEsmResolution = (resolutionConfig = {}) => {
@@ -45,18 +44,18 @@ export const jsenvPluginNodeEsmResolution = (resolutionConfig = {}) => {
         resolvers.js_module = nodeEsmResolverDefault;
       }
       if (resolvers.js_classic === undefined) {
-        resolvers.js_classic = (reference, context) => {
+        resolvers.js_classic = (reference) => {
           if (reference.subtype === "self_import_scripts_arg") {
-            return nodeEsmResolverDefault(reference, context);
+            return nodeEsmResolverDefault(reference);
           }
           return null;
         };
       }
     },
-    resolveReference: (reference, context) => {
-      const urlType = urlTypeFromReference(reference, context);
+    resolveReference: (reference) => {
+      const urlType = urlTypeFromReference(reference);
       const resolver = resolvers[urlType];
-      return resolver ? resolver(reference, context) : null;
+      return resolver ? resolver(reference) : null;
     },
     // when specifier is prefixed by "file:///@ignore/"
     // we return an empty js module
@@ -72,3 +71,14 @@ export const jsenvPluginNodeEsmResolution = (resolutionConfig = {}) => {
     },
   };
 };
+
+const urlTypeFromReference = (reference) => {
+  if (reference.type === "sourcemap_comment") {
+    return "sourcemap";
+  }
+  if (reference.injected) {
+    return reference.expectedType;
+  }
+
+  return reference.ownerUrlInfo.type;
+};