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

package/src/plugins/minification/jsenv_plugin_minification.js

@@ -0,0 +1,78 @@
+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
+
+  return {
+    name: "jsenv:minification",
+    appliesDuring: {
+      build: true,
+    },
+    optimizeUrlContent: {
+      html: htmlOptimizer,
+      svg: htmlOptimizer,
+      css: minification.css
+        ? (urlInfo, context) =>
+            minifyCss({
+              cssUrlInfo: urlInfo,
+              context,
+              options: minification.css,
+            })
+        : null,
+      js_classic: minification.js_classic
+        ? (urlInfo, context) =>
+            minifyJs({
+              jsUrlInfo: urlInfo,
+              context,
+              options: minification.js_classic,
+            })
+        : null,
+      js_module: minification.js_module
+        ? (urlInfo, context) =>
+            minifyJs({
+              jsUrlInfo: urlInfo,
+              context,
+              options: minification.js_module,
+            })
+        : null,
+      json: jsonOptimizer,
+      importmap: jsonOptimizer,
+      webmanifest: jsonOptimizer,
+    },
+  }
+}

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

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

package/src/plugins/node_esm_resolution/jsenv_plugin_node_esm_resolution.js

@@ -0,0 +1,146 @@
+/*
+ * - should I restore eventual search params lost during node esm resolution
+ * - what about symlinks?
+ *   It feels like I should apply symlink (when we don't want to preserve them)
+ *   once a file:/// url is found, regardless
+ *   if that comes from node resolution or anything else (not even magic resolution)
+ *   it should likely be an other plugin happening after the others
+ */
+
+import { registerFileLifecycle } from "@jsenv/filesystem"
+
+import {
+  applyNodeEsmResolution,
+  defaultLookupPackageScope,
+  defaultReadPackageJson,
+} from "@jsenv/node-esm-resolution"
+
+export const jsenvPluginNodeEsmResolution = ({
+  rootDirectoryUrl,
+  // https://nodejs.org/api/esm.html#resolver-algorithm-specification
+  packageConditions = ["browser", "import"],
+  filesInvalidatingCache = ["package.json", "package-lock.json"],
+}) => {
+  const packageScopesCache = new Map()
+  const lookupPackageScope = (url) => {
+    const fromCache = packageScopesCache.get(url)
+    if (fromCache) {
+      return fromCache
+    }
+    const packageScope = defaultLookupPackageScope(url)
+    packageScopesCache.set(url, packageScope)
+    return packageScope
+  }
+  const packageJsonsCache = new Map()
+  const readPackageJson = (url) => {
+    const fromCache = packageJsonsCache.get(url)
+    if (fromCache) {
+      return fromCache
+    }
+    const packageJson = defaultReadPackageJson(url)
+    packageJsonsCache.set(url, packageJson)
+    return packageJson
+  }
+
+  const unregisters = []
+  filesInvalidatingCache.forEach((file) => {
+    const unregister = registerFileLifecycle(new URL(file, rootDirectoryUrl), {
+      added: () => {
+        packageScopesCache.clear()
+        packageJsonsCache.clear()
+      },
+      updated: () => {
+        packageScopesCache.clear()
+        packageJsonsCache.clear()
+      },
+      removed: () => {
+        packageScopesCache.clear()
+        packageJsonsCache.clear()
+      },
+      keepProcessAlive: false,
+    })
+    unregisters.push(unregister)
+  })
+
+  return [
+    jsenvPluginNodeEsmResolver({
+      packageConditions,
+      lookupPackageScope,
+      readPackageJson,
+    }),
+    jsenvPluginNodeModulesVersionInUrls({
+      lookupPackageScope,
+      readPackageJson,
+    }),
+  ]
+}
+
+const jsenvPluginNodeEsmResolver = ({
+  packageConditions,
+  lookupPackageScope,
+  readPackageJson,
+}) => {
+  return {
+    name: "jsenv:node_esm_resolve",
+    appliesDuring: "*",
+    resolveUrl: {
+      js_import_export: (reference) => {
+        const { parentUrl, specifier } = reference
+        const { url } = applyNodeEsmResolution({
+          conditions: packageConditions,
+          parentUrl,
+          specifier,
+          lookupPackageScope,
+          readPackageJson,
+        })
+        return url
+      },
+    },
+    fetchUrlContent: (urlInfo) => {
+      if (urlInfo.url.startsWith("file:///@ignore/")) {
+        return {
+          content: "export default {}",
+        }
+      }
+      return null
+    },
+  }
+}
+
+const jsenvPluginNodeModulesVersionInUrls = ({
+  lookupPackageScope,
+  readPackageJson,
+}) => {
+  return {
+    name: "jsenv:node_modules_version_in_urls",
+    appliesDuring: {
+      dev: true,
+      test: true,
+    },
+    transformUrlSearchParams: (reference, context) => {
+      if (!reference.url.startsWith("file:")) {
+        return null
+      }
+      // without this check a file inside a project without package.json
+      // could be considered as a node module if there is a ancestor package.json
+      // but we want to version only node modules
+      if (!reference.url.includes("/node_modules/")) {
+        return null
+      }
+      if (reference.searchParams.has("v")) {
+        return null
+      }
+      const packageUrl = lookupPackageScope(reference.url)
+      if (!packageUrl) {
+        return null
+      }
+      if (packageUrl === context.rootDirectoryUrl) {
+        return null
+      }
+      const packageVersion = readPackageJson(packageUrl).version
+      return {
+        v: packageVersion,
+      }
+    },
+  }
+}

