@jsenv/core 27.0.0-alpha.3 → 27.0.0-alpha.32

package/src/omega/core_plugins/babel/helpers/babel_plugin_structure.js

@@ -1,187 +0,0 @@
-import { createRequire } from "node:module"
-
-import { getBabelHelperFileUrl } from "../babel_helper/babel_helper_directory.js"
-import { babelPluginCompatMap } from "./babel_plugins_compatibility.js"
-
-const require = createRequire(import.meta.url)
-
-export const getBaseBabelPluginStructure = ({
-  url,
-  isSupportedOnRuntime,
-  usesTopLevelAwait,
-  //   // https://github.com/rpetrich/babel-plugin-transform-async-to-promises/blob/92755ff8c943c97596523e586b5fa515c2e99326/async-to-promises.ts#L55
-  topLevelAwait = "simple",
-  isJsModule,
-}) => {
-  const isBabelPluginNeeded = (babelPluginName) => {
-    return !isSupportedOnRuntime(
-      babelPluginName,
-      babelPluginCompatMap[babelPluginName],
-    )
-  }
-
-  const babelPluginStructure = {}
-  if (isBabelPluginNeeded("proposal-numeric-separator")) {
-    babelPluginStructure[
-      "proposal-numeric-separator"
-    ] = require("@babel/plugin-proposal-numeric-separator")
-  }
-  if (isBabelPluginNeeded("proposal-json-strings")) {
-    babelPluginStructure[
-      "proposal-json-strings"
-    ] = require("@babel/plugin-proposal-json-strings")
-  }
-  if (isBabelPluginNeeded("proposal-object-rest-spread")) {
-    babelPluginStructure[
-      "proposal-object-rest-spread"
-    ] = require("@babel/plugin-proposal-object-rest-spread")
-  }
-  if (isBabelPluginNeeded("proposal-optional-catch-binding")) {
-    babelPluginStructure[
-      "proposal-optional-catch-binding"
-    ] = require("@babel/plugin-proposal-optional-catch-binding")
-  }
-  if (isBabelPluginNeeded("proposal-unicode-property-regex")) {
-    babelPluginStructure[
-      "proposal-unicode-property-regex"
-    ] = require("@babel/plugin-proposal-unicode-property-regex")
-  }
-  if (
-    isJsModule &&
-    usesTopLevelAwait &&
-    !isSupportedOnRuntime("top_level_await")
-  ) {
-    babelPluginStructure["transform-async-to-promises"] = [
-      require("babel-plugin-transform-async-to-promises"),
-      {
-        topLevelAwait,
-      },
-    ]
-  } else if (isBabelPluginNeeded("transform-async-to-promises")) {
-    babelPluginStructure[
-      "transform-async-to-promises"
-    ] = require("babel-plugin-transform-async-to-promises")
-  }
-  if (isBabelPluginNeeded("transform-arrow-functions")) {
-    babelPluginStructure[
-      "transform-arrow-functions"
-    ] = require("@babel/plugin-transform-arrow-functions")
-  }
-  if (isBabelPluginNeeded("transform-block-scoped-functions")) {
-    babelPluginStructure[
-      "transform-block-scoped-functions"
-    ] = require("@babel/plugin-transform-block-scoped-functions")
-  }
-  if (isBabelPluginNeeded("transform-block-scoping")) {
-    babelPluginStructure[
-      "transform-block-scoping"
-    ] = require("@babel/plugin-transform-block-scoping")
-  }
-  if (isBabelPluginNeeded("transform-classes")) {
-    babelPluginStructure[
-      "transform-classes"
-    ] = require("@babel/plugin-transform-classes")
-  }
-  if (isBabelPluginNeeded("transform-computed-properties")) {
-    babelPluginStructure[
-      "transform-computed-properties"
-    ] = require("@babel/plugin-transform-computed-properties")
-  }
-  if (isBabelPluginNeeded("transform-destructuring")) {
-    babelPluginStructure[
-      "transform-destructuring"
-    ] = require("@babel/plugin-transform-destructuring")
-  }
-  if (isBabelPluginNeeded("transform-dotall-regex")) {
-    babelPluginStructure[
-      "transform-dotall-regex"
-    ] = require("@babel/plugin-transform-dotall-regex")
-  }
-  if (isBabelPluginNeeded("transform-duplicate-keys")) {
-    babelPluginStructure[
-      "transform-duplicate-keys"
-    ] = require("@babel/plugin-transform-duplicate-keys")
-  }
-  if (isBabelPluginNeeded("transform-exponentiation-operator")) {
-    babelPluginStructure[
-      "transform-exponentiation-operator"
-    ] = require("@babel/plugin-transform-exponentiation-operator")
-  }
-  if (isBabelPluginNeeded("transform-for-of")) {
-    babelPluginStructure[
-      "transform-for-of"
-    ] = require("@babel/plugin-transform-for-of")
-  }
-  if (isBabelPluginNeeded("transform-function-name")) {
-    babelPluginStructure[
-      "transform-function-name"
-    ] = require("@babel/plugin-transform-function-name")
-  }
-  if (isBabelPluginNeeded("transform-literals")) {
-    babelPluginStructure[
-      "transform-literals"
-    ] = require("@babel/plugin-transform-literals")
-  }
-  if (isBabelPluginNeeded("transform-new-target")) {
-    babelPluginStructure[
-      "transform-new-target"
-    ] = require("@babel/plugin-transform-new-target")
-  }
-  if (isBabelPluginNeeded("transform-object-super")) {
-    babelPluginStructure[
-      "transform-object-super"
-    ] = require("@babel/plugin-transform-object-super")
-  }
-  if (isBabelPluginNeeded("transform-parameters")) {
-    babelPluginStructure[
-      "transform-parameters"
-    ] = require("@babel/plugin-transform-parameters")
-  }
-  if (isBabelPluginNeeded("transform-regenerator")) {
-    babelPluginStructure["transform-regenerator"] = [
-      require("@babel/plugin-transform-regenerator"),
-      {
-        asyncGenerators: true,
-        generators: true,
-        async: false,
-      },
-    ]
-  }
-  if (isBabelPluginNeeded("transform-shorthand-properties")) {
-    babelPluginStructure["transform-shorthand-properties"] = [
-      require("@babel/plugin-transform-shorthand-properties"),
-    ]
-  }
-  if (isBabelPluginNeeded("transform-spread")) {
-    babelPluginStructure["transform-spread"] = [
-      require("@babel/plugin-transform-spread"),
-    ]
-  }
-  if (isBabelPluginNeeded("transform-sticky-regex")) {
-    babelPluginStructure["transform-sticky-regex"] = [
-      require("@babel/plugin-transform-sticky-regex"),
-    ]
-  }
-  if (isBabelPluginNeeded("transform-template-literals")) {
-    babelPluginStructure["transform-template-literals"] = [
-      require("@babel/plugin-transform-template-literals"),
-    ]
-  }
-  if (
-    isBabelPluginNeeded("transform-typeof-symbol") &&
-    // prevent "typeof" to be injected into itself:
-    // - not needed
-    // - would create infinite attempt to transform typeof
-    url !== getBabelHelperFileUrl("typeof")
-  ) {
-    babelPluginStructure["transform-typeof-symbol"] = [
-      require("@babel/plugin-transform-typeof-symbol"),
-    ]
-  }
-  if (isBabelPluginNeeded("transform-unicode-regex")) {
-    babelPluginStructure["transform-unicode-regex"] = [
-      require("@babel/plugin-transform-unicode-regex"),
-    ]
-  }
-  return babelPluginStructure
-}

