@jsenv/core 29.9.1 → 30.0.0-alpha.1

package/src/plugins/bundling/js_module/bundle_js_modules.js

@@ -1,424 +0,0 @@
-import { pathToFileURL } from "node:url"
-
-import { URL_META } from "@jsenv/url-meta"
-import { isFileSystemPath } from "@jsenv/urls"
-import { createDetailedMessage } from "@jsenv/log"
-import { babelHelperNameFromUrl } from "@jsenv/babel-plugins"
-import { sourcemapConverter } from "@jsenv/sourcemap"
-
-import { fileUrlConverter } from "@jsenv/core/src/kitchen/file_url_converter.js"
-
-const globalThisClientFileUrl = new URL(
-  "../../transpilation/babel/global_this/client/global_this.js",
-  import.meta.url,
-).href
-const newStylesheetClientFileUrl = new URL(
-  "../../transpilation/babel/new_stylesheet/client/new_stylesheet.js",
-  import.meta.url,
-).href
-const regeneratorRuntimeClientFileUrl = new URL(
-  "../../transpilation/babel/regenerator_runtime/client/regenerator_runtime.js",
-  import.meta.url,
-).href
-
-export const bundleJsModules = async ({
-  jsModuleUrlInfos,
-  context,
-  options,
-}) => {
-  const {
-    signal,
-    logger,
-    rootDirectoryUrl,
-    buildDirectoryUrl,
-    assetsDirectory,
-    urlGraph,
-    runtimeCompat,
-    sourcemaps,
-  } = context
-  const {
-    babelHelpersChunk = true,
-    include,
-    preserveDynamicImport = false,
-    strictExports = false,
-  } = options
-  const { jsModuleBundleUrlInfos } = await buildWithRollup({
-    signal,
-    logger,
-    rootDirectoryUrl,
-    buildDirectoryUrl,
-    assetsDirectory,
-    urlGraph,
-    jsModuleUrlInfos,
-
-    runtimeCompat,
-    sourcemaps,
-
-    include,
-    babelHelpersChunk,
-    preserveDynamicImport,
-    strictExports,
-  })
-  return jsModuleBundleUrlInfos
-}
-
-const rollupPluginJsenv = ({
-  // logger,
-  rootDirectoryUrl,
-  buildDirectoryUrl,
-  assetsDirectory,
-  urlGraph,
-  jsModuleUrlInfos,
-  sourcemaps,
-
-  include,
-  babelHelpersChunk,
-  preserveDynamicImport,
-  strictExports,
-
-  resultRef,
-}) => {
-  let _rollupEmitFile = () => {
-    throw new Error("not implemented")
-  }
-  const format = jsModuleUrlInfos.some((jsModuleUrlInfo) =>
-    jsModuleUrlInfo.filename.endsWith(".cjs"),
-  )
-    ? "cjs"
-    : "esm"
-  const emitChunk = (chunk) => {
-    return _rollupEmitFile({
-      type: "chunk",
-      ...chunk,
-    })
-  }
-  let importCanBeBundled = () => true
-  if (include) {
-    const associations = URL_META.resolveAssociations(
-      { bundle: include },
-      rootDirectoryUrl,
-    )
-    importCanBeBundled = (url) => {
-      return URL_META.applyAssociations({ url, associations }).bundle
-    }
-  }
-  const urlImporters = {}
-
-  return {
-    name: "jsenv",
-    async buildStart() {
-      _rollupEmitFile = (...args) => this.emitFile(...args)
-      let previousNonEntryPointModuleId
-      jsModuleUrlInfos.forEach((jsModuleUrlInfo) => {
-        const id = jsModuleUrlInfo.url
-        if (jsModuleUrlInfo.isEntryPoint) {
-          emitChunk({
-            id,
-          })
-          return
-        }
-        emitChunk({
-          id,
-          implicitlyLoadedAfterOneOf: previousNonEntryPointModuleId
-            ? [previousNonEntryPointModuleId]
-            : null,
-          preserveSignature: strictExports
-            ? "strict"
-            : jsModuleUrlInfo.dependents.size < 2
-            ? "allow-extension"
-            : "strict",
-        })
-        previousNonEntryPointModuleId = id
-      })
-    },
-    async generateBundle(outputOptions, rollupResult) {
-      _rollupEmitFile = (...args) => this.emitFile(...args)
-
-      const jsModuleBundleUrlInfos = {}
-      Object.keys(rollupResult).forEach((fileName) => {
-        const rollupFileInfo = rollupResult[fileName]
-        // there is 3 types of file: "placeholder", "asset", "chunk"
-        if (rollupFileInfo.type === "chunk") {
-          const sourceUrls = Object.keys(rollupFileInfo.modules).map((id) =>
-            fileUrlConverter.asFileUrl(id),
-          )
-
-          let url
-          let originalUrl
-          if (rollupFileInfo.facadeModuleId) {
-            url = fileUrlConverter.asFileUrl(rollupFileInfo.facadeModuleId)
-            originalUrl = url
-          } else {
-            url = new URL(rollupFileInfo.fileName, buildDirectoryUrl).href
-            if (rollupFileInfo.isDynamicEntry) {
-              originalUrl = sourceUrls[sourceUrls.length - 1]
-            } else {
-              originalUrl = url
-            }
-          }
-
-          const jsModuleBundleUrlInfo = {
-            url,
-            originalUrl,
-            type: format === "esm" ? "js_module" : "common_js",
-            data: {
-              bundlerName: "rollup",
-              bundleRelativeUrl: rollupFileInfo.fileName,
-              usesImport:
-                rollupFileInfo.imports.length > 0 ||
-                rollupFileInfo.dynamicImports.length > 0,
-              isDynamicEntry: rollupFileInfo.isDynamicEntry,
-            },
-            sourceUrls,
-            contentType: "text/javascript",
-            content: rollupFileInfo.code,
-            sourcemap: rollupFileInfo.map,
-          }
-          jsModuleBundleUrlInfos[url] = jsModuleBundleUrlInfo
-        }
-      })
-      resultRef.current = {
-        jsModuleBundleUrlInfos,
-      }
-    },
-    outputOptions: (outputOptions) => {
-      // const sourcemapFile = buildDirectoryUrl
-      Object.assign(outputOptions, {
-        format,
-        dir: fileUrlConverter.asFilePath(buildDirectoryUrl),
-        sourcemap: sourcemaps === "file" || sourcemaps === "inline",
-        // sourcemapFile,
-        sourcemapPathTransform: (relativePath) => {
-          return new URL(relativePath, buildDirectoryUrl).href
-        },
-        entryFileNames: () => {
-          return `[name].js`
-        },
-        chunkFileNames: (chunkInfo) => {
-          const insideJs = willBeInsideJsDirectory({
-            chunkInfo,
-            fileUrlConverter,
-            jsModuleUrlInfos,
-          })
-          let nameFromUrlInfo
-          if (chunkInfo.facadeModuleId) {
-            const url = fileUrlConverter.asFileUrl(chunkInfo.facadeModuleId)
-            const urlInfo = jsModuleUrlInfos.find(
-              (jsModuleUrlInfo) => jsModuleUrlInfo.url === url,
-            )
-            if (urlInfo) {
-              nameFromUrlInfo = urlInfo.filename
-            }
-          }
-          const name = nameFromUrlInfo || `${chunkInfo.name}.js`
-          return insideJs ? `${assetsDirectory}js/${name}` : `${name}`
-        },
-        manualChunks: (id) => {
-          if (babelHelpersChunk) {
-            const fileUrl = fileUrlConverter.asFileUrl(id)
-            if (
-              fileUrl.endsWith(
-                "babel-plugin-transform-async-to-promises/helpers.mjs",
-              )
-            ) {
-              return "babel_helpers"
-            }
-            if (babelHelperNameFromUrl(fileUrl)) {
-              return "babel_helpers"
-            }
-            if (fileUrl === globalThisClientFileUrl) {
-              return "babel_helpers"
-            }
-            if (fileUrl === newStylesheetClientFileUrl) {
-              return "babel_helpers"
-            }
-            if (fileUrl === regeneratorRuntimeClientFileUrl) {
-              return "babel_helpers"
-            }
-          }
-          return null
-        },
-        // https://rollupjs.org/guide/en/#outputpaths
-        // paths: (id) => {
-        //   return id
-        // },
-      })
-    },
-    // https://rollupjs.org/guide/en/#resolvedynamicimport
-    resolveDynamicImport: (specifier, importer) => {
-      if (preserveDynamicImport) {
-        let urlObject
-        if (specifier[0] === "/") {
-          urlObject = new URL(specifier.slice(1), rootDirectoryUrl)
-        } else {
-          if (isFileSystemPath(importer)) {
-            importer = fileUrlConverter.asFileUrl(importer)
-          }
-          urlObject = new URL(specifier, importer)
-        }
-        urlObject.searchParams.set("as_js_classic_library", "")
-        return { external: true, id: urlObject.href }
-      }
-      return null
-    },
-    resolveId: (specifier, importer = rootDirectoryUrl) => {
-      if (isFileSystemPath(importer)) {
-        importer = fileUrlConverter.asFileUrl(importer)
-      }
-      let url
-      if (specifier[0] === "/") {
-        url = new URL(specifier.slice(1), rootDirectoryUrl).href
-      } else {
-        url = new URL(specifier, importer).href
-      }
-      const existingImporter = urlImporters[url]
-      if (!existingImporter) {
-        urlImporters[url] = importer
-      }
-      if (!url.startsWith("file:")) {
-        return { id: url, external: true }
-      }
-      if (!importCanBeBundled(url)) {
-        return { id: url, external: true }
-      }
-      const urlInfo = urlGraph.getUrlInfo(url)
-      if (!urlInfo) {
-        // happen when excluded by urlAnalysis.include
-        return { id: url, external: true }
-      }
-      if (!urlInfo.shouldHandle) {
-        return { id: url, external: true }
-      }
-      const filePath = fileUrlConverter.asFilePath(url)
-      return filePath
-    },
-    async load(rollupId) {
-      const fileUrl = fileUrlConverter.asFileUrl(rollupId)
-      const urlInfo = urlGraph.getUrlInfo(fileUrl)
-      return {
-        code: urlInfo.content,
-        map:
-          (sourcemaps === "file" || sourcemaps === "inline") &&
-          urlInfo.sourcemap
-            ? sourcemapConverter.toFilePaths(urlInfo.sourcemap)
-            : null,
-      }
-    },
-  }
-}
-
-const buildWithRollup = async ({
-  signal,
-  logger,
-  rootDirectoryUrl,
-  buildDirectoryUrl,
-  assetsDirectory,
-  urlGraph,
-  jsModuleUrlInfos,
-
-  runtimeCompat,
-  sourcemaps,
-
-  include,
-  babelHelpersChunk,
-  preserveDynamicImport,
-}) => {
-  const resultRef = { current: null }
-  try {
-    await applyRollupPlugins({
-      rollupPlugins: [
-        rollupPluginJsenv({
-          signal,
-          logger,
-          rootDirectoryUrl,
-          buildDirectoryUrl,
-          assetsDirectory,
-          urlGraph,
-          jsModuleUrlInfos,
-
-          runtimeCompat,
-          sourcemaps,
-          include,
-          babelHelpersChunk,
-          preserveDynamicImport,
-          resultRef,
-        }),
-      ],
-      inputOptions: {
-        input: [],
-        onwarn: (warning) => {
-          if (warning.code === "CIRCULAR_DEPENDENCY") {
-            return
-          }
-          if (
-            warning.code === "THIS_IS_UNDEFINED" &&
-            pathToFileURL(warning.id).href === globalThisClientFileUrl
-          ) {
-            return
-          }
-          if (warning.code === "EVAL") {
-            // ideally we should disable only for jsenv files
-            return
-          }
-          logger.warn(String(warning))
-        },
-      },
-    })
-    return resultRef.current
-  } catch (e) {
-    if (e.code === "MISSING_EXPORT") {
-      const detailedMessage = createDetailedMessage(e.message, {
-        frame: e.frame,
-      })
-      throw new Error(detailedMessage, { cause: e })
-    }
-    throw e
-  }
-}
-
-const applyRollupPlugins = async ({
-  rollupPlugins,
-  inputOptions = {},
-  outputOptions = {},
-}) => {
-  const { rollup } = await import("rollup")
-  const { importAssertions } = await import("acorn-import-assertions")
-  const rollupReturnValue = await rollup({
-    ...inputOptions,
-    plugins: rollupPlugins,
-    acornInjectPlugins: [
-      importAssertions,
-      ...(inputOptions.acornInjectPlugins || []),
-    ],
-  })
-  const rollupOutputArray = await rollupReturnValue.generate(outputOptions)
-  return rollupOutputArray
-}
-
-const willBeInsideJsDirectory = ({
-  chunkInfo,
-  fileUrlConverter,
-  jsModuleUrlInfos,
-}) => {
-  // if the chunk is generated dynamically by rollup
-  // for an entry point jsenv will put that file inside js/ directory
-  // if it's generated dynamically for a file already in js/ directory
-  // both will be inside the js/ directory
-  if (!chunkInfo.facadeModuleId) {
-    // generated by rollup
-    return true
-  }
-  const url = fileUrlConverter.asFileUrl(chunkInfo.facadeModuleId)
-  const jsModuleUrlInfo = jsModuleUrlInfos.find(
-    (jsModuleUrlInfo) => jsModuleUrlInfo.url === url,
-  )
-  if (!jsModuleUrlInfo) {
-    // generated by rollup
-    return true
-  }
-  if (!jsModuleUrlInfo.isEntryPoint) {
-    // not an entry point, jsenv will put it inside js/ directory
-    return true
-  }
-  return false
-}

