@jsenv/core 35.0.2 → 35.0.4

package/src/plugins/transpilation/babel/helpers/babel_plugin_structure.js

@@ -1,6 +1,6 @@
-import { getBabelHelperFileUrl } from "@jsenv/babel-plugins"
-import { requireBabelPlugin } from "../require_babel_plugin.js"
-import { babelPluginCompatMap } from "./babel_plugins_compatibility.js"
+import { getBabelHelperFileUrl } from "@jsenv/babel-plugins";
+import { requireBabelPlugin } from "../require_babel_plugin.js";
+import { babelPluginCompatMap } from "./babel_plugins_compatibility.js";
 
 export const getBaseBabelPluginStructure = ({
   url,
@@ -9,32 +9,32 @@ export const getBaseBabelPluginStructure = ({
   // getImportSpecifier,
 }) => {
   const isBabelPluginNeeded = (babelPluginName) => {
-    return !isSupported(babelPluginCompatMap[babelPluginName])
-  }
+    return !isSupported(babelPluginCompatMap[babelPluginName]);
+  };
 
-  const babelPluginStructure = {}
+  const babelPluginStructure = {};
   if (isBabelPluginNeeded("proposal-numeric-separator")) {
     babelPluginStructure["proposal-numeric-separator"] = requireBabelPlugin(
       "@babel/plugin-proposal-numeric-separator",
-    )
+    );
   }
   if (isBabelPluginNeeded("proposal-json-strings")) {
     babelPluginStructure["proposal-json-strings"] = requireBabelPlugin(
       "@babel/plugin-proposal-json-strings",
-    )
+    );
   }
   if (isBabelPluginNeeded("proposal-object-rest-spread")) {
     babelPluginStructure["proposal-object-rest-spread"] = requireBabelPlugin(
       "@babel/plugin-proposal-object-rest-spread",
-    )
+    );
   }
   if (isBabelPluginNeeded("proposal-optional-catch-binding")) {
     babelPluginStructure["proposal-optional-catch-binding"] =
-      requireBabelPlugin("@babel/plugin-proposal-optional-catch-binding")
+      requireBabelPlugin("@babel/plugin-proposal-optional-catch-binding");
   }
   if (isBabelPluginNeeded("proposal-unicode-property-regex")) {
     babelPluginStructure["proposal-unicode-property-regex"] =
-      requireBabelPlugin("@babel/plugin-proposal-unicode-property-regex")
+      requireBabelPlugin("@babel/plugin-proposal-unicode-property-regex");
   }
   if (isBabelPluginNeeded("transform-async-to-promises")) {
     babelPluginStructure["transform-async-to-promises"] = [
@@ -48,80 +48,80 @@ export const getBaseBabelPluginStructure = ({
         //     "babel-plugin-transform-async-to-promises/helpers.mjs",
         //   ) : null
       },
-    ]
+    ];
   }
   if (isBabelPluginNeeded("transform-arrow-functions")) {
     babelPluginStructure["transform-arrow-functions"] = requireBabelPlugin(
       "@babel/plugin-transform-arrow-functions",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-block-scoped-functions")) {
     babelPluginStructure["transform-block-scoped-functions"] =
-      requireBabelPlugin("@babel/plugin-transform-block-scoped-functions")
+      requireBabelPlugin("@babel/plugin-transform-block-scoped-functions");
   }
   if (isBabelPluginNeeded("transform-block-scoping")) {
     babelPluginStructure["transform-block-scoping"] = requireBabelPlugin(
       "@babel/plugin-transform-block-scoping",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-classes")) {
     babelPluginStructure["transform-classes"] = requireBabelPlugin(
       "@babel/plugin-transform-classes",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-computed-properties")) {
     babelPluginStructure["transform-computed-properties"] = requireBabelPlugin(
       "@babel/plugin-transform-computed-properties",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-destructuring")) {
     babelPluginStructure["transform-destructuring"] = requireBabelPlugin(
       "@babel/plugin-transform-destructuring",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-dotall-regex")) {
     babelPluginStructure["transform-dotall-regex"] = requireBabelPlugin(
       "@babel/plugin-transform-dotall-regex",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-duplicate-keys")) {
     babelPluginStructure["transform-duplicate-keys"] = requireBabelPlugin(
       "@babel/plugin-transform-duplicate-keys",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-exponentiation-operator")) {
     babelPluginStructure["transform-exponentiation-operator"] =
-      requireBabelPlugin("@babel/plugin-transform-exponentiation-operator")
+      requireBabelPlugin("@babel/plugin-transform-exponentiation-operator");
   }
   if (isBabelPluginNeeded("transform-for-of")) {
     babelPluginStructure["transform-for-of"] = requireBabelPlugin(
       "@babel/plugin-transform-for-of",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-function-name")) {
     babelPluginStructure["transform-function-name"] = requireBabelPlugin(
       "@babel/plugin-transform-function-name",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-literals")) {
     babelPluginStructure["transform-literals"] = requireBabelPlugin(
       "@babel/plugin-transform-literals",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-new-target")) {
     babelPluginStructure["transform-new-target"] = requireBabelPlugin(
       "@babel/plugin-transform-new-target",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-object-super")) {
     babelPluginStructure["transform-object-super"] = requireBabelPlugin(
       "@babel/plugin-transform-object-super",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-parameters")) {
     babelPluginStructure["transform-parameters"] = requireBabelPlugin(
       "@babel/plugin-transform-parameters",
-    )
+    );
   }
   if (isBabelPluginNeeded("transform-regenerator")) {
     babelPluginStructure["transform-regenerator"] = [
@@ -131,27 +131,27 @@ export const getBaseBabelPluginStructure = ({
         generators: true,
         async: false,
       },
-    ]
+    ];
   }
   if (isBabelPluginNeeded("transform-shorthand-properties")) {
     babelPluginStructure["transform-shorthand-properties"] = [
       requireBabelPlugin("@babel/plugin-transform-shorthand-properties"),
-    ]
+    ];
   }
   if (isBabelPluginNeeded("transform-spread")) {
     babelPluginStructure["transform-spread"] = [
       requireBabelPlugin("@babel/plugin-transform-spread"),
-    ]
+    ];
   }
   if (isBabelPluginNeeded("transform-sticky-regex")) {
     babelPluginStructure["transform-sticky-regex"] = [
       requireBabelPlugin("@babel/plugin-transform-sticky-regex"),
-    ]
+    ];
   }
   if (isBabelPluginNeeded("transform-template-literals")) {
     babelPluginStructure["transform-template-literals"] = [
       requireBabelPlugin("@babel/plugin-transform-template-literals"),
-    ]
+    ];
   }
   if (
     isBabelPluginNeeded("transform-typeof-symbol") &&
@@ -162,12 +162,12 @@ export const getBaseBabelPluginStructure = ({
   ) {
     babelPluginStructure["transform-typeof-symbol"] = [
       requireBabelPlugin("@babel/plugin-transform-typeof-symbol"),
-    ]
+    ];
   }
   if (isBabelPluginNeeded("transform-unicode-regex")) {
     babelPluginStructure["transform-unicode-regex"] = [
       requireBabelPlugin("@babel/plugin-transform-unicode-regex"),
-    ]
+    ];
   }
-  return babelPluginStructure
-}
+  return babelPluginStructure;
+};

package/src/plugins/transpilation/babel/helpers/babel_plugins_compatibility.js

@@ -421,12 +421,12 @@ export const babelPluginCompatMap = {
     samsung: "1",
     electron: "0.20",
   },
-}
+};
 
 // copy of transform-async-to-generator
 // so that async is not transpiled when supported
 babelPluginCompatMap["transform-async-to-promises"] =
-  babelPluginCompatMap["transform-async-to-generator"]
+  babelPluginCompatMap["transform-async-to-generator"];
 
 babelPluginCompatMap["regenerator-transform"] =
-  babelPluginCompatMap["transform-regenerator"]
+  babelPluginCompatMap["transform-regenerator"];

package/src/plugins/transpilation/babel/jsenv_plugin_babel.js

@@ -1,38 +1,38 @@
-import { applyBabelPlugins } from "@jsenv/ast"
+import { applyBabelPlugins } from "@jsenv/ast";
 
-import { RUNTIME_COMPAT } from "@jsenv/core/src/kitchen/compat/runtime_compat.js"
-import { getBaseBabelPluginStructure } from "./helpers/babel_plugin_structure.js"
-import { babelPluginBabelHelpersAsJsenvImports } from "./helpers/babel_plugin_babel_helpers_as_jsenv_imports.js"
-import { babelPluginNewStylesheetAsJsenvImport } from "./new_stylesheet/babel_plugin_new_stylesheet_as_jsenv_import.js"
-import { babelPluginGlobalThisAsJsenvImport } from "./global_this/babel_plugin_global_this_as_jsenv_import.js"
-import { babelPluginRegeneratorRuntimeAsJsenvImport } from "./regenerator_runtime/babel_plugin_regenerator_runtime_as_jsenv_import.js"
+import { RUNTIME_COMPAT } from "@jsenv/core/src/kitchen/compat/runtime_compat.js";
+import { getBaseBabelPluginStructure } from "./helpers/babel_plugin_structure.js";
+import { babelPluginBabelHelpersAsJsenvImports } from "./helpers/babel_plugin_babel_helpers_as_jsenv_imports.js";
+import { babelPluginNewStylesheetAsJsenvImport } from "./new_stylesheet/babel_plugin_new_stylesheet_as_jsenv_import.js";
+import { babelPluginGlobalThisAsJsenvImport } from "./global_this/babel_plugin_global_this_as_jsenv_import.js";
+import { babelPluginRegeneratorRuntimeAsJsenvImport } from "./regenerator_runtime/babel_plugin_regenerator_runtime_as_jsenv_import.js";
 
 export const jsenvPluginBabel = ({
   getCustomBabelPlugins,
   babelHelpersAsImport = true,
 } = {}) => {
   const transformWithBabel = async (urlInfo, context) => {
-    const isJsModule = urlInfo.type === "js_module"
+    const isJsModule = urlInfo.type === "js_module";
 
     const isSupported = (feature) =>
-      RUNTIME_COMPAT.isSupported(context.clientRuntimeCompat, feature)
+      RUNTIME_COMPAT.isSupported(context.clientRuntimeCompat, feature);
     const getImportSpecifier = (clientFileUrl) => {
       const [reference] = context.referenceUtils.inject({
         type: "js_import",
         expectedType: "js_module",
         specifier: clientFileUrl,
-      })
-      return JSON.parse(reference.generatedSpecifier)
-    }
+      });
+      return JSON.parse(reference.generatedSpecifier);
+    };
 
     const babelPluginStructure = getBaseBabelPluginStructure({
       url: urlInfo.url,
       isSupported,
       isJsModule,
       getImportSpecifier,
-    })
+    });
     if (getCustomBabelPlugins) {
-      Object.assign(babelPluginStructure, getCustomBabelPlugins(context))
+      Object.assign(babelPluginStructure, getCustomBabelPlugins(context));
     }
 
     if (isJsModule && babelHelpersAsImport) {
@@ -42,7 +42,7 @@ export const jsenvPluginBabel = ({
           {
             getImportSpecifier,
           },
-        ]
+        ];
       }
       if (!isSupported("async_generator_function")) {
         babelPluginStructure["regenerator-runtime-as-jsenv-import"] = [
@@ -50,7 +50,7 @@ export const jsenvPluginBabel = ({
           {
             getImportSpecifier,
           },
-        ]
+        ];
       }
       if (!isSupported("new_stylesheet")) {
         babelPluginStructure["new-stylesheet-as-jsenv-import"] = [
@@ -58,7 +58,7 @@ export const jsenvPluginBabel = ({
           {
             getImportSpecifier,
           },
-        ]
+        ];
       }
       if (Object.keys(babelPluginStructure).length > 0) {
         babelPluginStructure["babel-helper-as-jsenv-import"] = [
@@ -66,7 +66,7 @@ export const jsenvPluginBabel = ({
           {
             getImportSpecifier,
           },
-        ]
+        ];
       }
     }
     // otherwise, concerning global_this, and new_stylesheet we must inject the code
@@ -74,7 +74,7 @@ export const jsenvPluginBabel = ({
 
     const babelPlugins = Object.keys(babelPluginStructure).map(
       (babelPluginName) => babelPluginStructure[babelPluginName],
-    )
+    );
     const { code, map } = await applyBabelPlugins({
       babelPlugins,
       urlInfo,
@@ -83,12 +83,12 @@ export const jsenvPluginBabel = ({
           retainLines: context.dev,
         },
       },
-    })
+    });
     return {
       content: code,
       sourcemap: map,
-    }
-  }
+    };
+  };
   return {
     name: "jsenv:babel",
     appliesDuring: "*",
@@ -96,5 +96,5 @@ export const jsenvPluginBabel = ({
       js_classic: transformWithBabel,
       js_module: transformWithBabel,
     },
-  }
-}
+  };
+};

