@jsenv/core 35.0.2 → 35.0.4

package/src/plugins/transpilation/js_module_fallback/jsenv_plugin_js_module_fallback_inside_html.js

@@ -5,7 +5,7 @@
  * - <link rel="modulepreload"> are converted to <link rel="preload">
  */
 
-import { readFileSync } from "node:fs"
+import { readFileSync } from "node:fs";
 import {
   parseHtmlString,
   visitHtmlNodes,
@@ -15,17 +15,17 @@ import {
   analyzeScriptNode,
   injectHtmlNodeAsEarlyAsPossible,
   createHtmlNode,
-} from "@jsenv/ast"
-import { injectQueryParams, urlToRelativeUrl } from "@jsenv/urls"
-import { SOURCEMAP } from "@jsenv/sourcemap"
+} from "@jsenv/ast";
+import { injectQueryParams, urlToRelativeUrl } from "@jsenv/urls";
+import { SOURCEMAP } from "@jsenv/sourcemap";
 
 export const jsenvPluginJsModuleFallbackInsideHtml = ({
   systemJsInjection,
   systemJsClientFileUrl,
 }) => {
   const turnIntoJsClassicProxy = (reference) => {
-    return injectQueryParams(reference.url, { js_module_fallback: "" })
-  }
+    return injectQueryParams(reference.url, { js_module_fallback: "" });
+  };
 
   return {
     name: "jsenv:js_module_fallback_inside_html",
@@ -36,58 +36,58 @@ export const jsenvPluginJsModuleFallbackInsideHtml = ({
           context.systemJsTranspilation &&
           reference.subtype === "modulepreload"
         ) {
-          return turnIntoJsClassicProxy(reference)
+          return turnIntoJsClassicProxy(reference);
         }
         if (
           context.systemJsTranspilation &&
           reference.subtype === "preload" &&
           reference.expectedType === "js_module"
         ) {
-          return turnIntoJsClassicProxy(reference)
+          return turnIntoJsClassicProxy(reference);
         }
-        return null
+        return null;
       },
       script: (reference, context) => {
         if (
           context.systemJsTranspilation &&
           reference.expectedType === "js_module"
         ) {
-          return turnIntoJsClassicProxy(reference)
+          return turnIntoJsClassicProxy(reference);
         }
-        return null
+        return null;
       },
       js_url: (reference, context) => {
         if (
           context.systemJsTranspilation &&
           reference.expectedType === "js_module"
         ) {
-          return turnIntoJsClassicProxy(reference)
+          return turnIntoJsClassicProxy(reference);
         }
-        return null
+        return null;
       },
     },
     finalizeUrlContent: {
       html: async (urlInfo, context) => {
-        const htmlAst = parseHtmlString(urlInfo.content)
-        const mutations = []
+        const htmlAst = parseHtmlString(urlInfo.content);
+        const mutations = [];
         visitHtmlNodes(htmlAst, {
           link: (node) => {
-            const rel = getHtmlNodeAttribute(node, "rel")
+            const rel = getHtmlNodeAttribute(node, "rel");
             if (rel !== "modulepreload" && rel !== "preload") {
-              return
+              return;
             }
-            const href = getHtmlNodeAttribute(node, "href")
+            const href = getHtmlNodeAttribute(node, "href");
             if (!href) {
-              return
+              return;
             }
             const reference = context.referenceUtils.find(
               (ref) =>
                 ref.generatedSpecifier === href &&
                 ref.type === "link_href" &&
                 ref.subtype === rel,
-            )
+            );
             if (!isOrWasExpectingJsModule(reference)) {
-              return
+              return;
             }
             if (
               rel === "modulepreload" &&
@@ -98,73 +98,73 @@ export const jsenvPluginJsModuleFallbackInsideHtml = ({
                   rel: "preload",
                   as: "script",
                   crossorigin: undefined,
-                })
-              })
+                });
+              });
             }
             if (rel === "preload" && reference.expectedType === "js_classic") {
               mutations.push(() => {
-                setHtmlNodeAttributes(node, { crossorigin: undefined })
-              })
+                setHtmlNodeAttributes(node, { crossorigin: undefined });
+              });
             }
           },
           script: (node) => {
-            const { type } = analyzeScriptNode(node)
+            const { type } = analyzeScriptNode(node);
             if (type !== "js_module") {
-              return
+              return;
             }
-            const src = getHtmlNodeAttribute(node, "src")
+            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) {
-                return
+                return;
               }
               if (reference.expectedType === "js_classic") {
                 mutations.push(() => {
-                  setHtmlNodeAttributes(node, { type: undefined })
-                })
+                  setHtmlNodeAttributes(node, { type: undefined });
+                });
               }
             } else if (context.systemJsTranspilation) {
               mutations.push(() => {
-                setHtmlNodeAttributes(node, { type: undefined })
-              })
+                setHtmlNodeAttributes(node, { type: undefined });
+              });
             }
           },