package/src/omega/core_plugins/file_urls/jsenv_plugin_file_urls.js

@@ -1,67 +0,0 @@
-import { readFileSync } from "node:fs"
-import { urlToContentType } from "@jsenv/server"
-import {
-  urlIsInsideOf,
-  urlToRelativeUrl,
-  fileSystemRootUrl,
-} from "@jsenv/filesystem"
-import { ContentType } from "@jsenv/utils/src/content_type.js"
-
-export const jsenvPluginFileUrls = () => {
-  return [jsenvPluginResolveAbsoluteFileUrls(), jsenvPluginLoadFileUrls()]
-}
-
-const jsenvPluginResolveAbsoluteFileUrls = () => {
-  return {
-    name: "jsenv:resolve_absolute_file_urls",
-    appliesDuring: {
-      // during dev and test it's a browser running the code
-      // so absolute file urls needs to be relativized
-      dev: true,
-      test: true,
-      // during build it's fine to use file:// urls
-      build: false,
-    },
-    resolve: ({ specifier }, { rootDirectoryUrl }) => {
-      if (!specifier.startsWith("/@fs/")) {
-        return null
-      }
-      const url = new URL(specifier.slice("/@fs".length), rootDirectoryUrl).href
-      return url
-    },
-    formatReferencedUrl: ({ url }, { rootDirectoryUrl }) => {
-      if (!url.startsWith("file:")) {
-        return null
-      }
-      const specifier = urlIsInsideOf(url, rootDirectoryUrl)
-        ? `/${urlToRelativeUrl(url, rootDirectoryUrl)}`
-        : `/@fs/${url.slice(fileSystemRootUrl.length)}`
-      return specifier
-    },
-  }
-}
-
-const jsenvPluginLoadFileUrls = () => {
-  return {
-    name: "jsenv:load_file_urls",
-    appliesDuring: "*",
-    load: ({ url }) => {
-      if (!url.startsWith("file:")) {
-        return null
-      }
-      const urlObject = new URL(url)
-      const fileBuffer = readFileSync(urlObject)
-      const contentType = urlToContentType(url)
-      if (ContentType.isTextual(contentType)) {
-        return {
-          contentType,
-          content: String(fileBuffer),
-        }
-      }
-      return {
-        contentType,
-        content: fileBuffer,
-      }
-    },
-  }
-}

