@jsenv/plugin-transpilation 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/plugin-transpilation",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "TODO",
   "license": "MIT",
   "repository": {
@@ -32,7 +32,7 @@
     "@babel/plugin-transform-arrow-functions": "7.22.5",
     "@babel/plugin-transform-block-scoped-functions": "7.22.5",
     "@babel/plugin-transform-block-scoping": "7.22.5",
-    "@babel/plugin-transform-classes": "7.22.5",
+    "@babel/plugin-transform-classes": "7.22.6",
     "@babel/plugin-transform-computed-properties": "7.22.5",
     "@babel/plugin-transform-destructuring": "7.22.5",
     "@babel/plugin-transform-dotall-regex": "7.22.5",
@@ -53,8 +53,8 @@
     "@babel/plugin-transform-unicode-regex": "7.22.5",
     "babel-plugin-transform-async-to-promises": "0.8.18",
     "construct-style-sheets-polyfill": "3.1.0",
-    "@jsenv/ast": "4.1.0",
+    "@jsenv/ast": "5.0.0",
     "@jsenv/runtime-compat": "1.0.0",
-    "lightningcss": "1.21.0"
+    "lightningcss": "1.21.5"
   }
 }

package/src/as_js_module/jsenv_plugin_as_js_module.js

@@ -20,41 +20,24 @@ export const jsenvPluginAsJsModule = () => {
     redirectReference: (reference) => {
       if (reference.searchParams.has("as_js_module")) {
         reference.expectedType = "js_module";
-        const filename = urlToFilename(reference.url);
-        const [basename] = splitFileExtension(filename);
-        reference.filename = `${basename}.mjs`;
+        if (!reference.filename) {
+          const filename = urlToFilename(reference.url);
+          const [basename] = splitFileExtension(filename);
+          reference.filename = `${basename}.mjs`;
+        }
       }
     },
-    fetchUrlContent: async (urlInfo, context) => {
-      const [jsClassicReference, jsClassicUrlInfo] =
-        context.getWithoutSearchParam({
-          urlInfo,
-          context,
-          searchParam: "as_js_module",
-          // override the expectedType to "js_classic"
-          // because when there is ?as_js_module it means the underlying resource
-          // is js_classic
-          expectedType: "js_classic",
-        });
-      if (!jsClassicReference) {
-        return null;
-      }
-      await context.fetchUrlContent(jsClassicUrlInfo, {
-        reference: jsClassicReference,
+    fetchUrlContent: async (urlInfo) => {
+      const jsClassicUrlInfo = urlInfo.getWithoutSearchParam("as_js_module", {
+        // override the expectedType to "js_classic"
+        // because when there is ?as_js_module it means the underlying resource
+        // is js_classic
+        expectedType: "js_classic",
       });
-      if (context.dev) {
-        context.referenceUtils.found({
-          type: "js_import",
-          subtype: jsClassicReference.subtype,
-          specifier: jsClassicReference.url,
-          expectedType: "js_classic",
-        });
-      } else if (
-        context.build &&
-        !context.urlGraph.hasDependent(jsClassicUrlInfo)
-      ) {
-        context.urlGraph.deleteUrlInfo(jsClassicUrlInfo.url);
+      if (!jsClassicUrlInfo) {
+        return null;
       }
+      await jsClassicUrlInfo.fetchContent();
       const { content, sourcemap } = await convertJsClassicToJsModule({
         input: jsClassicUrlInfo.content,
         inputSourcemap: jsClassicUrlInfo.sourcemap,

package/src/babel/babel_plugin_structure.js

@@ -12,7 +12,7 @@ export const getBaseBabelPluginStructure = ({
   // getImportSpecifier,
 }) => {
   const isBabelPluginNeeded = (babelPluginName) => {
-    return !isSupported(babelPluginCompatMap[babelPluginName]);
+    return !isSupported(babelPluginName, babelPluginCompatMap[babelPluginName]);
   };
 
   const babelPluginStructure = {};

package/src/babel/jsenv_plugin_babel.js

@@ -9,17 +9,17 @@ import { analyzeConstructableStyleSheetUsage } from "./new_stylesheet/constructa
 import { babelPluginNewStylesheetInjector } from "./new_stylesheet/babel_plugin_new_stylesheet_injector.js";
 
 export const jsenvPluginBabel = ({ babelHelpersAsImport = true } = {}) => {
-  const transformWithBabel = async (urlInfo, context) => {
+  const transformWithBabel = async (urlInfo) => {
     const isJsModule = urlInfo.type === "js_module";
     const getImportSpecifier = (clientFileUrl) => {
-      const [reference] = context.referenceUtils.inject({
+      const jsImportReference = urlInfo.dependencies.inject({
         type: "js_import",
         expectedType: "js_module",
         specifier: clientFileUrl,
       });
-      return JSON.parse(reference.generatedSpecifier);
+      return JSON.parse(jsImportReference.generatedSpecifier);
     };
-    const isSupported = context.isSupportedOnCurrentClients;
+    const isSupported = urlInfo.context.isSupportedOnCurrentClients;
     const babelPluginStructure = getBaseBabelPluginStructure({
       url: urlInfo.originalUrl,
       isSupported,
@@ -36,7 +36,7 @@ export const jsenvPluginBabel = ({ babelHelpersAsImport = true } = {}) => {
             { babelHelpersAsImport, getImportSpecifier },
           ];
         } else {
-          context.referenceUtils.foundSideEffectFile({
+          urlInfo.dependencies.foundSideEffectFile({
             sideEffectFileUrl: regeneratorRuntimeClientFileUrl,
             expectedType: "js_classic",
             specifierLine: regeneratorRuntimeUsage.line,
@@ -55,7 +55,7 @@ export const jsenvPluginBabel = ({ babelHelpersAsImport = true } = {}) => {
             { babelHelpersAsImport, getImportSpecifier },
           ];
         } else {
-          context.referenceUtils.foundSideEffectFile({
+          urlInfo.dependencies.foundSideEffectFile({
             sideEffectFileUrl: regeneratorRuntimeClientFileUrl,
             expectedType: "js_classic",
             specifierLine: constructableStyleSheetUsage.line,
@@ -82,7 +82,7 @@ export const jsenvPluginBabel = ({ babelHelpersAsImport = true } = {}) => {
       babelPlugins,
       options: {
         generatorOpts: {
-          retainLines: context.dev,
+          retainLines: urlInfo.context.dev,
         },
       },
       input: urlInfo.content,

package/src/css/jsenv_plugin_css_transpilation.js

@@ -5,11 +5,11 @@ export const jsenvPluginCssTranspilation = () => {
     name: "jsenv:css_transpilation",
     appliesDuring: "*",
     transformUrlContent: {
-      css: async (urlInfo, context) => {
+      css: (urlInfo) => {
         return applyCssTranspilation({
           input: urlInfo.content,
           inputUrl: urlInfo.originalUrl,
-          runtimeCompat: context.runtimeCompat,
+          runtimeCompat: urlInfo.context.runtimeCompat,
         });
       },
     },

package/src/import_assertions/jsenv_plugin_import_assertions.js

@@ -19,39 +19,45 @@ export const jsenvPluginImportAssertions = ({
   text = "auto",
 }) => {
   const transpilations = { json, css, text };
-  const shouldTranspileImportAssertion = (context, type) => {
+  const shouldTranspileImportAssertion = (reference, type) => {
     const transpilation = transpilations[type];
     if (transpilation === true) {
       return true;
     }
     if (transpilation === "auto") {
-      return !context.isSupportedOnCurrentClients(`import_type_${type}`);
+      return !reference.ownerUrlInfo.context.isSupportedOnCurrentClients(
+        `import_type_${type}`,
+      );
     }
     return false;
   };
   const markAsJsModuleProxy = (reference) => {
     reference.expectedType = "js_module";
-    reference.filename = `${urlToFilename(reference.url)}.js`;
+    if (!reference.filename) {
+      reference.filename = `${urlToFilename(reference.url)}.js`;
+    }
   };
   const turnIntoJsModuleProxy = (reference, type) => {
     reference.mutation = (magicSource) => {
-      const { assertNode } = reference;
+      const { importTypeAttributeNode } = reference.astInfo;
       if (reference.subtype === "import_dynamic") {
-        const assertPropertyNode = assertNode.properties.find(
-          (prop) => prop.key.name === "assert",
-        );
-        const assertPropertyValue = assertPropertyNode.value;
-        const typePropertyNode = assertPropertyValue.properties.find(
-          (prop) => prop.key.name === "type",
-        );
         magicSource.remove({
-          start: typePropertyNode.start,
-          end: typePropertyNode.end,
+          start: importTypeAttributeNode.start,
+          end: importTypeAttributeNode.end,
         });
       } else {
+        const content = reference.ownerUrlInfo.content;
+        const assertKeyboardStart = content.indexOf(
+          "assert",
+          importTypeAttributeNode.start - " assert { ".length,
+        );
+        const assertKeywordEnd = content.indexOf(
+          "}",
+          importTypeAttributeNode.end,
+        );
         magicSource.remove({
-          start: assertNode.start,
-          end: assertNode.end,
+          start: assertKeyboardStart,
+          end: assertKeywordEnd + 1,
         });
       }
     };
@@ -77,8 +83,8 @@ export const jsenvPluginImportAssertions = ({
         transpilations.text = true;
       }
     },
-    redirectReference: (reference, context) => {
-      if (!reference.assert) {
+    redirectReference: (reference) => {
+      if (!reference.importAttributes) {
         return null;
       }
       const { searchParams } = reference;
@@ -90,8 +96,8 @@ export const jsenvPluginImportAssertions = ({
         markAsJsModuleProxy(reference);
         return null;
       }
-      const type = reference.assert.type;
-      if (shouldTranspileImportAssertion(context, type)) {
+      const type = reference.importAttributes.type;
+      if (shouldTranspileImportAssertion(reference, type)) {
         return turnIntoJsModuleProxy(reference, type);
       }
       return null;
@@ -104,29 +110,14 @@ const jsenvPluginAsModules = () => {
   const asJsonModule = {
     name: `jsenv:as_json_module`,
     appliesDuring: "*",
-    fetchUrlContent: async (urlInfo, context) => {
-      const [jsonReference, jsonUrlInfo] = context.getWithoutSearchParam({
-        urlInfo,
-        context,
-        searchParam: "as_json_module",
+    fetchUrlContent: async (urlInfo) => {
+      const jsonUrlInfo = urlInfo.getWithoutSearchParam("as_json_module", {
         expectedType: "json",
       });
-      if (!jsonReference) {
+      if (!jsonUrlInfo) {
         return null;
       }
-      await context.fetchUrlContent(jsonUrlInfo, {
-        reference: jsonReference,
-      });
-      if (context.dev) {
-        context.referenceUtils.found({
-          type: "js_import",
-          subtype: jsonReference.subtype,
-          specifier: jsonReference.url,
-          expectedType: "js_module",
-        });
-      } else if (context.build && !context.urlGraph.hasDependent(jsonUrlInfo)) {
-        context.urlGraph.deleteUrlInfo(jsonUrlInfo.url);
-      }
+      await jsonUrlInfo.fetchContent();
       const jsonText = JSON.stringify(jsonUrlInfo.content.trim());
       return {
         // here we could `export default ${jsonText}`:
@@ -145,29 +136,14 @@ const jsenvPluginAsModules = () => {
   const asCssModule = {
     name: `jsenv:as_css_module`,
     appliesDuring: "*",
-    fetchUrlContent: async (urlInfo, context) => {
-      const [cssReference, cssUrlInfo] = context.getWithoutSearchParam({
-        urlInfo,
-        context,
-        searchParam: "as_css_module",
+    fetchUrlContent: async (urlInfo) => {
+      const cssUrlInfo = urlInfo.getWithoutSearchParam("as_css_module", {
         expectedType: "css",
       });
-      if (!cssReference) {
+      if (!cssUrlInfo) {
         return null;
       }
-      await context.fetchUrlContent(cssUrlInfo, {
-        reference: cssReference,
-      });
-      if (context.dev) {
-        context.referenceUtils.found({
-          type: "js_import",
-          subtype: cssReference.subtype,
-          specifier: cssReference.url,
-          expectedType: "js_module",
-        });
-      } else if (context.build && !context.urlGraph.hasDependent(cssUrlInfo)) {
-        context.urlGraph.deleteUrlInfo(cssUrlInfo.url);
-      }
+      await cssUrlInfo.fetchContent();
       const cssText = JS_QUOTES.escapeSpecialChars(cssUrlInfo.content, {
         // If template string is choosen and runtime do not support template literals
         // it's ok because "jsenv:new_inline_content" plugin executes after this one
@@ -176,7 +152,7 @@ const jsenvPluginAsModules = () => {
       });
       return {
         content: `import ${JSON.stringify(
-          context.referenceUtils.inlineContentClientFileUrl,
+          urlInfo.context.inlineContentClientFileUrl,
         )};
 
 const inlineContent = new __InlineContent__(${cssText}, { type: "text/css" });
@@ -195,29 +171,14 @@ export default stylesheet;`,
   const asTextModule = {
     name: `jsenv:as_text_module`,
     appliesDuring: "*",
-    fetchUrlContent: async (urlInfo, context) => {
-      const [textReference, textUrlInfo] = context.getWithoutSearchParam({
-        urlInfo,
-        context,
-        searchParam: "as_text_module",
+    fetchUrlContent: async (urlInfo) => {
+      const textUrlInfo = urlInfo.getWithoutSearchParam("as_text_module", {
         expectedType: "text",
       });
-      if (!textReference) {
+      if (!textUrlInfo) {
         return null;
       }
-      await context.fetchUrlContent(textUrlInfo, {
-        reference: textReference,
-      });
-      if (context.dev) {
-        context.referenceUtils.found({
-          type: "js_import",
-          subtype: textReference.subtype,
-          specifier: textReference.url,
-          expectedType: "js_module",
-        });
-      } else if (context.build && !context.urlGraph.hasDependent(textUrlInfo)) {
-        context.urlGraph.deleteUrlInfo(textUrlInfo.url);
-      }
+      await textUrlInfo.fetchContent();
       const textPlain = JS_QUOTES.escapeSpecialChars(urlInfo.content, {
         // If template string is choosen and runtime do not support template literals
         // it's ok because "jsenv:new_inline_content" plugin executes after this one
@@ -226,7 +187,7 @@ export default stylesheet;`,
       });
       return {
         content: `import ${JSON.stringify(
-          context.referenceUtils.inlineContentClientFileUrl,
+          urlInfo.context.inlineContentClientFileUrl,
         )};
 
 const inlineContent = new InlineContent(${textPlain}, { type: "text/plain" });

package/src/import_meta_resolve/jsenv_plugin_import_meta_resolve.js

@@ -15,32 +15,36 @@ export const jsenvPluginImportMetaResolve = () => {
       return true;
     },
     transformUrlContent: {
-      js_module: async (urlInfo, context) => {
+      js_module: async (urlInfo) => {
         const magicSource = createMagicSource(urlInfo.content);
-        context.referenceUtils._references.forEach((ref) => {
-          if (ref.subtype === "import_meta_resolve") {
-            const originalSpecifierLength = Buffer.byteLength(ref.specifier);
+        for (const referenceToOther of urlInfo.referenceToOthersSet) {
+          if (referenceToOther.subtype === "import_meta_resolve") {
+            const originalSpecifierLength = Buffer.byteLength(
+              referenceToOther.specifier,
+            );
             const specifierLength = Buffer.byteLength(
-              ref.generatedSpecifier.slice(1, -1), // remove `"` around
+              referenceToOther.generatedSpecifier.slice(1, -1), // remove `"` around
             );
             const specifierLengthDiff =
               specifierLength - originalSpecifierLength;
-            const end = ref.node.end + specifierLengthDiff;
+            const { node } = referenceToOther.astInfo;
+            const end = node.end + specifierLengthDiff;
             magicSource.replace({
-              start: ref.node.start,
+              start: node.start,
               end,
-              replacement: `new URL(${ref.generatedSpecifier}, import.meta.url).href`,
+              replacement: `new URL(${referenceToOther.generatedSpecifier}, import.meta.url).href`,
             });
             const currentLengthBeforeSpecifier = "import.meta.resolve(".length;
             const newLengthBeforeSpecifier = "new URL(".length;
             const lengthDiff =
               currentLengthBeforeSpecifier - newLengthBeforeSpecifier;
-            ref.specifierColumn -= lengthDiff;
-            ref.specifierStart -= lengthDiff;
-            ref.specifierEnd =
-              ref.specifierStart + Buffer.byteLength(ref.generatedSpecifier);
+            referenceToOther.specifierColumn -= lengthDiff;
+            referenceToOther.specifierStart -= lengthDiff;
+            referenceToOther.specifierEnd =
+              referenceToOther.specifierStart +
+              Buffer.byteLength(referenceToOther.generatedSpecifier);
           }
-        });
+        }
         return magicSource.toContentAndSourcemap();
       },
     },

package/src/js_module_fallback/jsenv_plugin_js_module_conversion.js

@@ -3,15 +3,13 @@
  * - perform conversion from js module to js classic when url uses "?js_module_fallback"
  */
 
-import { injectQueryParams } from "@jsenv/urls";
+import { urlToFilename, injectQueryParams } from "@jsenv/urls";
 import {
   convertJsModuleToJsClassic,
   systemJsClientFileUrlDefault,
 } from "@jsenv/js-module-fallback";
 
-export const jsenvPluginJsModuleConversion = ({
-  generateJsClassicFilename,
-}) => {
+export const jsenvPluginJsModuleConversion = () => {
   const isReferencingJsModule = (reference) => {
     if (
       reference.type === "js_import" ||
@@ -26,23 +24,20 @@ export const jsenvPluginJsModuleConversion = ({
     return false;
   };
 
-  const shouldPropagateJsModuleConversion = (reference, context) => {
-    if (isReferencingJsModule(reference, context)) {
-      const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl);
-      if (!parentUrlInfo) {
-        return false;
-      }
-      const parentGotAsJsClassic = new URL(parentUrlInfo.url).searchParams.has(
-        "js_module_fallback",
-      );
-      return parentGotAsJsClassic;
+  const shouldPropagateJsModuleConversion = (reference) => {
+    if (isReferencingJsModule(reference)) {
+      const insideJsClassic =
+        reference.ownerUrlInfo.searchParams.has("js_module_fallback");
+      return insideJsClassic;
     }
     return false;
   };
 
   const markAsJsClassicProxy = (reference) => {
     reference.expectedType = "js_classic";
-    reference.filename = generateJsClassicFilename(reference.url);
+    if (!reference.filename) {
+      reference.filename = generateJsClassicFilename(reference.url);
+    }
   };
 
   const turnIntoJsClassicProxy = (reference) => {
@@ -56,7 +51,7 @@ export const jsenvPluginJsModuleConversion = ({
   return {
     name: "jsenv:js_module_conversion",
     appliesDuring: "*",
-    redirectReference: (reference, context) => {
+    redirectReference: (reference) => {
       if (reference.searchParams.has("js_module_fallback")) {
         markAsJsClassicProxy(reference);
         return null;
@@ -67,42 +62,25 @@ export const jsenvPluginJsModuleConversion = ({
       //   (because it's the transpiled equivalent of static and dynamic imports)
       // And not other references otherwise we could try to transform inline resources
       // or specifiers inside new URL()...
-      if (shouldPropagateJsModuleConversion(reference, context)) {
-        return turnIntoJsClassicProxy(reference, context);
+      if (shouldPropagateJsModuleConversion(reference)) {
+        return turnIntoJsClassicProxy(reference);
       }
       return null;
     },
-    fetchUrlContent: async (urlInfo, context) => {
-      const [jsModuleReference, jsModuleUrlInfo] =
-        context.getWithoutSearchParam({
-          urlInfo,
-          context,
-          searchParam: "js_module_fallback",
+    fetchUrlContent: async (urlInfo) => {
+      const jsModuleUrlInfo = urlInfo.getWithoutSearchParam(
+        "js_module_fallback",
+        {
           // override the expectedType to "js_module"
           // because when there is ?js_module_fallback it means the underlying resource
           // is a js_module
           expectedType: "js_module",
-        });
-      if (!jsModuleReference) {
+        },
+      );
+      if (!jsModuleUrlInfo) {
         return null;
       }
-      await context.fetchUrlContent(jsModuleUrlInfo, {
-        reference: jsModuleReference,
-      });
-      if (context.dev) {
-        context.referenceUtils.found({
-          type: "js_import",
-          subtype: jsModuleReference.subtype,
-          specifier: jsModuleReference.url,
-          expectedType: "js_module",
-        });
-      } else if (
-        context.build &&
-        !context.urlGraph.hasDependent(jsModuleUrlInfo)
-      ) {
-        context.urlGraph.deleteUrlInfo(jsModuleUrlInfo.url);
-      }
-
+      await jsModuleUrlInfo.fetchContent();
       let outputFormat;
       if (urlInfo.isEntryPoint && !jsModuleUrlInfo.data.usesImport) {
         // if it's an entry point without dependency (it does not use import)
@@ -114,7 +92,7 @@ export const jsenvPluginJsModuleConversion = ({
         // or to be able to import when it uses import
         outputFormat = "system";
         urlInfo.type = "js_classic";
-        context.referenceUtils.foundSideEffectFile({
+        urlInfo.dependencies.foundSideEffectFile({
           sideEffectFileUrl: systemJsClientFileUrlDefault,
           expectedType: "js_classic",
           line: 0,
@@ -122,12 +100,12 @@ export const jsenvPluginJsModuleConversion = ({
         });
       }
       const { content, sourcemap } = await convertJsModuleToJsClassic({
-        rootDirectoryUrl: context.rootDirectoryUrl,
+        rootDirectoryUrl: urlInfo.context.rootDirectoryUrl,
         input: jsModuleUrlInfo.content,
         inputIsEntryPoint: urlInfo.isEntryPoint,
         inputSourcemap: jsModuleUrlInfo.sourcemap,
         inputUrl: jsModuleUrlInfo.url,
-        outputUrl: jsModuleUrlInfo.generatedUrl,
+        outputUrl: urlInfo.url,
         outputFormat,
       });
       return {
@@ -142,3 +120,25 @@ export const jsenvPluginJsModuleConversion = ({
     },
   };
 };
+
+const generateJsClassicFilename = (url) => {
+  const filename = urlToFilename(url);
+  let [basename, extension] = splitFileExtension(filename);
+  const { searchParams } = new URL(url);
+  if (
+    searchParams.has("as_json_module") ||
+    searchParams.has("as_css_module") ||
+    searchParams.has("as_text_module")
+  ) {
+    extension = ".js";
+  }
+  return `${basename}.nomodule${extension}`;
+};
+
+const splitFileExtension = (filename) => {
+  const dotLastIndex = filename.lastIndexOf(".");
+  if (dotLastIndex === -1) {
+    return [filename, ""];
+  }
+  return [filename.slice(0, dotLastIndex), filename.slice(dotLastIndex)];
+};

package/src/js_module_fallback/jsenv_plugin_js_module_fallback.js

@@ -1,5 +1,3 @@
-import { urlToFilename } from "@jsenv/urls";
-
 import { jsenvPluginJsModuleConversion } from "./jsenv_plugin_js_module_conversion.js";
 import { jsenvPluginJsModuleFallbackInsideHtml } from "./jsenv_plugin_js_module_fallback_inside_html.js";
 import { jsenvPluginJsModuleFallbackOnWorkers } from "./jsenv_plugin_js_module_fallback_on_workers.js";
@@ -8,30 +6,6 @@ export const jsenvPluginJsModuleFallback = () => {
   return [
     jsenvPluginJsModuleFallbackInsideHtml(),
     jsenvPluginJsModuleFallbackOnWorkers(),
-    jsenvPluginJsModuleConversion({
-      generateJsClassicFilename,
-    }),
+    jsenvPluginJsModuleConversion(),
   ];
 };
-
-const generateJsClassicFilename = (url) => {
-  const filename = urlToFilename(url);
-  let [basename, extension] = splitFileExtension(filename);
-  const { searchParams } = new URL(url);
-  if (
-    searchParams.has("as_json_module") ||
-    searchParams.has("as_css_module") ||
-    searchParams.has("as_text_module")
-  ) {
-    extension = ".js";
-  }
-  return `${basename}.nomodule${extension}`;
-};
-
-const splitFileExtension = (filename) => {
-  const dotLastIndex = filename.lastIndexOf(".");
-  if (dotLastIndex === -1) {
-    return [filename, ""];
-  }
-  return [filename.slice(0, dotLastIndex), filename.slice(dotLastIndex)];
-};

package/src/js_module_fallback/jsenv_plugin_js_module_fallback_inside_html.js

@@ -17,6 +17,14 @@ import {
 
 export const jsenvPluginJsModuleFallbackInsideHtml = () => {
   const turnIntoJsClassicProxy = (reference) => {
+    // not needed for now: redirections are disabled
+    // for getWithoutSearchParam
+    // if (
+    //   reference.prev &&
+    //   reference.prev.searchParams.has("js_module_fallback")
+    // ) {
+    //   return null;
+    // }
     return injectQueryParams(reference.url, { js_module_fallback: "" });
   };
 
@@ -24,15 +32,15 @@ export const jsenvPluginJsModuleFallbackInsideHtml = () => {
     name: "jsenv:js_module_fallback_inside_html",
     appliesDuring: "*",
     redirectReference: {
-      link_href: (reference, context) => {
+      link_href: (reference) => {
         if (
-          context.systemJsTranspilation &&
+          reference.ownerUrlInfo.context.systemJsTranspilation &&
           reference.subtype === "modulepreload"
         ) {
           return turnIntoJsClassicProxy(reference);
         }
         if (
-          context.systemJsTranspilation &&
+          reference.ownerUrlInfo.context.systemJsTranspilation &&
           reference.subtype === "preload" &&
           reference.expectedType === "js_module"
         ) {
@@ -40,18 +48,18 @@ export const jsenvPluginJsModuleFallbackInsideHtml = () => {
         }
         return null;
       },
-      script: (reference, context) => {
+      script: (reference) => {
         if (
-          context.systemJsTranspilation &&
+          reference.ownerUrlInfo.context.systemJsTranspilation &&
           reference.expectedType === "js_module"
         ) {
           return turnIntoJsClassicProxy(reference);
         }
         return null;
       },
-      js_url: (reference, context) => {
+      js_url: (reference) => {
         if (
-          context.systemJsTranspilation &&
+          reference.ownerUrlInfo.context.systemJsTranspilation &&
           reference.expectedType === "js_module"
         ) {
           return turnIntoJsClassicProxy(reference);
@@ -60,7 +68,7 @@ export const jsenvPluginJsModuleFallbackInsideHtml = () => {
       },
     },
     finalizeUrlContent: {
-      html: async (urlInfo, context) => {
+      html: async (urlInfo) => {
         const htmlAst = parseHtmlString(urlInfo.content);
         const mutations = [];
         visitHtmlNodes(htmlAst, {
@@ -73,13 +81,18 @@ export const jsenvPluginJsModuleFallbackInsideHtml = () => {
             if (!href) {
               return;
             }
-            const reference = context.referenceUtils.find(
-              (ref) =>
-                ref.generatedSpecifier === href &&
-                ref.type === "link_href" &&
-                ref.subtype === rel,
-            );
-            if (!wasOrWillBeConvertedToJsClassic(reference)) {
+            let linkHintReference = null;
+            for (const referenceToOther of urlInfo.referenceToOthersSet) {
+              if (
+                referenceToOther.generatedSpecifier === href &&
+                referenceToOther.type === "link_href" &&
+                referenceToOther.subtype === rel
+              ) {
+                linkHintReference = referenceToOther;
+                break;
+              }
+            }
+            if (!wasOrWillBeConvertedToJsClassic(linkHintReference)) {
               return;
             }
             if (rel === "modulepreload") {
@@ -104,21 +117,26 @@ export const jsenvPluginJsModuleFallbackInsideHtml = () => {
             }
             const src = getHtmlNodeAttribute(node, "src");
             if (src) {
-              const reference = context.referenceUtils.find(
-                (ref) =>
-                  ref.generatedSpecifier === src &&
-                  ref.type === "script" &&
-                  ref.subtype === "js_module",
-              );
-              if (!reference) {
+              let scriptTypeModuleReference = null;
+              for (const referenceToOther of urlInfo.referenceToOthersSet) {
+                if (
+                  referenceToOther.generatedSpecifier === src &&
+                  referenceToOther.type === "script" &&
+                  referenceToOther.subtype === "js_module"
+                ) {
+                  scriptTypeModuleReference = referenceToOther;
+                  break;
+                }
+              }
+              if (!scriptTypeModuleReference) {
                 return;
               }
-              if (reference.expectedType === "js_classic") {
+              if (scriptTypeModuleReference.expectedType === "js_classic") {
                 mutations.push(() => {
                   setHtmlNodeAttributes(node, { type: undefined });
                 });
               }
-            } else if (context.systemJsTranspilation) {
+            } else if (urlInfo.context.systemJsTranspilation) {
               mutations.push(() => {
                 setHtmlNodeAttributes(node, { type: undefined });
               });
@@ -127,7 +145,7 @@ export const jsenvPluginJsModuleFallbackInsideHtml = () => {
         });
         await Promise.all(mutations.map((mutation) => mutation()));
         return stringifyHtmlAst(htmlAst, {
-          cleanupPositionAttributes: context.dev,
+          cleanupPositionAttributes: urlInfo.context.dev,
         });
       },
     },

package/src/js_module_fallback/jsenv_plugin_js_module_fallback_on_workers.js

@@ -16,9 +16,10 @@ import { injectQueryParams } from "@jsenv/urls";
 export const jsenvPluginJsModuleFallbackOnWorkers = () => {
   const turnIntoJsClassicProxy = (reference) => {
     reference.mutation = (magicSource) => {
+      const { typePropertyNode } = reference.astInfo;
       magicSource.replace({
-        start: reference.typePropertyNode.value.start,
-        end: reference.typePropertyNode.value.end,
+        start: typePropertyNode.value.start,
+        end: typePropertyNode.value.end,
         replacement: JSON.stringify("classic"),
       });
     };
@@ -29,19 +30,25 @@ export const jsenvPluginJsModuleFallbackOnWorkers = () => {
     name: "jsenv:js_module_fallback_on_workers",
     appliesDuring: "*",
     redirectReference: {
-      js_url: (reference, context) => {
+      js_url: (reference) => {
         if (reference.expectedType !== "js_module") {
           return null;
         }
         if (reference.expectedSubtype === "worker") {
-          if (context.isSupportedOnCurrentClients("worker_type_module")) {
+          if (
+            reference.ownerUrlInfo.context.isSupportedOnCurrentClients(
+              "worker_type_module",
+            )
+          ) {
             return null;
           }
           return turnIntoJsClassicProxy(reference);
         }
         if (reference.expectedSubtype === "service_worker") {
           if (
-            context.isSupportedOnCurrentClients("service_worker_type_module")
+            reference.ownerUrlInfo.context.isSupportedOnCurrentClients(
+              "service_worker_type_module",
+            )
           ) {
             return null;
           }
@@ -49,7 +56,9 @@ export const jsenvPluginJsModuleFallbackOnWorkers = () => {
         }
         if (reference.expectedSubtype === "shared_worker") {
           if (
-            context.isSupportedOnCurrentClients("shared_worker_type_module")
+            reference.ownerUrlInfo.context.isSupportedOnCurrentClients(
+              "shared_worker_type_module",
+            )
           ) {
             return null;
           }