-        })
+        });
 
         if (systemJsInjection) {
-          let needsSystemJs = false
+          let needsSystemJs = false;
           for (const reference of urlInfo.references) {
             if (reference.isResourceHint) {
               // we don't cook resource hints
               // because they might refer to resource that will be modified during build
               // It also means something else HAVE to reference that url in order to cook it
               // so that the preload is deleted by "resync_resource_hints.js" otherwise
-              continue
+              continue;
             }
             if (isOrWasExpectingJsModule(reference)) {
               const dependencyUrlInfo = context.urlGraph.getUrlInfo(
                 reference.url,
-              )
+              );
               try {
-                await context.cook(dependencyUrlInfo, { reference })
+                await context.cook(dependencyUrlInfo, { reference });
                 if (dependencyUrlInfo.data.jsClassicFormat === "system") {
-                  needsSystemJs = true
-                  break
+                  needsSystemJs = true;
+                  break;
                 }
               } catch (e) {
                 if (context.dev && e.code !== "PARSE_ERROR") {
-                  needsSystemJs = true
+                  needsSystemJs = true;
                   // ignore cooking error, the browser will trigger it again on fetch
                   // + disable cache for this html file because when browser will reload
                   // the error might be gone and we might need to inject systemjs
-                  urlInfo.headers["cache-control"] = "no-store"
+                  urlInfo.headers["cache-control"] = "no-store";
                 } else {
-                  throw e
+                  throw e;
                 }
               }
             }
@@ -174,21 +174,21 @@ export const jsenvPluginJsModuleFallbackInsideHtml = ({
               let systemJsFileContent = readFileSync(
                 new URL(systemJsClientFileUrl),
                 { encoding: "utf8" },
-              )
+              );
               const sourcemapFound = SOURCEMAP.readComment({
                 contentType: "text/javascript",
                 content: systemJsFileContent,
-              })
+              });
               if (sourcemapFound) {
                 const sourcemapFileUrl = new URL(
                   sourcemapFound.specifier,
                   systemJsClientFileUrl,
-                )
+                );
                 systemJsFileContent = SOURCEMAP.writeComment({
                   contentType: "text/javascript",
                   content: systemJsFileContent,
                   specifier: urlToRelativeUrl(sourcemapFileUrl, urlInfo.url),
-                })
+                });
               }
               const [systemJsReference, systemJsUrlInfo] =
                 context.referenceUtils.inject({
@@ -198,10 +198,10 @@ export const jsenvPluginJsModuleFallbackInsideHtml = ({
                   contentType: "text/javascript",
                   content: systemJsFileContent,
                   specifier: "s.js",
-                })
+                });
               await context.cook(systemJsUrlInfo, {
                 reference: systemJsReference,
-              })
+              });
               injectHtmlNodeAsEarlyAsPossible(
                 htmlAst,
                 createHtmlNode({
@@ -209,34 +209,34 @@ export const jsenvPluginJsModuleFallbackInsideHtml = ({
                   textContent: systemJsUrlInfo.content,
                 }),
                 "jsenv:js_module_fallback",
-              )
-            })
+              );
+            });
           }
         }
         if (mutations.length === 0) {
-          return null
+          return null;
         }
-        await Promise.all(mutations.map((mutation) => mutation()))
-        return stringifyHtmlAst(htmlAst)
+        await Promise.all(mutations.map((mutation) => mutation()));
+        return stringifyHtmlAst(htmlAst);
       },
     },
