@jsenv/plugin-transpilation 1.0.0 → 1.2.0

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 && jsonUrlInfo.dependents.size === 0) {
-        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 && cssUrlInfo.dependents.size === 0) {
-        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 && textUrlInfo.dependents.size === 0) {
-        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,14 +3,13 @@
  * - perform conversion from js module to js classic when url uses "?js_module_fallback"
  */
 
-import { injectQueryParams } from "@jsenv/urls";
-import { convertJsModuleToJsClassic } from "@jsenv/js-module-fallback";
+import { urlToFilename, injectQueryParams } from "@jsenv/urls";
+import {
+  convertJsModuleToJsClassic,
+  systemJsClientFileUrlDefault,
+} from "@jsenv/js-module-fallback";
 
-export const jsenvPluginJsModuleConversion = ({
-  systemJsInjection,
-  systemJsClientFileUrl,
-  generateJsClassicFilename,
-}) => {
+export const jsenvPluginJsModuleConversion = () => {
   const isReferencingJsModule = (reference) => {
     if (
       reference.type === "js_import" ||
@@ -25,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) => {
@@ -55,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;
@@ -66,39 +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 && jsModuleUrlInfo.dependents.size === 0) {
-        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)
@@ -109,17 +91,21 @@ export const jsenvPluginJsModuleConversion = ({
         // by an other file (for entry points)
         // or to be able to import when it uses import
         outputFormat = "system";
+        urlInfo.type = "js_classic";
+        urlInfo.dependencies.foundSideEffectFile({
+          sideEffectFileUrl: systemJsClientFileUrlDefault,
+          expectedType: "js_classic",
+          line: 0,
+          column: 0,
+        });
       }
-      urlInfo.data.jsClassicFormat = outputFormat;
       const { content, sourcemap } = await convertJsModuleToJsClassic({
-        rootDirectoryUrl: context.rootDirectoryUrl,
-        systemJsInjection,
-        systemJsClientFileUrl,
+        rootDirectoryUrl: urlInfo.context.rootDirectoryUrl,
         input: jsModuleUrlInfo.content,
         inputIsEntryPoint: urlInfo.isEntryPoint,
         inputSourcemap: jsModuleUrlInfo.sourcemap,
         inputUrl: jsModuleUrlInfo.url,
-        outputUrl: jsModuleUrlInfo.generatedUrl,
+        outputUrl: urlInfo.url,
         outputFormat,
       });
       return {
@@ -134,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,46 +1,11 @@
-import { urlToFilename } from "@jsenv/urls";
-import { systemJsClientFileUrlDefault } from "@jsenv/js-module-fallback";
-
 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";
 
-export const jsenvPluginJsModuleFallback = ({
-  systemJsInjection = true,
-  systemJsClientFileUrl = systemJsClientFileUrlDefault,
-}) => {
+export const jsenvPluginJsModuleFallback = () => {
   return [
-    jsenvPluginJsModuleFallbackInsideHtml({
-      systemJsInjection,
-      systemJsClientFileUrl,
-    }),
+    jsenvPluginJsModuleFallbackInsideHtml(),
     jsenvPluginJsModuleFallbackOnWorkers(),
-    jsenvPluginJsModuleConversion({
-      systemJsInjection,
-      systemJsClientFileUrl,
-      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)];
-};