@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/compile_server/js/babel_plugin_replace_expressions.js

@@ -1,101 +0,0 @@
-// heavily inspired from https://github.com/jviide/babel-plugin-transform-replace-expressions
-// last known commit: 57b608e0eeb8807db53d1c68292621dfafb5599c
-
-export const babelPluginReplaceExpressions = (api, options) => {
-  const { traverse, parse, types } = api
-  const { replaceMap = {}, allowConflictingReplacements = false } = options
-
-  const replacementMap = new Map()
-  const valueExpressionSet = new Set()
-
-  return {
-    name: "transform-replace-expressions",
-
-    pre: (state) => {
-      // https://github.com/babel/babel/blob/d50e78d45b608f6e0f6cc33aeb22f5db5027b153/packages/babel-traverse/src/path/replacement.js#L93
-      const parseExpression = (value) => {
-        const expressionNode = parse(value, state.opts).program.body[0]
-          .expression
-        traverse.removeProperties(expressionNode)
-        return expressionNode
-      }
-
-      Object.keys(replaceMap).forEach((key) => {
-        const keyExpressionNode = parseExpression(key)
-        const candidateArray = replacementMap.get(keyExpressionNode.type) || []
-        const value = replaceMap[key]
-        const valueExpressionNode = parseExpression(value)
-
-        const equivalentKeyExpressionIndex = candidateArray.findIndex(
-          (candidate) =>
-            types.isNodesEquivalent(
-              candidate.keyExpressionNode,
-              keyExpressionNode,
-            ),
-        )
-        if (
-          !allowConflictingReplacements &&
-          equivalentKeyExpressionIndex > -1
-        ) {
-          throw new Error(
-            `Expressions ${candidateArray[equivalentKeyExpressionIndex].key} and ${key} conflict`,
-          )
-        }
-
-        const newCandidate = {
-          key,
-          value,
-          keyExpressionNode,
-          valueExpressionNode,
-        }
-        if (equivalentKeyExpressionIndex > -1) {
-          candidateArray[equivalentKeyExpressionIndex] = newCandidate
-        } else {
-          candidateArray.push(newCandidate)
-        }
-        replacementMap.set(keyExpressionNode.type, candidateArray)
-      })
-
-      replacementMap.forEach((candidateArray) => {
-        candidateArray.forEach((candidate) => {
-          valueExpressionSet.add(candidate.valueExpressionNode)
-        })
-      })
-    },
-    visitor: {
-      Expression(path) {
-        if (valueExpressionSet.has(path.node)) {
-          path.skip()
-          return
-        }
-
-        const candidateArray = replacementMap.get(path.node.type)
-        if (!candidateArray) {
-          return
-        }
-
-        const candidateFound = candidateArray.find((candidate) => {
-          return types.isNodesEquivalent(candidate.keyExpressionNode, path.node)
-        })
-        if (candidateFound) {
-          try {
-            types.validate(
-              path.parent,
-              path.key,
-              candidateFound.valueExpressionNode,
-            )
-          } catch (err) {
-            if (!(err instanceof TypeError)) {
-              throw err
-            }
-            path.skip()
-            return
-          }
-
-          path.replaceWith(candidateFound.valueExpressionNode)
-          return
-        }
-      },
-    },
-  }
-}

package/src/internal/compile_server/js/babel_plugin_systemjs_prepend.js

@@ -1,23 +0,0 @@
-import { readFileSync } from "node:fs"
-
-import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/jsenv_file_urls.js"
-
-export const babelPluginSystemJsPrepend = (api) => {
-  api.assertVersion(7)
-  const systemJsUrl = new URL(
-    "src/internal/runtime_client/s.js",
-    jsenvCoreDirectoryUrl,
-  )
-  return {
-    name: "systemjs-prepend",
-    visitor: {
-      Program: {
-        exit(path) {
-          const code = String(readFileSync(systemJsUrl))
-          const ast = api.template.ast`${code}`
-          path.node.body.unshift(ast)
-        },
-      },
-    },
-  }
-}