-  }
-}
+  };
+};
 
 const isOrWasExpectingJsModule = (reference) => {
   if (isExpectingJsModule(reference)) {
-    return true
+    return true;
   }
   if (reference.original && isExpectingJsModule(reference.original)) {
-    return true
+    return true;
   }
-  return false
-}
+  return false;
+};
 
 const isExpectingJsModule = (reference) => {
   return (
     reference.expectedType === "js_module" ||
     reference.searchParams.has("js_module_fallback") ||
     reference.searchParams.has("as_js_classic")
-  )
-}
+  );
+};

package/src/plugins/transpilation/js_module_fallback/jsenv_plugin_js_module_fallback_on_workers.js

@@ -11,7 +11,7 @@
  *   new SharedWorker("shared_worker.js?js_module_fallback", { type: "classic" })
  */
 
-import { injectQueryParams } from "@jsenv/urls"
+import { injectQueryParams } from "@jsenv/urls";
 
 export const jsenvPluginJsModuleFallbackOnWorkers = () => {
   const turnIntoJsClassicProxy = (reference) => {
@@ -20,10 +20,10 @@ export const jsenvPluginJsModuleFallbackOnWorkers = () => {
         start: reference.typePropertyNode.value.start,
         end: reference.typePropertyNode.value.end,
         replacement: JSON.stringify("classic"),
-      })
-    }
-    return injectQueryParams(reference.url, { js_module_fallback: "" })
-  }
+      });
+    };
+    return injectQueryParams(reference.url, { js_module_fallback: "" });
+  };
 
   return {
     name: "jsenv:js_module_fallback_on_workers",
@@ -31,32 +31,32 @@ export const jsenvPluginJsModuleFallbackOnWorkers = () => {
     redirectUrl: {
       js_url: (reference, context) => {
         if (reference.expectedType !== "js_module") {
-          return null
+          return null;
         }
         if (reference.expectedSubtype === "worker") {
           if (context.isSupportedOnCurrentClients("worker_type_module")) {
-            return null
+            return null;
           }
-          return turnIntoJsClassicProxy(reference)
+          return turnIntoJsClassicProxy(reference);
         }
         if (reference.expectedSubtype === "service_worker") {
           if (
             context.isSupportedOnCurrentClients("service_worker_type_module")
           ) {
-            return null
+            return null;
           }
-          return turnIntoJsClassicProxy(reference)
+          return turnIntoJsClassicProxy(reference);
         }
         if (reference.expectedSubtype === "shared_worker") {
           if (
             context.isSupportedOnCurrentClients("shared_worker_type_module")
           ) {
-            return null
+            return null;
           }
-          return turnIntoJsClassicProxy(reference)
+          return turnIntoJsClassicProxy(reference);
         }
-        return null
+        return null;
       },
     },
-  }
-}
+  };
+};

package/src/plugins/transpilation/jsenv_plugin_import_meta_resolve.js

@@ -1,4 +1,4 @@
-import { createMagicSource } from "@jsenv/sourcemap"
+import { createMagicSource } from "@jsenv/sourcemap";
 
 export const jsenvPluginImportMetaResolve = () => {
   return {
@@ -6,43 +6,43 @@ export const jsenvPluginImportMetaResolve = () => {
     appliesDuring: "*",
     init: (context) => {
       if (context.isSupportedOnCurrentClients("import_meta_resolve")) {
-        return false
+        return false;
       }
       // keep it untouched, systemjs will handle it
       if (context.systemJsTranspilation) {
-        return false
+        return false;
       }
-      return true
+      return true;
     },
     transformUrlContent: {
       js_module: async (urlInfo, context) => {
-        const magicSource = createMagicSource(urlInfo.content)
+        const magicSource = createMagicSource(urlInfo.content);
         context.referenceUtils._references.forEach((ref) => {
           if (ref.subtype === "import_meta_resolve") {
-            const originalSpecifierLength = Buffer.byteLength(ref.specifier)
+            const originalSpecifierLength = Buffer.byteLength(ref.specifier);
             const specifierLength = Buffer.byteLength(
               ref.generatedSpecifier.slice(1, -1), // remove `"` around
-            )
+            );
             const specifierLengthDiff =
-              specifierLength - originalSpecifierLength
-            const end = ref.node.end + specifierLengthDiff
+              specifierLength - originalSpecifierLength;
+            const end = ref.node.end + specifierLengthDiff;
             magicSource.replace({
               start: ref.node.start,
               end,
               replacement: `new URL(${ref.generatedSpecifier}, import.meta.url).href`,
-            })
-            const currentLengthBeforeSpecifier = "import.meta.resolve(".length
-            const newLengthBeforeSpecifier = "new URL(".length
+            });
+            const currentLengthBeforeSpecifier = "import.meta.resolve(".length;
+            const newLengthBeforeSpecifier = "new URL(".length;
             const lengthDiff =
-              currentLengthBeforeSpecifier - newLengthBeforeSpecifier
-            ref.specifierColumn -= lengthDiff
-            ref.specifierStart -= lengthDiff
+              currentLengthBeforeSpecifier - newLengthBeforeSpecifier;
+            ref.specifierColumn -= lengthDiff;
+            ref.specifierStart -= lengthDiff;
             ref.specifierEnd =
-              ref.specifierStart + Buffer.byteLength(ref.generatedSpecifier)
+              ref.specifierStart + Buffer.byteLength(ref.generatedSpecifier);
           }
-        })
-        return magicSource.toContentAndSourcemap()
+        });
+        return magicSource.toContentAndSourcemap();
       },
     },