package/src/plugins/bundling/jsenv_plugin_bundling.js

@@ -1,52 +0,0 @@
-import { bundleCss } from "./css/bundle_css.js"
-import { bundleJsClassicWorkers } from "./js_classic_workers/bundle_js_classic_workers.js"
-import { bundleJsModules } from "./js_module/bundle_js_modules.js"
-
-export const jsenvPluginBundling = (bundling) => {
-  if (typeof bundling === "boolean") {
-    bundling = {
-      css: bundling,
-      js_classic_workers: bundling,
-      js_module: bundling,
-    }
-  } else if (typeof bundling !== "object") {
-    throw new Error(`bundling must be a boolean or an object, got ${bundling}`)
-  }
-  Object.keys(bundling).forEach((key) => {
-    if (bundling[key] === true) bundling[key] = {}
-  })
-
-  return {
-    name: "jsenv:bundling",
-    appliesDuring: "build",
-    bundle: {
-      css: bundling.css
-        ? (cssUrlInfos, context) => {
-            return bundleCss({
-              cssUrlInfos,
-              context,
-              options: bundling.css,
-            })
-          }
-        : undefined,
-      js_classic: bundling.js_classic
-        ? (jsClassicUrlInfos, context) => {
-            return bundleJsClassicWorkers({
-              jsClassicUrlInfos,
-              context,
-              options: bundling.js_classic_workers,
-            })
-          }
-        : undefined,
-      js_module: bundling.js_module
-        ? (jsModuleUrlInfos, context) => {
-            return bundleJsModules({
-              jsModuleUrlInfos,
-              context,
-              options: bundling.js_module,
-            })
-          }
-        : undefined,
-    },
-  }
-}