package/src/internal/compile_server/js/babel_plugin_transform_import_meta.js

@@ -1,134 +0,0 @@
-// https://github.com/jamiebuilds/babel-handbook/blob/master/translations/en/plugin-handbook.md#toc-stages-of-babel
-// https://github.com/cfware/babel-plugin-bundled-import-meta/blob/master/index.js
-// https://github.com/babel/babel/blob/f4edf62f6beeab8ae9f2b7f0b82f1b3b12a581af/packages/babel-helper-module-imports/src/index.js#L7
-
-import { require } from "@jsenv/core/src/internal/require.js"
-
-import { createParseError } from "./babel_parse_error.js"
-
-export const babelPluginTransformImportMeta = (api, { importMetaFormat }) => {
-  const {
-    addNamespace,
-    addDefault,
-    addNamed,
-  } = require("@babel/helper-module-imports")
-  let babelState
-  const jsValueToAst = (jsValue) => {
-    const { parseExpression } = require("@babel/parser")
-    const valueAst = parseExpression(jsValue, babelState.parserOpts)
-    return valueAst
-  }
-  const visitImportMetaProperty = ({
-    importMetaPropertyName,
-    replaceWithImport,
-    replaceWithValue,
-  }) => {
-    if (importMetaFormat === "esmodule") {
-      // keep native version
-      return
-    }
-    if (importMetaFormat === "systemjs") {
-      // systemjs will handle it
-      return
-    }
-    if (importMetaFormat === "commonjs") {
-      if (importMetaPropertyName === "url") {
-        replaceWithImport({
-          from: `@jsenv/core/helpers/import-meta/import-meta-url-commonjs.js`,
-        })
-        return
-      }
-      if (importMetaPropertyName === "resolve") {
-        throw createParseError({
-          message: `import.meta.resolve() not supported with commonjs format`,
-        })
-      }
-      replaceWithValue(undefined)
-      return
-    }
-    if (importMetaFormat === "global") {
-      if (importMetaPropertyName === "url") {
-        replaceWithImport({
-          from: `@jsenv/core/helpers/import-meta/import-meta-url-global.js`,
-        })
-        return
-      }
-      if (importMetaPropertyName === "resolve") {
-        throw createParseError({
-          message: `import.meta.resolve() not supported with global format`,
-        })
-      }
-      replaceWithValue(undefined)
-      return
-    }
-  }
-
-  return {
-    name: "transform-import-meta",
-
-    pre: (state) => {
-      babelState = state
-    },
-
-    visitor: {
-      Program(programPath) {
-        const metaPropertyPathMap = {}
-        programPath.traverse({
-          MemberExpression(path) {
-            const { node } = path
-            const { object } = node
-            if (object.type !== "MetaProperty") {
-              return
-            }
-            const { property: objectProperty } = object
-            if (objectProperty.name !== "meta") {
-              return
-            }
-            const { property } = node
-            const { name } = property
-            if (name in metaPropertyPathMap) {
-              metaPropertyPathMap[name].push(path)
-            } else {
-              metaPropertyPathMap[name] = [path]
-            }
-          },
-        })
-        Object.keys(metaPropertyPathMap).forEach((importMetaPropertyName) => {
-          visitImportMetaProperty({
-            importMetaPropertyName,
-            replaceWithImport: ({ namespace, name, from, nameHint }) => {
-              let importAst
-              if (namespace) {
-                importAst = addNamespace(programPath, from, {
-                  nameHint,
-                })
-              } else if (name) {
-                importAst = addNamed(programPath, name, from)
-              } else {
-                importAst = addDefault(programPath, from, {
-                  nameHint,
-                })
-              }
-              metaPropertyPathMap[importMetaPropertyName].forEach((path) => {
-                path.replaceWith(importAst)
-              })
-            },
-            replaceWithValue: (value) => {
-              const valueAst = jsValueToAst(
-                // eslint-disable-next-line no-nested-ternary
-                value === undefined
-                  ? "undefined"
-                  : value === null
-                  ? "null"
-                  : JSON.stringify(value),
-              )
-              metaPropertyPathMap[importMetaPropertyName].forEach((path) => {
-                path.replaceWith(valueAst)
-              })
-            },
-          })
-        })
-      },
-    },
-  }
-}