-  }
-}
+  };
+};

package/src/plugins/transpilation/jsenv_plugin_top_level_await.js

@@ -1,6 +1,6 @@
-import { applyBabelPlugins } from "@jsenv/ast"
+import { applyBabelPlugins } from "@jsenv/ast";
 
-import { requireBabelPlugin } from "./babel/require_babel_plugin.js"
+import { requireBabelPlugin } from "./babel/require_babel_plugin.js";
 
 export const jsenvPluginTopLevelAwait = () => {
   return {
@@ -8,19 +8,19 @@ export const jsenvPluginTopLevelAwait = () => {
     appliesDuring: "*",
     init: (context) => {
       if (context.isSupportedOnCurrentClients("top_level_await")) {
-        return false
+        return false;
       }
       // keep it untouched, systemjs will handle it
       if (context.systemJsTranspilation) {
-        return false
+        return false;
       }
-      return true
+      return true;
     },
     transformUrlContent: {
       js_module: async (urlInfo) => {
-        const usesTLA = await usesTopLevelAwait(urlInfo)
+        const usesTLA = await usesTopLevelAwait(urlInfo);
         if (!usesTLA) {
-          return null
+          return null;
         }
         const { code, map } = await applyBabelPlugins({
           urlInfo,
@@ -44,44 +44,44 @@ export const jsenvPluginTopLevelAwait = () => {
               },
             ],
           ],
-        })
+        });
         return {
           content: code,
           sourcemap: map,
-        }
+        };
       },
     },
-  }
-}
+  };
+};
 
 const usesTopLevelAwait = async (urlInfo) => {
   if (!urlInfo.content.includes("await ")) {
-    return false
+    return false;
   }
   const { metadata } = await applyBabelPlugins({
     urlInfo,
     babelPlugins: [babelPluginMetadataUsesTopLevelAwait],
-  })
-  return metadata.usesTopLevelAwait
-}
+  });
+  return metadata.usesTopLevelAwait;
+};
 
 const babelPluginMetadataUsesTopLevelAwait = () => {
   return {
     name: "metadata-uses-top-level-await",
     visitor: {
       Program: (programPath, state) => {
-        let usesTopLevelAwait = false
+        let usesTopLevelAwait = false;
         programPath.traverse({
           AwaitExpression: (path) => {
-            const closestFunction = path.getFunctionParent()
+            const closestFunction = path.getFunctionParent();
             if (!closestFunction || closestFunction.type === "Program") {
-              usesTopLevelAwait = true
-              path.stop()
+              usesTopLevelAwait = true;
+              path.stop();
             }
           },
-        })
-        state.file.metadata.usesTopLevelAwait = usesTopLevelAwait
+        });
+        state.file.metadata.usesTopLevelAwait = usesTopLevelAwait;
       },
     },
-  }
-}
+  };
+};

package/src/plugins/transpilation/jsenv_plugin_transpilation.js

@@ -7,13 +7,13 @@
  * of this plugin
  */
 