package/src/plugins/minification/css/minify_css.js

@@ -1,9 +0,0 @@
-import { minifyWithParcel } from "@jsenv/ast"
-
-export const minifyCss = ({ cssUrlInfo, context }) => {
-  const { code, map } = minifyWithParcel(cssUrlInfo, context)
-  return {
-    content: String(code),
-    sourcemap: map,
-  }
-}

package/src/plugins/minification/html/minify_html.js

@@ -1,13 +0,0 @@
-import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
-
-// https://github.com/kangax/html-minifier#options-quick-reference
-export const minifyHtml = ({ htmlUrlInfo, options } = {}) => {
-  const { collapseWhitespace = true, removeComments = true } = options
-
-  const { minify } = requireFromJsenv("html-minifier")
-  const htmlMinified = minify(htmlUrlInfo.content, {
-    collapseWhitespace,
-    removeComments,
-  })
-  return htmlMinified
-}

package/src/plugins/minification/js/minify_js.js

@@ -1,31 +0,0 @@
-// https://github.com/terser-js/terser#minify-options
-
-export const minifyJs = async ({ jsUrlInfo, options }) => {
-  const url = jsUrlInfo.url
-  const content = jsUrlInfo.content
-  const sourcemap = jsUrlInfo.sourcemap
-  const isJsModule = jsUrlInfo.type === "js_module"
-
-  const { minify } = await import("terser")
-  const terserResult = await minify(
-    {
-      [url]: content,
-    },
-    {
-      sourceMap: {
-        ...(sourcemap ? { content: JSON.stringify(sourcemap) } : {}),
-        asObject: true,
-        includeSources: true,
-      },
-      module: isJsModule,
-      // We need to preserve "new InlineContent()" calls to be able to recognize them
-      // after minification in order to version urls inside inline content text
-      keep_fnames: /InlineContent/,
-      ...options,
-    },
-  )
-  return {
-    content: terserResult.code,
-    sourcemap: terserResult.map,
-  }
-}

