@jsenv/core 27.0.0-alpha.6 → 27.0.0-alpha.60

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

@@ -0,0 +1,309 @@
+import {
+  isFileSystemPath,
+  normalizeStructuredMetaMap,
+  urlIsInsideOf,
+  urlToMeta,
+} from "@jsenv/filesystem"
+import { createDetailedMessage } from "@jsenv/logger"
+
+import { applyRollupPlugins } from "@jsenv/utils/js_ast/apply_rollup_plugins.js"
+import { sourcemapConverter } from "@jsenv/utils/sourcemap/sourcemap_converter.js"
+import { fileUrlConverter } from "@jsenv/core/src/omega/file_url_converter.js"
+import { babelHelperNameFromUrl } from "@jsenv/babel-plugins"
+
+const jsenvBabelPluginDirectoryUrl = new URL(
+  "../../transpilation/babel/",
+  import.meta.url,
+).href
+
+export const bundleJsModule = async ({
+  jsModuleUrlInfos,
+  context,
+  options,
+}) => {
+  const {
+    signal,
+    logger,
+    rootDirectoryUrl,
+    buildDirectoryUrl,
+    urlGraph,
+    runtimeCompat,
+    sourcemaps,
+  } = context
+  const { jsModuleBundleUrlInfos } = await buildWithRollup({
+    signal,
+    logger,
+    rootDirectoryUrl,
+    buildDirectoryUrl,
+    urlGraph,
+    jsModuleUrlInfos,
+
+    runtimeCompat,
+    sourcemaps,
+    options,
+  })
+  return jsModuleBundleUrlInfos
+}
+
+export const buildWithRollup = async ({
+  signal,
+  logger,
+  rootDirectoryUrl,
+  buildDirectoryUrl,
+  urlGraph,
+  jsModuleUrlInfos,
+
+  runtimeCompat,
+  sourcemaps,
+  options,
+}) => {
+  const resultRef = { current: null }
+  try {
+    await applyRollupPlugins({
+      rollupPlugins: [
+        rollupPluginJsenv({
+          signal,
+          logger,
+          rootDirectoryUrl,
+          buildDirectoryUrl,
+          urlGraph,
+          jsModuleUrlInfos,
+
+          runtimeCompat,
+          sourcemaps,
+          options,
+          resultRef,
+        }),
+      ],
+      inputOptions: {
+        input: [],
+        onwarn: (warning) => {
+          if (warning.code === "CIRCULAR_DEPENDENCY") {
+            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 rollupPluginJsenv = ({
+  // logger,
+  rootDirectoryUrl,
+  buildDirectoryUrl,
+  urlGraph,
+  jsModuleUrlInfos,
+  sourcemaps,
+  options,
+
+  resultRef,
+}) => {
+  let _rollupEmitFile = () => {
+    throw new Error("not implemented")
+  }
+  const emitChunk = (chunk) => {
+    return _rollupEmitFile({
+      type: "chunk",
+      ...chunk,
+    })
+  }
+  let importCanBeBundled = () => true
+  if (options.include) {
+    const bundleIncludeConfig = normalizeStructuredMetaMap(
+      {
+        bundle: options.include,
+      },
+      rootDirectoryUrl,
+    )
+    importCanBeBundled = (url) => {
+      return urlToMeta({
+        url,
+        structuredMetaMap: bundleIncludeConfig,
+      }).bundle
+    }
+  }
+  const urlImporters = {}
+
+  return {
+    name: "jsenv",
+    async buildStart() {
+      _rollupEmitFile = (...args) => this.emitFile(...args)
+      let previousNonEntryPointModuleId
+      jsModuleUrlInfos.forEach((jsModuleUrlInfo) => {
+        const id = jsModuleUrlInfo.url
+        if (jsModuleUrlInfo.data.isEntryPoint) {
+          emitChunk({
+            id,
+          })
+          return
+        }
+        emitChunk({
+          id,
+          implicitlyLoadedAfterOneOf: previousNonEntryPointModuleId
+            ? [previousNonEntryPointModuleId]
+            : null,
+          preserveSignature: "allow-extension",
+        })
+        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 jsModuleBundleUrlInfo = {
+            data: {
+              generatedBy: "rollup",
+              bundleRelativeUrl: rollupFileInfo.fileName,
+              usesImport:
+                rollupFileInfo.imports.length > 0 ||
+                rollupFileInfo.dynamicImports.length > 0,
+              usesExport: rollupFileInfo.exports.length > 0,
+            },
+            contentType: "text/javascript",
+            content: rollupFileInfo.code,
+            sourcemap: rollupFileInfo.map,
+          }
+          let url
+          if (rollupFileInfo.facadeModuleId) {
+            url = fileUrlConverter.asFileUrl(rollupFileInfo.facadeModuleId)
+          } else {
+            url = new URL(rollupFileInfo.fileName, buildDirectoryUrl).href
+          }
+          jsModuleBundleUrlInfos[url] = jsModuleBundleUrlInfo
+        }
+      })
+      resultRef.current = {
+        jsModuleBundleUrlInfos,
+      }
+    },
+    outputOptions: (outputOptions) => {
+      // const sourcemapFile = buildDirectoryUrl
+      Object.assign(outputOptions, {
+        format: "esm",
+        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 ? `js/${name}` : `${name}`
+        },
+        manualChunks: (id) => {
+          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 (urlIsInsideOf(fileUrl, jsenvBabelPluginDirectoryUrl)) {
+            return "babel_helpers"
+          }
+          return null
+        },
+        // https://rollupjs.org/guide/en/#outputpaths
+        // paths: (id) => {
+        //   return id
+        // },
+      })
+    },
+    resolveId: (specifier, importer = rootDirectoryUrl) => {
+      if (isFileSystemPath(importer)) {
+        importer = fileUrlConverter.asFileUrl(importer)
+      }
+      const 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 filePath = fileUrlConverter.asFilePath(url)
+      return filePath
+    },
+    async load(rollupId) {
+      const fileUrl = fileUrlConverter.asFileUrl(rollupId)
+      const urlInfo = urlGraph.getUrlInfo(fileUrl)
+      return {
+        code: urlInfo.content,
+        map: urlInfo.sourcemap
+          ? sourcemapConverter.toFilePaths(urlInfo.sourcemap)
+          : null,
+      }
+    },
+  }
+}
+
+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.data.isEntryPoint &&
+    !jsModuleUrlInfo.data.isWebWorkerEntryPoint
+  ) {
+    // not an entry point, jsenv will put it inside js/ directory
+    return true
+  }
+  return false
+}

package/src/plugins/bundling/jsenv_plugin_bundling.js

@@ -0,0 +1,54 @@
+import { bundleCss } from "./css/bundle_css.js"
+import { bundleJsClassicWorkers } from "./js_classic_workers/bundle_js_classic_workers.js"
+import { bundleJsModule } from "./js_module/bundle_js_module.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: true,
+    },
+    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 bundleJsModule({
+              jsModuleUrlInfos,
+              context,
+              options: bundling.js_module,
+            })
+          }
+        : undefined,
+    },
+  }
+}