package/src/internal/compile_server/js/babel_plugins.js

@@ -1,37 +0,0 @@
-import { require } from "@jsenv/core/src/internal/require.js"
-
-export const getMinimalBabelPluginMap = () => {
-  const syntaxDynamicImport = require("@babel/plugin-syntax-dynamic-import")
-  const syntaxImportMeta = require("@babel/plugin-syntax-import-meta")
-  const syntaxNumericSeparator = require("@babel/plugin-syntax-numeric-separator")
-  const syntaxImportAssertions = require("@babel/plugin-syntax-import-assertions")
-
-  return {
-    "syntax-dynamic-import": syntaxDynamicImport,
-    "syntax-import-meta": syntaxImportMeta,
-    "syntax-numeric-separator": syntaxNumericSeparator,
-    "synyax-import-assertions": syntaxImportAssertions,
-  }
-}
-
-export const extractSyntaxBabelPluginMap = (babelPluginMap) => {
-  const babelSyntaxPluginMap = {}
-  const babelPluginMapWithoutSyntax = {}
-  Object.keys(babelPluginMap).forEach((key) => {
-    if (key.startsWith("syntax-")) {
-      babelSyntaxPluginMap[key] = babelPluginMap[key]
-    } else {
-      babelPluginMapWithoutSyntax[key] = babelPluginMap[key]
-    }
-  })
-  return {
-    babelSyntaxPluginMap,
-    babelPluginMapWithoutSyntax,
-  }
-}
-
-export const babelPluginsFromBabelPluginMap = (babelPluginMap) => {
-  return Object.keys(babelPluginMap).map(
-    (babelPluginName) => babelPluginMap[babelPluginName],
-  )
-}

package/src/internal/compile_server/js/generateBabelHelper.js

@@ -1,36 +0,0 @@
-import { require } from "@jsenv/core/src/internal/require.js"
-
-export const generateBabelHelper = (name) => {
-  const { buildExternalHelpers } = require("@babel/core")
-  const { getDependencies } = require("@babel/helpers")
-
-  const helpersToBuild = [name]
-
-  /**
-   * we have to ensure we generate helper dependencies too because
-   * some helper contains import like
-   * import "setPrototypeOf"
-   * and babel deletes them somehow during buildExternalHelpers
-   *
-   * To fix that we could for instance extract babel helpers into
-   * actual files like we already do for global-this
-   * or regenerator-runtime
-   *
-   * But it means every babel update means updating thoose files too.
-   * for now let's keep it like that
-   */
-
-  const ensureDependencies = (name) => {
-    const dependencies = getDependencies(name)
-    dependencies.forEach((name) => {
-      if (helpersToBuild.includes(name)) {
-        return
-      }
-      helpersToBuild.push(name)
-      ensureDependencies(name)
-    })
-  }
-  ensureDependencies(name)
-
-  return buildExternalHelpers(helpersToBuild, "module")
-}

package/src/internal/compile_server/js/js_transformer.js