package/src/plugins/transpilation/babel/new_stylesheet/babel_plugin_new_stylesheet_as_jsenv_import.js

@@ -1,10 +1,10 @@
-import { pathToFileURL } from "node:url"
-import { injectJsImport } from "@jsenv/ast"
+import { pathToFileURL } from "node:url";
+import { injectJsImport } from "@jsenv/ast";
 
 export const newStylesheetClientFileUrl = new URL(
   "./client/new_stylesheet.js",
   import.meta.url,
-).href
+).href;
 
 export const babelPluginNewStylesheetAsJsenvImport = (
   babel,
@@ -15,58 +15,58 @@ export const babelPluginNewStylesheetAsJsenvImport = (
     visitor: {
       Program: (programPath, babelState) => {
         if (babelState.filename) {
-          const fileUrl = pathToFileURL(babelState.filename).href
+          const fileUrl = pathToFileURL(babelState.filename).href;
           if (fileUrl === newStylesheetClientFileUrl) {
-            return
+            return;
           }
         }
-        let usesNewStylesheet = false
+        let usesNewStylesheet = false;
         programPath.traverse({
           NewExpression: (path) => {
-            usesNewStylesheet = isNewCssStyleSheetCall(path.node)
+            usesNewStylesheet = isNewCssStyleSheetCall(path.node);
             if (usesNewStylesheet) {
-              path.stop()
+              path.stop();
             }
           },
           MemberExpression: (path) => {
-            usesNewStylesheet = isDocumentAdoptedStyleSheets(path.node)
+            usesNewStylesheet = isDocumentAdoptedStyleSheets(path.node);
             if (usesNewStylesheet) {
-              path.stop()
+              path.stop();
             }
           },
           CallExpression: (path) => {
             if (path.node.callee.type !== "Import") {
               // Some other function call, not import();
-              return
+              return;
             }
             if (path.node.arguments[0].type !== "StringLiteral") {
               // Non-string argument, probably a variable or expression, e.g.
               // import(moduleId)
               // import('./' + moduleName)
-              return
+              return;
             }
-            const sourcePath = path.get("arguments")[0]
+            const sourcePath = path.get("arguments")[0];
             usesNewStylesheet =
               hasCssModuleQueryParam(sourcePath) ||
-              hasImportTypeCssAssertion(path)
+              hasImportTypeCssAssertion(path);
             if (usesNewStylesheet) {
-              path.stop()
+              path.stop();
             }
           },
           ImportDeclaration: (path) => {
-            const sourcePath = path.get("source")
+            const sourcePath = path.get("source");
             usesNewStylesheet =
               hasCssModuleQueryParam(sourcePath) ||
-              hasImportTypeCssAssertion(path)
+              hasImportTypeCssAssertion(path);
             if (usesNewStylesheet) {
-              path.stop()
+              path.stop();
             }
           },
           ExportAllDeclaration: (path) => {
-            const sourcePath = path.get("source")
-            usesNewStylesheet = hasCssModuleQueryParam(sourcePath)
+            const sourcePath = path.get("source");
+            usesNewStylesheet = hasCssModuleQueryParam(sourcePath);
             if (usesNewStylesheet) {
-              path.stop()
+              path.stop();
             }
           },
           ExportNamedDeclaration: (path) => {
@@ -76,34 +76,34 @@ export const babelPluginNewStylesheetAsJsenvImport = (
               // export { varName }
               // export const constName = ...
               // export function funcName() {}
-              return
+              return;
             }
-            const sourcePath = path.get("source")
-            usesNewStylesheet = hasCssModuleQueryParam(sourcePath)
+            const sourcePath = path.get("source");
+            usesNewStylesheet = hasCssModuleQueryParam(sourcePath);
             if (usesNewStylesheet) {
-              path.stop()
+              path.stop();
             }
           },
-        })
+        });
         if (usesNewStylesheet) {
           injectJsImport({
             programPath,
             from: getImportSpecifier(newStylesheetClientFileUrl),
             sideEffect: true,
-          })
+          });
         }
       },
     },