package/src/plugins/cache_control/jsenv_plugin_cache_control.js

@@ -0,0 +1,34 @@
+export const jsenvPluginCacheControl = () => {
+  return {
+    name: "jsenv:cache_control",
+    appliesDuring: {
+      dev: true,
+      test: true,
+    },
+    augmentResponse: ({ reference }, context) => {
+      if (context.scenario === "dev") {
+        // During dev, all files are put into browser cache for 1 hour because:
+        // 1: Browser cache is a temporary directory created by playwright
+        // 2: We assume source files won't be modified while tests are running
+        return {
+          headers: {
+            "cache-control": `private,max-age=3600,immutable`,
+          },
+        }
+      }
+      if (
+        reference.searchParams.has("v") &&
+        !reference.searchParams.has("hmr")
+      ) {
+        return {
+          headers: {
+            "cache-control": `private,max-age=${SECONDS_IN_30_DAYS},immutable`,
+          },
+        }
+      }
+      return null
+    },
+  }
+}
+
+const SECONDS_IN_30_DAYS = 60 * 60 * 24 * 30

package/src/{omega/core_plugins → plugins}/commonjs_globals/jsenv_plugin_commonjs_globals.js

@@ -11,50 +11,63 @@ import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
 import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
 
 export const jsenvPluginCommonJsGlobals = () => {
+  const transformCommonJsGlobals = async (urlInfo, { scenario }) => {
+    if (
+      !urlInfo.content.includes("process.env.NODE_ENV") &&
+      !urlInfo.content.includes("__filename") &&
+      !urlInfo.content.includes("__dirname")
+    ) {
+      return null
+    }
+    const isJsModule = urlInfo.type === "js_module"
+    const replaceMap = {
+      "process.env.NODE_ENV": `("${
+        scenario === "dev" || scenario === "test" ? "dev" : "prod"
+      }")`,
+      "global": "globalThis",
+      "__filename": isJsModule
+        ? `import.meta.url.slice('file:///'.length)`
+        : `document.currentScript.src`,
+      "__dirname": isJsModule
+        ? `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`
+        : `new URL('./', document.currentScript.src).href`,
+    }
+    const { metadata } = await applyBabelPlugins({
+      babelPlugins: [
+        [
+          babelPluginMetadataExpressionPaths,
+          {
+            replaceMap,
+            allowConflictingReplacements: true,
+          },
+        ],
+      ],
+      urlInfo,
+    })
+    const { expressionPaths } = metadata
+    const keys = Object.keys(expressionPaths)
+    if (keys.length === 0) {
+      return null
+    }
+    const magicSource = createMagicSource(urlInfo.content)
+    keys.forEach((key) => {
+      expressionPaths[key].forEach((path) => {
+        magicSource.replace({
+          start: path.node.start,
+          end: path.node.end,
+          replacement: replaceMap[key],
+        })
+      })
+    })
+    return magicSource.toContentAndSourcemap()
+  }
+
   return {
     name: "jsenv:commonjs_globals",
     appliesDuring: "*",
-    transform: {
-      js_module: async ({ url, generatedUrl, content }, { scenario }) => {
-        const replaceMap = {
-          "process.env.NODE_ENV": `("${
-            scenario === "dev" || scenario === "test" ? "dev" : "prod"
-          }")`,
-          "global": "globalThis",
-          "__filename": `import.meta.url.slice('file:///'.length)`,
-          "__dirname": `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`,
-        }
-        const { metadata } = await applyBabelPlugins({
-          babelPlugins: [
-            [
-              babelPluginMetadataExpressionPaths,
-              {
-                replaceMap,
-                allowConflictingReplacements: true,
-              },
-            ],
-          ],
-          url,
-          generatedUrl,
-          content,
-        })
-        const { expressionPaths } = metadata
-        const keys = Object.keys(expressionPaths)
-        if (keys.length === 0) {
-          return null
-        }
-        const magicSource = createMagicSource(content)
-        keys.forEach((key) => {
-          expressionPaths[key].forEach((path) => {
-            magicSource.replace({
-              start: path.node.start,
-              end: path.node.end,
-              replacement: replaceMap[key],
-            })
-          })
-        })
-        return magicSource.toContentAndSourcemap()
-      },
+    transformUrlContent: {
+      js_classic: transformCommonJsGlobals,
+      js_module: transformCommonJsGlobals,
     },
   }
 }

package/src/plugins/file_urls/jsenv_plugin_file_urls.js

@@ -0,0 +1,66 @@
+import { readFileSync } from "node:fs"
+import { urlIsInsideOf, urlToRelativeUrl } from "@jsenv/filesystem"
+
+import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+
+export const jsenvPluginFileUrls = () => {
+  return [jsenvPluginResolveAbsoluteFileUrls(), jsenvPluginFetchFileUrls()]
+}
+
+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,
+    },
+    resolveUrl: (reference) => {
+      if (!reference.specifier.startsWith("/@fs/")) {
+        return null
+      }
+      const fsRootRelativeUrl = reference.specifier.slice("/@fs/".length)
+      return `file:///${fsRootRelativeUrl}`
+    },
+    formatUrl: (reference, context) => {
+      if (!reference.generatedUrl.startsWith("file:")) {
+        return null
+      }
+      if (urlIsInsideOf(reference.generatedUrl, context.rootDirectoryUrl)) {
+        return `/${urlToRelativeUrl(
+          reference.generatedUrl,
+          context.rootDirectoryUrl,
+        )}`
+      }
+      return `/@fs/${reference.generatedUrl.slice("file:///".length)}`
+    },
+  }
+}
+
+const jsenvPluginFetchFileUrls = () => {
+  return {
+    name: "jsenv:fetch_file_urls",
+    appliesDuring: "*",
+    fetchUrlContent: (urlInfo) => {
+      if (!urlInfo.url.startsWith("file:")) {
+        return null
+      }
+      const urlObject = new URL(urlInfo.url)
+      const fileBuffer = readFileSync(urlObject)
+      const contentType = CONTENT_TYPE.fromUrlExtension(urlInfo.url)
+      if (CONTENT_TYPE.isTextual(contentType)) {
+        return {
+          contentType,
+          content: String(fileBuffer),
+        }
+      }
+      return {
+        contentType,
+        content: fileBuffer,
+      }
+    },
+  }
+}