@@ -1,195 +0,0 @@
-import { urlToRelativeUrl, urlToFileSystemPath } from "@jsenv/filesystem"
-
-import { require } from "@jsenv/core/src/internal/require.js"
-import { ansiToHTML } from "./ansi_to_html.js"
-import { createParseError } from "./babel_parse_error.js"
-import {
-  getMinimalBabelPluginMap,
-  babelPluginsFromBabelPluginMap,
-} from "./babel_plugins.js"
-import { babelHelperNameFromUrl } from "./babelHelper.js"
-import { babelPluginBabelHelpersAsJsenvImports } from "./babel_plugin_babel_helpers_as_jsenv_imports.js"
-import { babelPluginRegeneratorRuntimeAsJsenvImport } from "./babel_plugin_regenerator_runtime_as_jsenv_import.js"
-import { babelPluginTransformImportMeta } from "./babel_plugin_transform_import_meta.js"
-import { babelPluginImportMetadata } from "./babel_plugin_import_metadata.js"
-import { babelPluginProxyExternalImports } from "./babel_plugin_proxy_external_imports.js"
-import { babelPluginSystemJsPrepend } from "./babel_plugin_systemjs_prepend.js"
-
-export const transformJs = async ({
-  projectDirectoryUrl,
-  jsenvRemoteDirectory,
-  url,
-
-  babelPluginMap,
-  moduleOutFormat = "esmodule",
-  importMetaFormat = moduleOutFormat,
-  babelHelpersInjectionAsImport = moduleOutFormat === "esmodule",
-  prependSystemJs,
-  topLevelAwait,
-  transformGenerator = true,
-  sourcemapEnabled = true,
-
-  map,
-  ast,
-  code,
-}) => {
-  if (typeof projectDirectoryUrl !== "string") {
-    throw new TypeError(
-      `projectDirectoryUrl must be a string, got ${projectDirectoryUrl}`,
-    )
-  }
-  if (typeof babelPluginMap !== "object") {
-    throw new TypeError(
-      `babelPluginMap must be an object, got ${babelPluginMap}`,
-    )
-  }
-  if (typeof code === "undefined") {
-    throw new TypeError(`code missing, received ${code}`)
-  }
-  if (typeof url !== "string") {
-    throw new TypeError(`url must be a string, got ${url}`)
-  }
-  if (babelHelpersInjectionAsImport && moduleOutFormat !== "esmodule") {
-    throw new Error(
-      `babelHelpersInjectionAsImport can be enabled only when "moduleOutFormat" is "esmodule"`,
-    )
-  }
-  const relativeUrl = url.startsWith(projectDirectoryUrl)
-    ? urlToRelativeUrl(url, projectDirectoryUrl)
-    : undefined
-
-  const inputPath = computeInputPath(url)
-  // https://babeljs.io/docs/en/options
-  const options = {
-    filename: inputPath,
-    filenameRelative: relativeUrl,
-    inputSourceMap: map,
-    configFile: false,
-    babelrc: false, // trust only these options, do not read any babelrc config file
-    ast: true,
-    sourceMaps: sourcemapEnabled,
-    sourceFileName: inputPath,
-    // https://babeljs.io/docs/en/options#parseropts
-    parserOpts: {
-      allowAwaitOutsideFunction:
-        topLevelAwait === undefined ||
-        topLevelAwait === "return" ||
-        topLevelAwait === "simple" ||
-        topLevelAwait === "ignore",
-    },
-    generatorOpts: {
-      compact: false,
-    },
-  }
-  const babelHelperName = babelHelperNameFromUrl(url)
-  // to prevent typeof circular dependency
-  if (babelHelperName === "typeof") {
-    const babelPluginMapWithoutTransformTypeOf = { ...babelPluginMap }
-    delete babelPluginMapWithoutTransformTypeOf["transform-typeof-symbol"]
-    babelPluginMap = babelPluginMapWithoutTransformTypeOf
-  }
-  if (transformGenerator) {
-    babelPluginMap = {
-      ...babelPluginMap,
-      "regenerator-runtime-as-jsenv-import": [
-        babelPluginRegeneratorRuntimeAsJsenvImport,
-      ],
-    }
-  }
-  babelPluginMap = {
-    ...getMinimalBabelPluginMap(),
-    "transform-import-meta": [
-      babelPluginTransformImportMeta,
-      { importMetaFormat },
-    ],
-    ...babelPluginMap,
-    ...(babelHelpersInjectionAsImport
-      ? {
-          "babel-helpers-as-jsenv-imports": [
-            babelPluginBabelHelpersAsJsenvImports,
-          ],
-        }
-      : {}),
-    ...(jsenvRemoteDirectory
-      ? {
-          "proxy-external-imports": [
-            babelPluginProxyExternalImports,
-            { jsenvRemoteDirectory },
-          ],
-        }
-      : {}),
-    "import-metadata": [babelPluginImportMetadata],
-  }
-  if (moduleOutFormat === "systemjs") {
-    const transformModulesSystemJs = require("@babel/plugin-transform-modules-systemjs")
-    const proposalDynamicImport = require("@babel/plugin-proposal-dynamic-import")
-    babelPluginMap = {
-      ...babelPluginMap,
-      "proposal-dynamic-import": [proposalDynamicImport],
-      "transform-modules-systemjs": [transformModulesSystemJs],
-    }
-  }
-  if (prependSystemJs) {
-    babelPluginMap = {
-      ...babelPluginMap,
-      "systemjs-prepend": [babelPluginSystemJsPrepend],
-    }
-  }
-
-  const asyncToPromise = babelPluginMap["transform-async-to-promises"]
-  if (topLevelAwait && asyncToPromise) {
-    asyncToPromise.options.topLevelAwait = topLevelAwait
-  }
-  const babelTransformReturnValue = await babelTransform({
-    ast,
-    code,
-    options: {
-      ...options,
-      plugins: babelPluginsFromBabelPluginMap(babelPluginMap),
-    },
-  })
-  code = babelTransformReturnValue.code
-  map = babelTransformReturnValue.map
-  ast = babelTransformReturnValue.ast
-  const { metadata } = babelTransformReturnValue
-  return { code, map, metadata, ast }
-}
-
-const computeInputPath = (url) => {
-  if (url.startsWith("file://")) {
-    return urlToFileSystemPath(url)
-  }
-  return url
-}
-
-const babelTransform = async ({ ast, code, options }) => {
-  const { transformAsync, transformFromAstAsync } = await import("@babel/core")
-
-  try {
-    if (ast) {
-      const result = await transformFromAstAsync(ast, code, options)
-      return result
-    }
-    return await transformAsync(code, options)
-  } catch (error) {
-    if (error && error.code === "BABEL_PARSE_ERROR") {
-      const message = error.message
-      const messageWithoutAnsi = message.replace(ansiRegex, "")
-      throw createParseError({
-        cause: error,
-        message: messageWithoutAnsi,
-        messageHTML: ansiToHTML(message),
-        filename: options.filename,
-        lineNumber: error.loc.line,
-        columnNumber: error.loc.column,
-      })
-    }
-    throw error
-  }
-}
-
-const pattern = [
-  "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
-  "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))",
-].join("|")
-const ansiRegex = new RegExp(pattern, "g")