-  }
-}
+  };
+};
 
 const isNewCssStyleSheetCall = (node) => {
   return (
     node.type === "NewExpression" &&
     node.callee.type === "Identifier" &&
     node.callee.name === "CSSStyleSheet"
-  )
-}
+  );
+};
 
 const isDocumentAdoptedStyleSheets = (node) => {
   return (
@@ -112,31 +112,31 @@ const isDocumentAdoptedStyleSheets = (node) => {
     node.object.name === "document" &&
     node.property.type === "Identifier" &&
     node.property.name === "adoptedStyleSheets"
-  )
-}
+  );
+};
 
 const hasCssModuleQueryParam = (path) => {
-  const { node } = path
+  const { node } = path;
   return (
     node.type === "StringLiteral" &&
     new URL(node.value, "https://jsenv.dev").searchParams.has(`css_module`)
-  )
-}
+  );
+};
 
 const hasImportTypeCssAssertion = (path) => {
   const importAssertionsDescriptor = getImportAssertionsDescriptor(
     path.node.assertions,
-  )
-  return Boolean(importAssertionsDescriptor.type === "css")
-}
+  );
+  return Boolean(importAssertionsDescriptor.type === "css");
+};
 
 const getImportAssertionsDescriptor = (importAssertions) => {
-  const importAssertionsDescriptor = {}
+  const importAssertionsDescriptor = {};
   if (importAssertions) {
     importAssertions.forEach((importAssertion) => {
       importAssertionsDescriptor[importAssertion.key.name] =
-        importAssertion.value.value
-    })
+        importAssertion.value.value;
+    });
   }
-  return importAssertionsDescriptor
-}
+  return importAssertionsDescriptor;
+};