package/src/{omega/core_plugins → plugins}/filesystem_magic/jsenv_plugin_filesystem_magic.js

@@ -6,19 +6,19 @@ import { urlToExtension } from "@jsenv/filesystem"
 import { applyFileSystemMagicResolution } from "@jsenv/node-esm-resolution"
 
 export const jsenvPluginFileSystemMagic = ({
-  magicExtensions = ["inherit"],
+  magicExtensions = ["inherit", ".js"],
   magicDirectoryIndex = true,
   preservesSymlink = true,
 } = {}) => {
   return {
     name: "jsenv:filesystem_magic",
     appliesDuring: "*",
-    normalize: ({ parentUrl, url }) => {
+    redirectUrl: (reference) => {
       // http, https, data, about, etc
-      if (!url.startsWith("file:")) {
+      if (!reference.url.startsWith("file:")) {
         return null
       }
-      const urlObject = new URL(url)
+      const urlObject = new URL(reference.url)
       const { search, hash } = urlObject
       urlObject.search = ""
       urlObject.hash = ""
@@ -26,7 +26,10 @@ export const jsenvPluginFileSystemMagic = ({
         urlObject.href,
         {
           magicDirectoryIndex,
-          magicExtensions: getExtensionsToTry(magicExtensions, parentUrl),
+          magicExtensions: getExtensionsToTry(
+            magicExtensions,
+            reference.parentUrl,
+          ),
         },
       )
       if (!filesystemResolution.found) {