package/src/{omega → plugins}/plugin_controller.js

@@ -1,14 +1,16 @@
+import { timeStart } from "@jsenv/server"
+
 export const createPluginController = ({
   plugins,
   scenario,
   hooks = [
-    "resolve",
-    "normalize",
-    "load",
-    "transform",
-    "transformReferencedUrl",
-    "formatReferencedUrl",
-    "finalize",
+    "resolveUrl",
+    "redirectUrl",
+    "fetchUrlContent",
+    "transformUrlContent",
+    "transformUrlSearchParams",
+    "formatUrl",
+    "finalizeUrlContent",
     "cooked",
     "destroy",
   ],
@@ -47,7 +49,13 @@ export const createPluginController = ({
     }
     currentPlugin = hook.plugin
     currentHookName = hook.hookName
+    const timeEnd = timeStart(
+      `${currentHookName}-${currentPlugin.name.replace("jsenv:", "")}`,
+    )
     let valueReturned = hookFn(info, context)
+    if (info.timing) {
+      Object.assign(info.timing, timeEnd())
+    }
     valueReturned = assertAndNormalizeReturnValue(hook.hookName, valueReturned)
     currentPlugin = null
     currentHookName = null
@@ -60,7 +68,13 @@ export const createPluginController = ({
     }
     currentPlugin = hook.plugin
     currentHookName = hook.hookName
+    const timeEnd = timeStart(
+      `${currentHookName}-${currentPlugin.name.replace("jsenv:", "")}`,
+    )
     let valueReturned = await hookFn(info, context)
+    if (info.timing) {
+      Object.assign(info.timing, timeEnd())
+    }
     valueReturned = assertAndNormalizeReturnValue(hook.hookName, valueReturned)
     currentPlugin = null
     currentHookName = null
@@ -99,6 +113,9 @@ export const createPluginController = ({
   }
   const callAsyncHooksUntil = (hookName, info, context) => {
     const hooks = hookGroups[hookName]
+    if (hooks.length === 0) {
+      return null
+    }
     return new Promise((resolve, reject) => {
       const visit = (index) => {
         if (index >= hooks.length) {
@@ -145,12 +162,18 @@ const flattenAndFilterPlugins = (pluginsRaw, { scenario }) => {
       const { appliesDuring } = pluginEntry
       if (appliesDuring === undefined) {
         console.warn(`"appliesDuring" is undefined on ${pluginEntry.name}`)
+        return
       }
       if (appliesDuring === "*") {
         plugins.push(pluginEntry)
         return
       }
-      if (appliesDuring && appliesDuring[scenario]) {
+      if (typeof appliesDuring !== "object") {
+        throw new Error(
+          `"appliesDuring" must be an object or "*", got ${appliesDuring}`,
+        )
+      }
+      if (appliesDuring[scenario]) {
         plugins.push(pluginEntry)
         return
       }
@@ -203,7 +226,7 @@ const assertAndNormalizeReturnValue = (hookName, returnValue) => {
 const returnValueAssertions = [
   {
     name: "url_assertion",
-    appliesTo: ["resolve", "redirect"],
+    appliesTo: ["resolveUrl", "redirectUrl"],
     assertion: (valueReturned) => {
       if (valueReturned instanceof URL) {
         return valueReturned.href
@@ -218,13 +241,21 @@ const returnValueAssertions = [
   },
   {
     name: "content_assertion",
-    appliesTo: ["load", "transform", "finalize"],
+    appliesTo: [
+      "fetchUrlContent",
+      "transformUrlContent",
+      "finalizeUrlContent",
+      "optimizeUrlContent",
+    ],
     assertion: (valueReturned) => {
       if (typeof valueReturned === "string" || Buffer.isBuffer(valueReturned)) {
         return { content: valueReturned }
       }
       if (typeof valueReturned === "object") {
-        const { content } = valueReturned
+        const { external, content } = valueReturned
+        if (external) {
+          return undefined
+        }
         if (typeof content !== "string" && !Buffer.isBuffer(content)) {
           throw new Error(
             `Unexpected "content" returned by plugin: it must be a string or a buffer; got ${content}`,

package/src/plugins/plugins.js

@@ -0,0 +1,92 @@
+import { jsenvPluginUrlAnalysis } from "../plugins/url_analysis/jsenv_plugin_url_analysis.js"
+import { jsenvPluginLeadingSlash } from "./leading_slash/jsenv_plugin_leading_slash.js"
+import { jsenvPluginImportmap } from "./importmap/jsenv_plugin_importmap.js"
+import { jsenvPluginUrlResolution } from "./url_resolution/jsenv_plugin_url_resolution.js"
+import { jsenvPluginNodeEsmResolution } from "./node_esm_resolution/jsenv_plugin_node_esm_resolution.js"
+import { jsenvPluginUrlVersion } from "./url_version/jsenv_plugin_url_version.js"
+import { jsenvPluginFileUrls } from "./file_urls/jsenv_plugin_file_urls.js"
+import { jsenvPluginHttpUrls } from "./http_urls/jsenv_plugin_http_urls.js"
+import { jsenvPluginFileSystemMagic } from "./filesystem_magic/jsenv_plugin_filesystem_magic.js"
+import { jsenvPluginInline } from "./inline/jsenv_plugin_inline.js"
+import { jsenvPluginHtmlSupervisor } from "./html_supervisor/jsenv_plugin_html_supervisor.js"
+import { jsenvPluginCommonJsGlobals } from "./commonjs_globals/jsenv_plugin_commonjs_globals.js"
+import { jsenvPluginImportMetaScenarios } from "./import_meta_scenarios/jsenv_plugin_import_meta_scenarios.js"
+import { jsenvPluginInjectGlobals } from "./inject_globals/jsenv_plugin_inject_globals.js"
+import { jsenvPluginTranspilation } from "./transpilation/jsenv_plugin_transpilation.js"
+import { jsenvPluginBundling } from "./bundling/jsenv_plugin_bundling.js"
+import { jsenvPluginMinification } from "./minification/jsenv_plugin_minification.js"
+import { jsenvPluginImportMetaHot } from "./import_meta_hot/jsenv_plugin_import_meta_hot.js"
+import { jsenvPluginAutoreload } from "./autoreload/jsenv_plugin_autoreload.js"
+import { jsenvPluginCacheControl } from "./cache_control/jsenv_plugin_cache_control.js"
+
+export const getCorePlugins = ({
+  rootDirectoryUrl,
+  urlGraph,
+  scenario,
+
+  htmlSupervisor,
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+  injectedGlobals,
+  transpilation = true,
+  minification = false,
+  bundling = false,
+
+  clientAutoreload = false,
+  clientFileChangeCallbackList,
+  clientFilesPruneCallbackList,
+} = {}) => {
+  if (htmlSupervisor === true) {
+    htmlSupervisor = {}
+  }
+  if (nodeEsmResolution === true) {
+    nodeEsmResolution = {}
+  }
+  return [
+    jsenvPluginUrlAnalysis(),
+    jsenvPluginTranspilation(transpilation),
+    ...(htmlSupervisor
+      ? [
+          jsenvPluginHtmlSupervisor({
+            rootDirectoryUrl,
+            ...htmlSupervisor,
+          }),
+        ]
+      : []), // before inline as it turns inline <script> into <script src>
+    jsenvPluginInline(), // before "file urls" to resolve and load inline urls
+    jsenvPluginImportmap(), // before node esm to handle bare specifiers before node esm
+    jsenvPluginFileUrls(),
+    jsenvPluginHttpUrls(),
+    jsenvPluginLeadingSlash(),
+    // before url resolution to handle "js_import_export" resolution
+    jsenvPluginNodeEsmResolution({
+      rootDirectoryUrl,
+      ...nodeEsmResolution,
+    }),
+    jsenvPluginUrlResolution(),
+    jsenvPluginFileSystemMagic(fileSystemMagicResolution),
+    jsenvPluginUrlVersion(),
+    jsenvPluginInjectGlobals(injectedGlobals),
+    jsenvPluginCommonJsGlobals(),
+    jsenvPluginImportMetaScenarios(),
+
+    jsenvPluginBundling(bundling),
+    jsenvPluginMinification(minification),
+
+    jsenvPluginImportMetaHot({
+      rootDirectoryUrl,
+    }),
+    ...(clientAutoreload
+      ? [
+          jsenvPluginAutoreload({
+            rootDirectoryUrl,
+            urlGraph,
+            scenario,
+            clientFileChangeCallbackList,
+            clientFilesPruneCallbackList,
+          }),
+        ]
+      : []),
+    jsenvPluginCacheControl(),
+  ]
+}