package/src/internal/compile_server/js/jsenv_compile_js.js

@@ -1,62 +0,0 @@
-import { generateSourcemapUrl } from "@jsenv/core/src/internal/sourcemap_utils.js"
-
-import { asCompilationResult } from "@jsenv/core/src/internal/compile_server/jsenv_directory/compilation_result.js"
-
-import { transformJs } from "./js_transformer.js"
-
-export const compileJavascript = async ({
-  projectDirectoryUrl,
-  jsenvRemoteDirectory,
-  url,
-  compiledUrl,
-
-  compileProfile,
-  babelPluginMap,
-  topLevelAwait,
-  prependSystemJs,
-
-  code,
-  map,
-  sourcemapExcludeSources,
-  sourcemapMethod,
-}) => {
-  if (prependSystemJs === undefined) {
-    const { searchParams } = new URL(url)
-    prependSystemJs =
-      searchParams.has("worker") || searchParams.has("service_worker")
-  }
-  const transformResult = await transformJs({
-    projectDirectoryUrl,
-    jsenvRemoteDirectory,
-    url,
-    compiledUrl,
-
-    babelPluginMap,
-    moduleOutFormat: compileProfile.moduleOutFormat,
-    topLevelAwait,
-    prependSystemJs,
-
-    code,
-    map,
-  })
-  return asCompilationResult(
-    {
-      contentType: "application/javascript",
-      metadata: transformResult.metadata,
-      code: transformResult.code,
-      map: transformResult.map,
-    },
-    {
-      projectDirectoryUrl,
-      jsenvRemoteDirectory,
-      originalFileUrl: url,
-      compiledFileUrl: compiledUrl,
-      // sourcemap are not inside the asset folder because
-      // of https://github.com/microsoft/vscode-chrome-debug-core/issues/544
-      sourcemapFileUrl: generateSourcemapUrl(compiledUrl),
-      sourcemapExcludeSources,
-      sourcemapMethod,
-      originalFileContent: code,
-    },
-  )
-}

