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

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/{omega/core_plugins → plugins}/node_esm_resolution/jsenv_plugin_node_esm_resolution.js

@@ -20,18 +20,18 @@ export const jsenvPluginNodeEsmResolution = ({
   const nodeEsmResolution = {
     name: "jsenv:node_esm_resolve",
     appliesDuring: "*",
-    resolve: {
-      js_import_export: ({ parentUrl, specifier }) => {
+    resolveUrl: {
+      js_import_export: (reference) => {
         const { url } = applyNodeEsmResolution({
           conditions: packageConditions,
-          parentUrl,
-          specifier,
+          parentUrl: reference.parentUrl,
+          specifier: reference.specifier,
         })
         return url
       },
     },
-    load: ({ url }) => {
-      if (url.startsWith("file:///@ignore/")) {
+    fetchUrlContent: (urlInfo) => {
+      if (urlInfo.url.startsWith("file:///@ignore/")) {
         return {
           content: "export default {}",
         }
@@ -46,30 +46,30 @@ export const jsenvPluginNodeEsmResolution = ({
       dev: true,
       test: true,
     },
-    transformReferencedUrl: ({ url }, { rootDirectoryUrl }) => {
-      if (!url.startsWith("file:")) {
+    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 (!url.includes("/node_modules/")) {
+      if (!reference.url.includes("/node_modules/")) {
         return null
       }
-      const urlObject = new URL(url)
-      if (urlObject.searchParams.has("v")) {
+      if (reference.searchParams.has("v")) {
         return null
       }
-      const packageUrl = lookupPackageScope(url)
+      const packageUrl = lookupPackageScope(reference.url)
       if (!packageUrl) {
         return null
       }
-      if (packageUrl === rootDirectoryUrl) {
+      if (packageUrl === context.rootDirectoryUrl) {
         return null
       }
       const packageVersion = readPackageJson(packageUrl).version
-      urlObject.searchParams.set("v", packageVersion)
-      return urlObject.href
+      return {
+        v: packageVersion,
+      }
     },
   }
 

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

@@ -2,13 +2,13 @@ export const createPluginController = ({
   plugins,
   scenario,
   hooks = [
-    "resolve",
-    "normalize",
-    "load",
-    "transform",
-    "transformReferencedUrl",
-    "formatReferencedUrl",
-    "finalize",
+    "resolveUrl",
+    "normalizeUrl",
+    "fetchUrlContent",
+    "transformUrlContent",
+    "transformUrlSearchParams",
+    "formatUrl",
+    "finalizeUrlContent",
     "cooked",
     "destroy",
   ],
@@ -203,7 +203,7 @@ const assertAndNormalizeReturnValue = (hookName, returnValue) => {
 const returnValueAssertions = [
   {
     name: "url_assertion",
-    appliesTo: ["resolve", "redirect"],
+    appliesTo: ["resolveUrl", "normalizeUrl"],
     assertion: (valueReturned) => {
       if (valueReturned instanceof URL) {
         return valueReturned.href
@@ -218,13 +218,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,73 @@
+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"
+
+export const getCorePlugins = ({
+  rootDirectoryUrl,
+  urlGraph,
+  scenario,
+
+  htmlSupervisor,
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+  injectedGlobals,
+  transpilation = true,
+  minification = false,
+  bundling = false,
+
+  autoreload = false,
+} = {}) => {
+  if (htmlSupervisor === true) {
+    htmlSupervisor = {}
+  }
+  if (autoreload === true) {
+    autoreload = {}
+  }
+  return [
+    jsenvPluginTranspilation(transpilation),
+    ...(htmlSupervisor ? [jsenvPluginHtmlSupervisor(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(),
+    jsenvPluginNodeEsmResolution(nodeEsmResolution), // before url resolution to handle "js_import_export" resolution
+    jsenvPluginUrlResolution(),
+    jsenvPluginFileSystemMagic(fileSystemMagicResolution),
+    jsenvPluginUrlVersion(),
+    jsenvPluginInjectGlobals(injectedGlobals),
+    jsenvPluginCommonJsGlobals(),
+    jsenvPluginImportMetaScenarios(),
+    // jsenvPluginWorkers(),
+
+    jsenvPluginBundling(bundling),
+    jsenvPluginMinification(minification),
+
+    jsenvPluginImportMetaHot(),
+    ...(autoreload
+      ? [
+          jsenvPluginAutoreload({
+            rootDirectoryUrl,
+            urlGraph,
+            scenario,
+            ...autoreload,
+          }),
+        ]
+      : []),
+  ]
+}