package/src/plugins/minification/jsenv_plugin_minification.js

@@ -1,79 +0,0 @@
-import { minifyHtml } from "./html/minify_html.js"
-import { minifyCss } from "./css/minify_css.js"
-import { minifyJs } from "./js/minify_js.js"
-import { minifyJson } from "./json/minify_json.js"
-
-export const jsenvPluginMinification = (minification) => {
-  if (typeof minification === "boolean") {
-    minification = {
-      html: minification,
-      css: minification,
-      js_classic: minification,
-      js_module: minification,
-      json: minification,
-      svg: minification,
-    }
-  } else if (typeof minification !== "object") {
-    throw new Error(
-      `minification must be a boolean or an object, got ${minification}`,
-    )
-  }
-  Object.keys(minification).forEach((key) => {
-    if (minification[key] === true) minification[key] = {}
-  })
-  const htmlOptimizer = minification.html
-    ? (urlInfo, context) =>
-        minifyHtml({
-          htmlUrlInfo: urlInfo,
-          context,
-          options: minification.html,
-        })
-    : null
-  const jsonOptimizer = minification.json
-    ? (urlInfo, context) =>
-        minifyJson({
-          jsonUrlInfo: urlInfo,
-          context,
-          options: minification.json,
-        })
-    : null
-  const cssOptimizer = minification.css
-    ? (urlInfo, context) =>
-        minifyCss({
-          cssUrlInfo: urlInfo,
-          context,
-          options: minification.css,
-        })
-    : null
-  const jsClassicOptimizer = minification.js_classic
-    ? (urlInfo, context) =>
-        minifyJs({
-          jsUrlInfo: urlInfo,
-          context,
-          options: minification.js_classic,
-        })
-    : null
-  const jsModuleOptimizer = minification.js_module
-    ? (urlInfo, context) =>
-        minifyJs({
-          jsUrlInfo: urlInfo,
-          context,
-          options: minification.js_module,
-        })
-    : null
-
-  return {
-    name: "jsenv:minification",
-    appliesDuring: "build",
-    optimizeUrlContent: {
-      html: htmlOptimizer,
-      svg: htmlOptimizer,
-      css: cssOptimizer,
-      js_classic: jsClassicOptimizer,
-      js_module: jsModuleOptimizer,
-      json: jsonOptimizer,
-      importmap: jsonOptimizer,
-      webmanifest: jsonOptimizer,
-    },
-  }
-}

package/src/plugins/minification/json/minify_json.js

@@ -1,8 +0,0 @@
-export const minifyJson = ({ jsonUrlInfo }) => {
-  const { content } = jsonUrlInfo
-  if (content.startsWith("{\n")) {
-    const jsonWithoutWhitespaces = JSON.stringify(JSON.parse(content))
-    return jsonWithoutWhitespaces
-  }
-  return null
-}