@jsenv/core 27.0.0-alpha.38 → 27.0.0-alpha.40

package/src/plugins/transpilation/as_js_classic/jsenv_plugin_workers_type_module_as_classic.js

@@ -1,61 +1,81 @@
-import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
 import { injectQueryParamsIntoSpecifier } from "@jsenv/utils/urls/url_utils.js"
 import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
-import {
-  analyzeNewWorkerOrNewSharedWorker,
-  analyzeServiceWorkerRegisterCall,
-} from "@jsenv/utils/js_ast/js_static_analysis.js"
+import { parseJsUrls } from "@jsenv/core/packages/utils/js_ast/parse_js_urls.js"
 
-// TODO: handle also service worker and shared worker in this plugin
 export const jsenvPluginWorkersTypeModuleAsClassic = ({
   generateJsClassicFilename,
 }) => {
   const transformJsWorkerTypes = async (urlInfo, context) => {
-    const workersToTranspile = getWorkersToTranspile(urlInfo, context)
-    if (
-      !workersToTranspile.worker &&
-      !workersToTranspile.serviceWorker &&
-      !workersToTranspile.sharedServiceWorker
-    ) {
-      return null
-    }
-    const { metadata } = await applyBabelPlugins({
-      babelPlugins: [
-        [
-          babelPluginMetadataWorkerMentions,
-          {
-            workersToTranspile,
-            isJsModule: urlInfo.type === "js_module",
-          },
-        ],
-      ],
-      urlInfo,
+    const toUpdate = []
+    let workerTypeModuleIsSupported
+    let serviceWorkerTypeModuleIsSupported
+    let sharedWorkerTypeModuleIsSupported
+    const jsUrls = parseJsUrls({
+      js: urlInfo.content,
+      url: (urlInfo.data && urlInfo.data.rawUrl) || urlInfo.url,
+      isJsModule: urlInfo.type === "js_module",
     })
-    const { workerMentions } = metadata
-    const magicSource = createMagicSource(urlInfo.content)
-    workerMentions.forEach((workerMention) => {
-      if (workerMention.expectedType !== "js_module") {
+    jsUrls.forEach((jsUrlMention) => {
+      if (jsUrlMention.expectedType !== "js_module") {
         return
       }
-      const specifier = workerMention.specifier
+      if (jsUrlMention.expectedSubtype === "worker") {
+        if (workerTypeModuleIsSupported === undefined) {
+          workerTypeModuleIsSupported =
+            context.isSupportedOnCurrentClients("worker_type_module")
+        }
+        if (workerTypeModuleIsSupported) {
+          return
+        }
+        toUpdate.push(jsUrlMention)
+        return
+      }
+      if (jsUrlMention.expectedSubtype === "service_worker") {
+        if (serviceWorkerTypeModuleIsSupported === undefined) {
+          serviceWorkerTypeModuleIsSupported =
+            context.isSupportedOnCurrentClients("service_worker_type_module")
+        }
+        if (serviceWorkerTypeModuleIsSupported) {
+          return
+        }
+        toUpdate.push(jsUrlMention)
+        return
+      }
+      if (jsUrlMention.expectedSubtype === "shared_worker") {
+        if (sharedWorkerTypeModuleIsSupported === undefined) {
+          sharedWorkerTypeModuleIsSupported =
+            context.isSupportedOnCurrentClients("shared_worker_type_module")
+        }
+        if (sharedWorkerTypeModuleIsSupported) {
+          return
+        }
+        toUpdate.push(jsUrlMention)
+        return
+      }
+    })
+    if (toUpdate.length === 0) {
+      return null
+    }
+    const magicSource = createMagicSource(urlInfo.content)
+    toUpdate.forEach((jsUrlMention) => {
       const reference = context.referenceUtils.findByGeneratedSpecifier(
-        JSON.stringify(specifier),
+        JSON.stringify(jsUrlMention.specifier),
       )
       const [newReference] = context.referenceUtils.update(reference, {
         expectedType: "js_classic",
-        specifier: injectQueryParamsIntoSpecifier(specifier, {
+        specifier: injectQueryParamsIntoSpecifier(reference.specifier, {
           as_js_classic: "",
         }),
         filename: generateJsClassicFilename(reference.url),
       })
       magicSource.replace({
-        start: workerMention.start,
-        end: workerMention.end,
+        start: jsUrlMention.start,
+        end: jsUrlMention.end,
         replacement: newReference.generatedSpecifier,
       })
       magicSource.replace({
-        start: workerMention.typeArgNode.value.start,
-        end: workerMention.typeArgNode.value.end,
+        start: jsUrlMention.typePropertyNode.value.start,
+        end: jsUrlMention.typePropertyNode.value.end,
         replacement: JSON.stringify("classic"),
       })
     })
@@ -71,69 +91,3 @@ export const jsenvPluginWorkersTypeModuleAsClassic = ({
     },
   }
 }
-
-const getWorkersToTranspile = (urlInfo, context) => {
-  let worker = false
-  let serviceWorker = false
-  let sharedWorker = false
-  for (const reference of urlInfo.references) {
-    if (reference.expectedType !== "js_module") {
-      continue
-    }
-    if (
-      reference.expectedSubtype === "worker" &&
-      !context.isSupportedOnCurrentClients("worker_type_module")
-    ) {
-      worker = true
-    }
-    if (
-      reference.expectedSubtype === "service_worker" &&
-      !context.isSupportedOnCurrentClients("service_worker_type_module")
-    ) {
-      serviceWorker = true
-    }
-    if (
-      reference.expectedSubtype === "shared_worker" &&
-      !context.isSupportedOnCurrentClients("shared_worker_type_module")
-    ) {
-      sharedWorker = true
-    }
-  }
-  return { worker, serviceWorker, sharedWorker }
-}
-
-const babelPluginMetadataWorkerMentions = (
-  _,
-  { workersToTranspile, isJsModule },
-) => {
-  return {
-    name: "metadata-worker-mentions",
-    visitor: {
-      Program(programPath, state) {
-        const workerMentions = []
-        const visitors = {
-          NewExpression: (path) => {
-            if (workersToTranspile.worker || workersToTranspile.sharedWorker) {
-              const mentions = analyzeNewWorkerOrNewSharedWorker(path, {
-                isJsModule,
-              })
-              if (mentions) {
-                workerMentions.push(...mentions)
-              }
-            }
-          },
-        }
-        if (workersToTranspile.serviceWorker) {
-          visitors.CallExpression = (path) => {
-            const mentions = analyzeServiceWorkerRegisterCall(path)
-            if (mentions) {
-              workerMentions.push(...mentions)
-            }
-          }
-        }
-        programPath.traverse(visitors)
-        state.file.metadata.workerMentions = workerMentions
-      },
-    },
-  }
-}

package/src/plugins/transpilation/import_assertions/jsenv_plugin_import_assertions.js

@@ -1,12 +1,11 @@
 import { urlToFilename } from "@jsenv/filesystem"
 
-import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
+import { parseJsImportAssertions } from "@jsenv/utils/js_ast/parse_js_import_assertions.js"
 import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
 import { injectQueryParamsIntoSpecifier } from "@jsenv/utils/urls/url_utils.js"
 import { JS_QUOTES } from "@jsenv/utils/string/js_quotes.js"
 
 import { fetchOriginalUrlInfo } from "../fetch_original_url_info.js"
-import { babelPluginMetadataImportAssertions } from "./helpers/babel_plugin_metadata_import_assertions.js"
 
 export const jsenvPluginImportAssertions = () => {
   const importAssertions = {
@@ -15,18 +14,17 @@ export const jsenvPluginImportAssertions = () => {
     transformUrlContent: {
       js_module: async (urlInfo, context) => {
         // "usesImportAssertion" is set by "jsenv:imports_analysis"
-        if (!urlInfo.data.usesImportAssertion) {
+        if (urlInfo.data.usesImportAssertion === false) {
           return null
         }
         const importTypesToTranspile = getImportTypesToTranspile(context)
         if (importTypesToTranspile.length === 0) {
           return null
         }
-        const { metadata } = await applyBabelPlugins({
-          babelPlugins: [babelPluginMetadataImportAssertions],
-          urlInfo,
+        const importAssertions = await parseJsImportAssertions({
+          js: urlInfo.content,
+          url: (urlInfo.data && urlInfo.data.rawUrl) || urlInfo.url,
         })
-        const { importAssertions } = metadata
         const magicSource = createMagicSource(urlInfo.content)
         importAssertions.forEach((importAssertion) => {
           const assertType = importAssertion.assert.type
@@ -34,54 +32,27 @@ export const jsenvPluginImportAssertions = () => {
             return
           }
           const { searchParam } = importAsInfos[assertType]
-          const { path } = importAssertion
-          const { node } = path
-          if (node.type === "CallExpression") {
-            const importSpecifierPath = path.get("arguments")[0]
-            const specifier = importSpecifierPath.node.value
-            const reference = context.referenceUtils.findByGeneratedSpecifier(
-              JSON.stringify(specifier),
-            )
-            const [newReference] = context.referenceUtils.update(reference, {
-              expectedType: "js_module",
-              specifier: injectQueryParamsIntoSpecifier(specifier, {
-                [searchParam]: "",
-              }),
-              filename: `${urlToFilename(reference.url)}.js`,
-            })
-            magicSource.replace({
-              start: importSpecifierPath.node.start,
-              end: importSpecifierPath.node.end,
-              replacement: newReference.generatedSpecifier,
-            })
-            const secondArgPath = path.get("arguments")[1]
-            magicSource.remove({
-              start: secondArgPath.node.start,
-              end: secondArgPath.node.end,
-            })
-            return
-          }
-          const importSpecifierPath = path.get("source")
-          const specifier = importSpecifierPath.node.value
           const reference = context.referenceUtils.findByGeneratedSpecifier(
-            JSON.stringify(specifier),
+            JSON.stringify(importAssertion.specifier),
           )
           const [newReference] = context.referenceUtils.update(reference, {
             expectedType: "js_module",
-            specifier: injectQueryParamsIntoSpecifier(specifier, {
-              [searchParam]: "",
-            }),
+            specifier: injectQueryParamsIntoSpecifier(
+              importAssertion.specifier,
+              {
+                [searchParam]: "",
+              },
+            ),
             filename: `${urlToFilename(reference.url)}.js`,
           })
           magicSource.replace({
-            start: importSpecifierPath.node.start,
-            end: importSpecifierPath.node.end,
+            start: importAssertion.specifierStart,
+            end: importAssertion.specifierEnd,
             replacement: newReference.generatedSpecifier,
           })
-          const assertionsPath = path.get("assertions")[0]
           magicSource.remove({
-            start: assertionsPath.node.start,
-            end: assertionsPath.node.end,
+            start: importAssertion.assertNode.start,
+            end: importAssertion.assertNode.end,
           })
         })
         return magicSource.toContentAndSourcemap()
@@ -208,10 +179,10 @@ const getImportTypesToTranspile = ({
   isSupportedOnCurrentClients,
 }) => {
   // during build always replace import assertions with the js:
-  // - means rollup can bundle more js file together
-  // - means url versioning can work for css inlined in js
   // - avoid rollup to see import assertions
   //   We would have to tell rollup to ignore import with assertion
+  // - means rollup can bundle more js file together
+  // - means url versioning can work for css inlined in js
   if (scenario === "build") {
     return ["json", "css", "text"]
   }

package/src/plugins/url_references/js/js_urls.js

@@ -1,17 +1,14 @@
-import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
-import {
-  analyzeNewUrlCall,
-  analyzeNewWorkerOrNewSharedWorker,
-  analyzeImportScriptCalls,
-  analyzeSystemRegisterCall,
-  analyzeSystemImportCall,
-  analyzeServiceWorkerRegisterCall,
-} from "@jsenv/utils/js_ast/js_static_analysis.js"
+import { parseJsUrls } from "@jsenv/utils/js_ast/parse_js_urls.js"
 import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
 import { isWebWorkerUrlInfo } from "@jsenv/core/src/omega/web_workers.js"
 
 export const parseAndTransformJsUrls = async (urlInfo, context) => {
-  const jsMentions = await performJsUrlsStaticAnalysis(urlInfo)
+  const jsMentions = await parseJsUrls({
+    js: urlInfo.content,
+    url: (urlInfo.data && urlInfo.data.rawUrl) || urlInfo.url,
+    isJsModule: urlInfo.type === "js_module",
+    isWebWorker: isWebWorkerUrlInfo(urlInfo),
+  })
   const { rootDirectoryUrl, referenceUtils } = context
   const actions = []
   const magicSource = createMagicSource(urlInfo.content)
@@ -29,6 +26,8 @@ export const parseAndTransformJsUrls = async (urlInfo, context) => {
         "StringLiteral": jsMention.baseUrl,
         "window.origin": rootDirectoryUrl,
         "import.meta.url": urlInfo.url,
+        "context.meta.url": urlInfo.url,
+        "document.currentScript.src": urlInfo.url,
       }[jsMention.baseUrlType],
     })
     actions.push(async () => {
@@ -42,107 +41,3 @@ export const parseAndTransformJsUrls = async (urlInfo, context) => {
   await Promise.all(actions.map((action) => action()))
   return magicSource.toContentAndSourcemap()
 }
-
-const performJsUrlsStaticAnalysis = async (urlInfo) => {
-  const isJsModule = urlInfo.type === "js_module"
-  const isWebWorker = isWebWorkerUrlInfo(urlInfo)
-  if (canSkipStaticAnalysis(urlInfo, { isJsModule, isWebWorker })) {
-    return []
-  }
-  const { metadata } = await applyBabelPlugins({
-    babelPlugins: [
-      [babelPluginMetadataJsUrlMentions, { isJsModule, isWebWorker }],
-    ],
-    urlInfo,
-  })
-  const { jsMentions } = metadata
-  return jsMentions
-}
-
-const canSkipStaticAnalysis = (urlInfo, { isJsModule, isWebWorker }) => {
-  const js = urlInfo.content
-  if (isJsModule) {
-    if (
-      js.includes("new URL(") ||
-      js.includes("new Worker(") ||
-      js.includes("new SharedWorker(") ||
-      js.includes("serviceWorker.register(")
-    ) {
-      return false
-    }
-  }
-  if (!isJsModule) {
-    if (
-      js.includes("System.") ||
-      js.includes("new URL(") ||
-      js.includes("new Worker(") ||
-      js.includes("new SharedWorker(") ||
-      js.includes("serviceWorker.register(")
-    ) {
-      return false
-    }
-  }
-  if (isWebWorker && js.includes("importScripts(")) {
-    return false
-  }
-  return true
-}
-
-/*
- * see also
- * https://github.com/jamiebuilds/babel-handbook/blob/master/translations/en/plugin-handbook.md
- * https://github.com/mjackson/babel-plugin-import-visitor
- *
- */
-const babelPluginMetadataJsUrlMentions = (_, { isJsModule, isWebWorker }) => {
-  return {
-    name: "metadata-js-mentions",
-    visitor: {
-      Program(programPath, state) {
-        const jsMentions = []
-        const callOneStaticAnalyzer = (path, analyzer) => {
-          const returnValue = analyzer(path)
-          if (returnValue === null) {
-            return false
-          }
-          if (Array.isArray(returnValue)) {
-            jsMentions.push(...returnValue)
-            return true
-          }
-          if (typeof returnValue === "object") {
-            jsMentions.push(returnValue)
-            return true
-          }
-          return false
-        }
-        const callStaticAnalyzers = (path, analysers) => {
-          for (const analyzer of analysers) {
-            if (callOneStaticAnalyzer(path, analyzer)) {
-              break
-            }
-          }
-        }
-        const visitors = {
-          NewExpression: (path) => {
-            callStaticAnalyzers(path, [
-              (path) => analyzeNewWorkerOrNewSharedWorker(path, { isJsModule }),
-              (path) => analyzeNewUrlCall(path, { isJsModule }),
-            ])
-          },
-        }
-        const callExpressionStaticAnalysers = [
-          ...(isJsModule
-            ? []
-            : [analyzeSystemRegisterCall, analyzeSystemImportCall]),
-          ...(isWebWorker ? [analyzeImportScriptCalls] : []),
-          analyzeServiceWorkerRegisterCall,
-        ]
-        visitors.CallExpression = (path) => {
-          callStaticAnalyzers(path, callExpressionStaticAnalysers)
-        }
-        programPath.traverse(visitors)
-        state.file.metadata.jsMentions = jsMentions
-      },
-    },
-  }
-}

package/src/plugins/url_references/jsenv_plugin_imports_analysis.js

@@ -7,31 +7,31 @@ export const jsenvPluginImportsAnalysis = () => {
     appliesDuring: "*",
     transformUrlContent: {
       js_module: async (urlInfo, context) => {
-        const [imports, exports] = await parseJsModuleImports(
-          urlInfo.content,
-          (urlInfo.data && urlInfo.data.rawUrl) || urlInfo.url,
-        )
+        const [imports, exports] = await parseJsModuleImports({
+          js: urlInfo.content,
+          url: (urlInfo.data && urlInfo.data.rawUrl) || urlInfo.url,
+        })
         const actions = []
         const magicSource = createMagicSource(urlInfo.content)
         urlInfo.data.usesImport = imports.length > 0
         urlInfo.data.usesExport = exports.length > 0
         urlInfo.data.usesImportAssertion = imports.some(
-          (importInfo) => importInfo.usesAssert,
+          (importInfo) => typeof importInfo.usesAssert,
         )
         imports.forEach((importInfo) => {
           const [reference] = context.referenceUtils.found({
             type: "js_import_export",
             subtype: importInfo.subtype,
-            expectedType: "js_module",
+            expectedType: importInfo.expectedType, // can be json for import assertions
             expectedSubtype: urlInfo.subtype,
-            line: importInfo.line,
-            column: importInfo.column,
+            line: importInfo.specifierLine,
+            column: importInfo.specifierColumn,
             specifier: importInfo.specifier,
           })
           actions.push(async () => {
             magicSource.replace({
-              start: importInfo.start,
-              end: importInfo.end,
+              start: importInfo.specifierStart,
+              end: importInfo.specifierEnd,
               replacement: await context.referenceUtils.readGeneratedSpecifier(
                 reference,
               ),

package/src/plugins/transpilation/import_assertions/helpers/babel_plugin_metadata_import_assertions.js

@@ -1,98 +0,0 @@
-export const babelPluginMetadataImportAssertions = () => {
-  return {
-    name: "metadata-import-assertions",
-    visitor: {
-      Program: (programPath, state) => {
-        const importAssertions = collectProgramImportAssertions(programPath)
-        state.file.metadata.importAssertions = importAssertions
-      },
-    },
-  }
-}
-
-/*
- * Jsenv wont touch code where "specifier" or "type" is dynamic (see code below)
- * ```js
- * const file ="./style.css"
- * const type = "css"
- * import(file, { assert: { type }})
- * ```
- * Jsenv could throw an error because we know browser will fail to execute the code
- * because import assertions are not supported.
- * But for now (as it is simpler to do so) we let the browser throw the error
- */
-const collectProgramImportAssertions = (programPath) => {
-  const importAssertions = []
-  programPath.traverse({
-    CallExpression: (path) => {
-      if (path.node.callee.type !== "Import") {
-        // Some other function call, not import();
-        return
-      }
-      if (path.node.arguments[0].type !== "StringLiteral") {
-        // Non-string argument, probably a variable or expression, e.g.
-        // import(moduleId)
-        // import('./' + moduleName)
-        return
-      }
-      const args = path.node.arguments
-      const secondArg = args[1]
-      if (!secondArg) {
-        return
-      }
-      const { properties } = secondArg
-      const assertProperty = properties.find((property) => {
-        return property.key.name === "assert"
-      })
-      if (!assertProperty) {
-        return
-      }
-      const assertProperties = assertProperty.value.properties
-      const typePropertyNode = assertProperties.find((property) => {
-        return property.key.name === "type"
-      })
-      if (!typePropertyNode) {
-        return
-      }
-      const typePropertyValue = typePropertyNode.value
-      if (typePropertyValue.type !== "StringLiteral") {
-        return
-      }
-      const type = typePropertyValue.value
-      importAssertions.push({
-        path,
-        assert: {
-          type,
-        },
-      })
-    },
-
-    ImportDeclaration: (path) => {
-      const { assertions } = path.node
-      if (!assertions) {
-        return
-      }
-      if (assertions.length === 0) {
-        return
-      }
-      const typeAssertion = assertions.find(
-        (assertion) => assertion.key.name === "type",
-      )
-      if (!typeAssertion) {
-        return
-      }
-      const typeNode = typeAssertion.value
-      if (typeNode.type !== "StringLiteral") {
-        return
-      }
-      const type = typeNode.value
-      importAssertions.push({
-        path,
-        assert: {
-          type,
-        },
-      })
-    },
-  })
-  return importAssertions
-}