package/src/omega/core_plugins/import_assertions/helpers/json_module.js

@@ -1,12 +0,0 @@
-export const convertJsonTextToJavascriptModule = ({ content }) => {
-  // here we could do the following
-  // return export default jsonText
-  // This would return valid js, that would be minified later
-  // however we will prefer using JSON.parse because it's faster
-  // for js engine to parse JSON than JS
-
-  return {
-    contentType: "application/javascript",
-    content: `export default JSON.parse(${JSON.stringify(content.trim())})`,
-  }
-}

package/src/omega/core_plugins/import_assertions/helpers/text_module.js

@@ -1,6 +0,0 @@
-export const convertTextToJavascriptModule = ({ content }) => {
-  return {
-    contentType: "application/javascript",
-    content: `export default ${JSON.stringify(content)}`,
-  }
-}

package/src/omega/core_plugins/import_assertions/jsenv_plugin_import_assertions.js

@@ -1,211 +0,0 @@
-import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
-import { ContentType } from "@jsenv/utils/src/content_type.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 { babelPluginMetadataImportAssertions } from "./helpers/babel_plugin_metadata_import_assertions.js"
-import { convertJsonTextToJavascriptModule } from "./helpers/json_module.js"
-import { convertTextToJavascriptModule } from "./helpers/text_module.js"
-
-export const jsenvPluginImportAssertions = () => {
-  const importAssertions = [
-    {
-      name: "jsenv:import_assertions",
-      appliesDuring: "*",
-      transform: {
-        js_module: async (
-          { url, generatedUrl, content },
-          { scenario, isSupportedOnRuntime, referenceUtils },
-        ) => {
-          const importTypesToHandle = getImportTypesToHandle({
-            scenario,
-            isSupportedOnRuntime,
-          })
-          if (importTypesToHandle.length === 0) {
-            return null
-          }
-          const { metadata } = await applyBabelPlugins({
-            babelPlugins: [babelPluginMetadataImportAssertions],
-            url,
-            generatedUrl,
-            content,
-          })
-          const { importAssertions } = metadata
-          const magicSource = createMagicSource(content)
-          importAssertions.forEach((importAssertion) => {
-            const assertType = importAssertion.assert.type
-            if (!importTypesToHandle.includes(assertType)) {
-              return
-            }
-            const { path } = importAssertion
-            const { node } = path
-            const importType = `${assertType}_module`
-            if (node.type === "CallExpression") {
-              const importSpecifierPath = path.get("arguments")[0]
-              const specifier = importSpecifierPath.node.value
-              const newSpecifier = injectQueryParamsIntoSpecifier(specifier, {
-                [importType]: "",
-              })
-              const [newReference, newUrlInfo] = referenceUtils.updateSpecifier(
-                JSON.stringify(specifier),
-                newSpecifier,
-              )
-              newUrlInfo.data.importType = importType
-              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 newSpecifier = injectQueryParamsIntoSpecifier(specifier, {
-              [importType]: "",
-            })
-            const [newReference, newUrlInfo] = referenceUtils.updateSpecifier(
-              JSON.stringify(specifier),
-              newSpecifier,
-            )
-            newUrlInfo.data.importType = importType
-            magicSource.replace({
-              start: importSpecifierPath.node.start,
-              end: importSpecifierPath.node.end,
-              replacement: newReference.generatedSpecifier,
-            })
-            const assertionsPath = path.get("assertions")[0]
-            magicSource.remove({
-              start: assertionsPath.node.start,
-              end: assertionsPath.node.end,
-            })
-          })
-          return magicSource.toContentAndSourcemap()
-        },
-      },
-    },
-  ]
-
-  const importTypeJson = {
-    name: "jsenv:import_type_json",
-    appliesDuring: "*",
-    finalize: ({ url, contentType, content }) => {
-      if (!new URL(url).searchParams.has("json_module")) {
-        return null
-      }
-      if (contentType !== "application/json") {
-        throw new Error(
-          `Unexpected content type on ${url}, should be "application/json" but got ${contentType}`,
-        )
-      }
-      return convertJsonTextToJavascriptModule({
-        content,
-      })
-    },
-  }
-
-  // not standard but I expect this to happen one day?
-  const importTypeText = {
-    name: "jsenv:import_type_text",
-    appliesDuring: "*",
-    finalize: ({ url, contentType, content }) => {
-      if (!new URL(url).searchParams.has("text_module")) {
-        return null
-      }
-      if (ContentType.isTextual(contentType)) {
-        throw new Error(
-          `Unexpected content type on ${url}, should be "text/*" but got ${contentType}`,
-        )
-      }
-      return convertTextToJavascriptModule({
-        content,
-      })
-    },
-  }
-
-  return [
-    importAssertions,
-    importTypeJson,
-    jsenvPluginImportTypeCss(),
-    importTypeText,
-  ]
-}
-
-const jsenvPluginImportTypeCss = () => {
-  const inlineContentClientFileUrl = new URL(
-    "../inline/client/inline_content.js",
-    import.meta.url,
-  ).href
-
-  return {
-    name: "jsenv:import_type_css",
-    appliesDuring: "*",
-    // load the original css url
-    load: ({ data }, { urlGraph, load }) => {
-      if (data.importType !== "css_module") {
-        return null
-      }
-      return load({
-        reference: data.originalReference,
-        urlInfo: urlGraph.getUrlInfo(data.originalReference.url),
-      })
-    },
-    transform: ({ url, data, contentType, content }, { referenceUtils }) => {
-      if (data.importType !== "css_module") {
-        return null
-      }
-      if (contentType !== "text/css") {
-        throw new Error(
-          `Unexpected content type on ${url}, should be "text/css" but got ${contentType}`,
-        )
-      }
-      const [reference] = referenceUtils.inject({
-        type: "js_import_export",
-        specifier: inlineContentClientFileUrl,
-      })
-      const cssText = JS_QUOTES.escapeSpecialChars(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
-        // and convert template strings into raw strings
-        canUseTemplateString: true,
-      })
-      return {
-        type: "js_module",
-        contentType: "application/javascript",
-        content: `import { InlineContent } from ${reference.generatedSpecifier}
-
-const css = new InlineContent(${cssText}, { type: "text/css" })
-const stylesheet = new CSSStyleSheet()
-stylesheet.replaceSync(css.text)
-export default stylesheet`,
-      }
-    },
-  }
-}
-
-const getImportTypesToHandle = ({ scenario, isSupportedOnRuntime }) => {
-  // 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
-  if (scenario === "build") {
-    return ["json", "css", "text"]
-  }
-  const importTypes = []
-  if (!isSupportedOnRuntime("import_type_json")) {
-    importTypes.push("json")
-  }
-  if (!isSupportedOnRuntime("import_type_css")) {
-    importTypes.push("css")
-  }
-  if (!isSupportedOnRuntime("import_type_text")) {
-    importTypes.push("text")
-  }
-  return importTypes
-}

package/src/omega/core_plugins/inline/jsenv_plugin_inline.js

@@ -1,13 +0,0 @@
-import { jsenvPluginJsAndCssInsideHtml } from "./jsenv_plugin_js_and_css_inside_html.js"
-import { jsenvPluginNewInlineContent } from "./jsenv_plugin_new_inline_content.js"
-import { jsenvPluginDataUrls } from "./jsenv_plugin_data_urls.js"
-import { jsenvPluginInlineQueryParam } from "./jsenv_plugin_inline_query_param.js"
-
-export const jsenvPluginInline = ({ allowEscapeForVersioning } = {}) => {
-  return [
-    jsenvPluginJsAndCssInsideHtml(),
-    jsenvPluginNewInlineContent({ allowEscapeForVersioning }),
-    jsenvPluginDataUrls(),
-    jsenvPluginInlineQueryParam(),
-  ]
-}