-import { jsenvPluginCssTranspilation } from "./css/jsenv_plugin_css_transpilation.js"
-import { jsenvPluginImportAssertions } from "./import_assertions/jsenv_plugin_import_assertions.js"
-import { jsenvPluginJsModuleFallback } from "./js_module_fallback/jsenv_plugin_js_module_fallback.js"
-import { jsenvPluginAsJsModule } from "./as_js_module/jsenv_plugin_as_js_module.js"
-import { jsenvPluginBabel } from "./babel/jsenv_plugin_babel.js"
-import { jsenvPluginTopLevelAwait } from "./jsenv_plugin_top_level_await.js"
-import { jsenvPluginImportMetaResolve } from "./jsenv_plugin_import_meta_resolve.js"
+import { jsenvPluginCssTranspilation } from "./css/jsenv_plugin_css_transpilation.js";
+import { jsenvPluginImportAssertions } from "./import_assertions/jsenv_plugin_import_assertions.js";
+import { jsenvPluginJsModuleFallback } from "./js_module_fallback/jsenv_plugin_js_module_fallback.js";
+import { jsenvPluginAsJsModule } from "./as_js_module/jsenv_plugin_as_js_module.js";
+import { jsenvPluginBabel } from "./babel/jsenv_plugin_babel.js";
+import { jsenvPluginTopLevelAwait } from "./jsenv_plugin_top_level_await.js";
+import { jsenvPluginImportMetaResolve } from "./jsenv_plugin_import_meta_resolve.js";
 
 export const jsenvPluginTranspilation = ({
   importAssertions = true,
@@ -28,10 +28,10 @@ export const jsenvPluginTranspilation = ({
   getCustomBabelPlugins,
 }) => {
   if (importAssertions === true) {
-    importAssertions = {}
+    importAssertions = {};
   }
   if (jsModuleFallbackOnJsClassic === true) {
-    jsModuleFallbackOnJsClassic = {}
+    jsModuleFallbackOnJsClassic = {};
   }
   return [
     ...(importMetaResolve ? [jsenvPluginImportMetaResolve()] : []),
@@ -52,5 +52,5 @@ export const jsenvPluginTranspilation = ({
     // so we want to wait to know the module format before transforming things related to top level await
     ...(topLevelAwait ? [jsenvPluginTopLevelAwait(topLevelAwait)] : []),
     ...(css ? [jsenvPluginCssTranspilation()] : []),
-  ]
-}
+  ];
+};

package/src/plugins/url_analysis/css/css_urls.js

@@ -2,16 +2,16 @@
  * https://github.com/parcel-bundler/parcel/blob/v2/packages/transformers/css/src/CSSTransformer.js
  */
 
-import { parseCssUrls } from "@jsenv/ast"
-import { createMagicSource } from "@jsenv/sourcemap"
+import { parseCssUrls } from "@jsenv/ast";
+import { createMagicSource } from "@jsenv/sourcemap";
 
 export const parseAndTransformCssUrls = async (urlInfo, context) => {
   const cssUrls = await parseCssUrls({
     css: urlInfo.content,
     url: urlInfo.originalUrl,
-  })
-  const actions = []
-  const magicSource = createMagicSource(urlInfo.content)
+  });
+  const actions = [];
+  const magicSource = createMagicSource(urlInfo.content);
   for (const cssUrl of cssUrls) {
     const [reference] = context.referenceUtils.found({
       type: cssUrl.type,
@@ -20,20 +20,20 @@ export const parseAndTransformCssUrls = async (urlInfo, context) => {
       specifierEnd: cssUrl.end,
       specifierLine: cssUrl.line,
       specifierColumn: cssUrl.column,
-    })
+    });
     actions.push(async () => {
       const replacement = await context.referenceUtils.readGeneratedSpecifier(
         reference,
-      )
+      );
       magicSource.replace({
         start: cssUrl.start,
         end: cssUrl.end,
         replacement,
-      })
-    })
+      });
+    });
   }
   if (actions.length > 0) {
-    await Promise.all(actions.map((action) => action()))
+    await Promise.all(actions.map((action) => action()));
   }
-  return magicSource.toContentAndSourcemap()
-}
+  return magicSource.toContentAndSourcemap();
+};