package/src/internal/compile_server/js/load_babel_plugin_map_from_file.js

@@ -1,49 +0,0 @@
-import {
-  isFileSystemPath,
-  fileSystemPathToUrl,
-  urlToFileSystemPath,
-} from "@jsenv/filesystem"
-
-export const loadBabelPluginMapFromFile = async ({
-  projectDirectoryUrl,
-  babelConfigFileUrl,
-}) => {
-  const babelOptions = await loadBabelOptionsFromFile({
-    projectDirectoryUrl,
-    babelConfigFileUrl,
-  })
-
-  const babelPluginMap = {}
-  babelOptions.plugins.forEach((plugin) => {
-    const babelPluginName = babelPluginNameFromPlugin(plugin)
-    babelPluginMap[babelPluginName] = plugin
-  })
-
-  return babelPluginMap
-}
-
-const loadBabelOptionsFromFile = async ({
-  projectDirectoryUrl,
-  babelConfigFileUrl,
-}) => {
-  const { loadOptionsAsync } = await import("@babel/core")
-  const babelOptions = await loadOptionsAsync({
-    cwd: urlToFileSystemPath(projectDirectoryUrl),
-    configFile: babelConfigFileUrl
-      ? urlToFileSystemPath(babelConfigFileUrl)
-      : undefined,
-  })
-  return babelOptions
-}
-
-const babelPluginNameFromPlugin = ({ key }) => {
-  if (
-    isFileSystemPath(key) &&
-    fileSystemPathToUrl(key).endsWith(
-      "babel-plugin-transform-async-to-promises/async-to-promises.js",
-    )
-  ) {
-    return "transform-async-to-promises"
-  }
-  return key
-}

package/src/internal/compile_server/jsenv_directory/comparison_utils.js

@@ -1,27 +0,0 @@
-export const sameValueInTwoObjects = (object, secondObject) => {
-  const objectKeys = Object.keys(object)
-  const secondObjectKeys = Object.keys(secondObject)
-  if (!sameValuesInTwoArrays(objectKeys, secondObjectKeys)) {
-    return false
-  }
-  return objectKeys.every((key) => {
-    const objectKeyValue = object[key]
-    const secondObjectKeyValue = secondObject[key]
-    if (
-      typeof objectKeyValue === "object" &&
-      objectKeyValue !== null &&
-      typeof secondObjectKeyValue === "object" &&
-      secondObjectKeyValue !== null
-    ) {
-      return sameValueInTwoObjects(objectKeyValue, secondObjectKeyValue)
-    }
-    return objectKeyValue === secondObjectKeyValue
-  })
-}
-
-export const sameValuesInTwoArrays = (array, secondArray) => {
-  return (
-    array.length === secondArray.length &&
-    array.every((value) => secondArray.includes(value))
-  )
-}