@jsenv/core 23.0.4 → 23.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "23.0.4",
+  "version": "23.0.8",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {
@@ -42,9 +42,7 @@
     "test-build": "node ./script/test/test_build.js",
     "test-launch-browser": "node ./script/test/test-launch-browser.js",
     "test-launch-node": "node ./script/test/test-launch-node.js",
-    "measure-performances": "node --expose-gc ./script/performance/generate_performance_report.js --local",
-    "measure-dev-server-performances": "node --expose-gc ./script/performance/measure_dev_server/measure_dev_server.js --local",
-    "measure-test-plan-performances": "node --expose-gc ./script/performance/measure_test_plan/measure_test_plan.js --local",
+    "measure-performances": "node --expose-gc ./script/performance/generate_performance_report.js --log --once",
     "prettier-format": "node ./script/prettier/prettier_format.mjs",
     "prettier-format-stage": "npm run prettier-format -- --staged",
     "prettier-check": "npm run prettier-format -- --dry-run",
@@ -66,12 +64,13 @@
     "@babel/plugin-transform-modules-systemjs": "7.15.4",
     "@c88/v8-coverage": "0.1.1",
     "@jsenv/cancellation": "3.0.0",
-    "@jsenv/filesystem": "2.2.0",
+    "@jsenv/filesystem": "2.3.1",
     "@jsenv/importmap": "1.1.0",
     "@jsenv/logger": "4.0.1",
     "@jsenv/node-signals": "2.0.1",
     "@jsenv/server": "7.2.0",
     "@jsenv/uneval": "1.6.0",
+    "@jsenv/workers": "1.1.0",
     "@rollup/plugin-commonjs": "21.0.0",
     "@rollup/plugin-json": "4.1.0",
     "@rollup/plugin-node-resolve": "13.0.5",
@@ -79,8 +78,8 @@
     "acorn-import-assertions": "1.8.0",
     "ansi-to-html": "0.7.2",
     "bytes": "3.1.0",
-    "construct-style-sheets-polyfill": "3.0.4",
     "cjs-module-lexer": "1.2.2",
+    "construct-style-sheets-polyfill": "3.0.4",
     "cssnano": "5.0.8",
     "cssnano-preset-default": "5.1.4",
     "cuid": "2.1.8",
@@ -122,7 +121,7 @@
     "@babel/plugin-transform-react-jsx": "7.14.9",
     "@babel/plugin-transform-typescript": "7.15.8",
     "@babel/preset-env": "7.15.8",
-    "@jsenv/assert": "2.3.1",
+    "@jsenv/assert": "2.3.2",
     "@jsenv/babel-preset": "./packages/jsenv-babel-preset",
     "@jsenv/codecov-upload": "3.5.0",
     "@jsenv/eslint-config": "16.0.8",
@@ -130,7 +129,7 @@
     "@jsenv/importmap-eslint-resolver": "5.1.2",
     "@jsenv/importmap-node-module": "2.4.1",
     "@jsenv/package-publish": "1.6.2",
-    "@jsenv/performance-impact": "1.7.0",
+    "@jsenv/performance-impact": "2.1.2",
     "@jsenv/prettier-check-project": "5.6.1",
     "@jsenv/pwa": "4.0.0",
     "babel-plugin-transform-async-to-promises": "0.8.15",

package/src/internal/building/createJsenvRollupPlugin.js

@@ -15,6 +15,7 @@ import {
   normalizeStructuredMetaMap,
   urlToMeta,
 } from "@jsenv/filesystem"
+import { createWorkersForJavaScriptModules } from "@jsenv/workers"
 
 import { createUrlConverter } from "@jsenv/core/src/internal/url_conversion.js"
 import { createUrlFetcher } from "@jsenv/core/src/internal/building/url_fetcher.js"
@@ -42,7 +43,6 @@ import {
 import { computeBuildRelativeUrl } from "./url-versioning.js"
 import { visitImportReferences } from "./import_references.js"
 
-import { minifyJs } from "./js/minifyJs.js"
 import { createImportResolverForNode } from "../import-resolution/import-resolver-node.js"
 import { createImportResolverForImportmap } from "../import-resolution/import-resolver-importmap.js"
 import { getDefaultImportMap } from "../import-resolution/importmap-default.js"
@@ -218,7 +218,63 @@ export const createJsenvRollupPlugin = async ({
     return rollupSetAssetSource(rollupReferenceId, assetSource)
   }
 
-  const jsenvRollupPlugin = {
+  let onBundleEnd = () => {}
+  let minifyJs
+  let minifyHtml
+
+  const jsenvRollupPlugin = {}
+
+  if (minify) {
+    const { methodHooks, workers } = createWorkersForJavaScriptModules({
+      minifyJs: `${new URL("./js/minifyJs.js", import.meta.url)}#minifyJs`,
+      minifyHtml: `${new URL(
+        "./html/minifyHtml.js",
+        import.meta.url,
+      )}#minifyHtml`,
+    })
+
+    // inspired from https://github.com/vitejs/vite/blob/06d86e4a2e90ca916a43d450bca1e6c28bc4bfe2/packages/vite/src/node/plugins/terser.ts#L23
+    minifyJs = async ({ url, code, map, ...rest }) => {
+      const result = await methodHooks.minifyJs({
+        url,
+        code,
+        map,
+        ...minifyJsOptions,
+        ...rest,
+      })
+      return {
+        code: result.code,
+        map: result.map,
+      }
+    }
+
+    minifyHtml = async (html) => {
+      return methodHooks.minifyHtml(html, minifyHtmlOptions)
+    }
+
+    jsenvRollupPlugin.renderChunk = async (code, chunk) => {
+      let map = chunk.map
+      const result = await minifyJs({
+        url: asOriginalUrl(chunk.facadeModuleId),
+        code,
+        map,
+        ...(format === "global" ? { toplevel: false } : { toplevel: true }),
+      })
+
+      code = result.code
+      map = result.map
+      return {
+        code,
+        map,
+      }
+    }
+
+    onBundleEnd = () => {
+      workers.destroy()
+    }
+  }
+
+  Object.assign(jsenvRollupPlugin, {
     name: "jsenv",
 
     async buildStart() {
@@ -414,9 +470,9 @@ export const createJsenvRollupPlugin = async ({
               useImportMapToMaximizeCacheReuse,
               createImportMapForFilesUsedInJs,
               minify,
-              minifyHtmlOptions,
+              minifyJs,
+              minifyHtml,
               minifyCssOptions,
-              minifyJsOptions,
             })
           },
         },
@@ -1001,28 +1057,6 @@ export const createJsenvRollupPlugin = async ({
       return outputOptions
     },
 
-    renderChunk: async (code, chunk) => {
-      let map = chunk.map
-
-      if (!minify) {
-        return null
-      }
-
-      const result = await minifyJs({
-        url: asOriginalUrl(chunk.facadeModuleId),
-        code,
-        map,
-        ...(format === "global" ? { toplevel: false } : { toplevel: true }),
-        ...minifyJsOptions,
-      })
-      code = result.code
-      map = result.map
-      return {
-        code,
-        map,
-      }
-    },
-
     async generateBundle(outputOptions, rollupResult) {
       const jsChunks = {}
       // rollupResult can be mutated by late asset emission
@@ -1119,6 +1153,7 @@ export const createJsenvRollupPlugin = async ({
       ressourceBuilder.rollupBuildEnd({ jsModuleBuild, buildManifest })
       // wait html files to be emitted
       await ressourceBuilder.getAllEntryPointsEmittedPromise()
+      onBundleEnd()
 
       const assetBuild = {}
       Object.keys(rollupResult).forEach((rollupFileId) => {
@@ -1260,7 +1295,7 @@ export const createJsenvRollupPlugin = async ({
         }),
       )
     },
-  }
+  })
 
   const fetchImportMapFromUrl = async (importMapUrl, importer) => {
     const importMapResponse = await urlFetcher.fetchUrl(importMapUrl, {

package/src/internal/building/html/parseHtmlRessource.js

@@ -51,14 +51,13 @@ import {
 import { collectNodesMutations } from "../parsing.utils.js"
 
 import { collectSvgMutations } from "../svg/parseSvgRessource.js"
-import { minifyHtml } from "./minifyHtml.js"
 
 export const parseHtmlRessource = async (
   htmlRessource,
   notifiers,
   {
     minify,
-    minifyHtmlOptions,
+    minifyHtml,
     htmlStringToHtmlAst = (htmlString) => parseHtmlString(htmlString),
     htmlAstToHtmlString = (htmlAst) => stringifyHtmlAst(htmlAst),
     ressourceHintNeverUsedCallback = () => {},
@@ -153,7 +152,7 @@ export const parseHtmlRessource = async (
 
     const htmlAfterTransformation = htmlAstToHtmlString(htmlAst)
     const html = minify
-      ? minifyHtml(htmlAfterTransformation, minifyHtmlOptions)
+      ? await minifyHtml(htmlAfterTransformation)
       : htmlAfterTransformation
     htmlRessource.buildEnd(html)
   }

package/src/internal/building/js/parseJsRessource.js

@@ -5,12 +5,11 @@ import {
   setJavaScriptSourceMappingUrl,
 } from "@jsenv/core/src/internal/sourceMappingURLUtils.js"
 import { bundleWorker } from "@jsenv/core/src/internal/building/bundleWorker.js"
-import { minifyJs } from "./minifyJs.js"
 
 export const parseJsRessource = async (
   jsRessource,
   { notifyReferenceFound },
-  { asProjectUrl, asOriginalUrl, minify, minifyJsOptions },
+  { asProjectUrl, asOriginalUrl, minify, minifyJs },
 ) => {
   const jsUrl = jsRessource.url
   const jsString = String(jsRessource.bufferBeforeBuild)
@@ -72,7 +71,6 @@ export const parseJsRessource = async (
         code: jsString,
         map,
         toplevel: false,
-        ...minifyJsOptions,
       })
       code = result.code
       map = result.map

package/src/internal/building/parseRessource.js

@@ -36,9 +36,9 @@ export const parseRessource = (
     useImportMapToMaximizeCacheReuse,
     createImportMapForFilesUsedInJs,
     minify,
-    minifyHtmlOptions,
+    minifyJs,
+    minifyHtml,
     minifyCssOptions,
-    minifyJsOptions,
   },
 ) => {
   const { contentType } = ressource
@@ -49,7 +49,7 @@ export const parseRessource = (
   if (contentType === "text/html") {
     return parseHtmlRessource(ressource, notifiers, {
       minify,
-      minifyHtmlOptions,
+      minifyHtml,
       htmlStringToHtmlAst: async (htmlString) => {
         const htmlAst = parseHtmlString(htmlString)
 
@@ -157,14 +157,14 @@ export const parseRessource = (
       asOriginalUrl,
       asOriginalServerUrl,
       minify,
-      minifyJsOptions,
+      minifyJs,
     })
   }
 
   if (contentType === "image/svg+xml") {
     return parseSvgRessource(ressource, notifiers, {
       minify,
-      minifyHtmlOptions,
+      minifyHtml,
     })
   }
 

package/src/internal/building/svg/parseSvgRessource.js

@@ -19,7 +19,7 @@ export const parseSvgRessource = async (
   const htmlRessources = parseHtmlAstRessources(svgAst)
   const mutations = collectSvgMutations(htmlRessources, notifiers, svgRessource)
 
-  return ({ getUrlRelativeToImporter }) => {
+  return async ({ getUrlRelativeToImporter }) => {
     mutations.forEach((mutationCallback) => {
       mutationCallback({ getUrlRelativeToImporter })
     })
@@ -27,7 +27,7 @@ export const parseSvgRessource = async (
     // could also benefit of minification https://github.com/svg/svgo
     if (minify) {
       svgRessource.buildEnd(
-        minifyHtml(svgAfterTransformation, minifyHtmlOptions),
+        await minifyHtml(svgAfterTransformation, minifyHtmlOptions),
       )
       return
     }

package/src/internal/compiling/babel_plugin_new_stylesheet_as_jsenv_import.js

@@ -1,3 +1,9 @@
+/*
+ * TODO:
+ * - code should also inject helper when code uses new keyword on "CSSStyleSheet"
+ * - code should also inject helper when code uses "document.adoptedStylesheets"
+ */
+
 import { require } from "../require.js"
 
 export const babelPluginNewStylesheetAsJsenvImport = (
@@ -18,8 +24,6 @@ export const babelPluginNewStylesheetAsJsenvImport = (
     addSideEffect(path.scope.getProgramParent().path, newStylesheetImportPath)
   }
 
-  // TODO: we should detect usage of new keyword on "CSSStyleSheet"
-  // and inject too in that case
   return {
     name: "constructable-stylesheet-as-jsenv-import",
     visitor: {

package/src/internal/compiling/compile-directory/getOrGenerateCompiledFile.js

@@ -2,9 +2,7 @@ import { urlToFileSystemPath } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/logger"
 import { timeStart, timeFunction } from "@jsenv/server"
 import { readFileContent } from "./fs-optimized-for-cache.js"
-import { readMeta } from "./readMeta.js"
-import { validateMeta } from "./validateMeta.js"
-import { updateMeta } from "./updateMeta.js"
+import { validateCache } from "./validateCache.js"
 import { getMetaJsonFileUrl } from "./compile-asset.js"
 import { createLockRegistry } from "./createLockRegistry.js"
 
@@ -16,13 +14,13 @@ export const getOrGenerateCompiledFile = async ({
   projectDirectoryUrl,
   originalFileUrl,
   compiledFileUrl = originalFileUrl,
-  writeOnFilesystem,
   useFilesystemAsCache,
-  cacheHitTracking = false,
   compileCacheSourcesValidation,
   compileCacheAssetsValidation,
   fileContentFallback,
+  clientNeedsEtagHeader,
   ifEtagMatch,
+  clientNeedsLastModifiedHeader,
   ifModifiedSinceDate,
   compile,
 }) => {
@@ -71,7 +69,9 @@ export const getOrGenerateCompiledFile = async ({
           compiledFileUrl,
           compile,
           fileContentFallback,
+          clientNeedsEtagHeader,
           ifEtagMatch,
+          clientNeedsLastModifiedHeader,
           ifModifiedSinceDate,
           useFilesystemAsCache,
           compileCacheSourcesValidation,
@@ -79,22 +79,6 @@ export const getOrGenerateCompiledFile = async ({
           logger,
         })
 
-      let cacheWriteTiming = {}
-      if (writeOnFilesystem) {
-        const result = await timeFunction("cache write", () =>
-          updateMeta({
-            logger,
-            meta,
-            compileResult,
-            compileResultStatus,
-            compiledFileUrl,
-            // originalFileUrl,
-            cacheHitTracking,
-          }),
-        )
-        cacheWriteTiming = result[0]
-      }
-
       return {
         meta,
         compileResult,
@@ -102,7 +86,6 @@ export const getOrGenerateCompiledFile = async ({
         timing: {
           ...lockTiming,
           ...timing,
-          ...cacheWriteTiming,
         },
       }
     },
@@ -118,55 +101,49 @@ const computeCompileReport = async ({
   compiledFileUrl,
   compile,
   fileContentFallback,
+  clientNeedsEtagHeader,
   ifEtagMatch,
+  clientNeedsLastModifiedHeader,
   ifModifiedSinceDate,
   useFilesystemAsCache,
   compileCacheSourcesValidation,
   compileCacheAssetsValidation,
   logger,
 }) => {
-  const [cacheReadTiming, meta] = await timeFunction("cache read", async () => {
-    if (useFilesystemAsCache) {
-      return readMeta({
+  const [readCacheTiming, cacheValidity] = await timeFunction(
+    "read cache",
+    () => {
+      if (!useFilesystemAsCache) {
+        return {
+          isValid: false,
+          code: "META_FILE_NOT_FOUND",
+          meta: {
+            isValid: false,
+            code: "META_FILE_NOT_FOUND",
+          },
+        }
+      }
+      return validateCache({
         logger,
+        useFilesystemAsCache,
         compiledFileUrl,
+        clientNeedsEtagHeader,
+        ifEtagMatch,
+        clientNeedsLastModifiedHeader,
+        ifModifiedSinceDate,
+        compileCacheSourcesValidation,
+        compileCacheAssetsValidation,
       })
-    }
-    return null
-  })
-
-  if (!meta) {
-    const [compileTiming, compileResult] = await timeFunction("compile", () =>
-      callCompile({
-        logger,
-        originalFileUrl,
-        fileContentFallback,
-        compile,
-      }),
-    )
+    },
+  )
 
-    return {
-      meta: null,
-      compileResult,
-      compileResultStatus: "created",
-      timing: {
-        ...cacheReadTiming,
-        ...compileTiming,
-      },
+  if (!cacheValidity.isValid) {
+    if (cacheValidity.code === "SOURCES_EMPTY") {
+      logger.warn(`WARNING: meta.sources is empty for ${compiledFileUrl}`)
     }
-  }
 
-  const metaValidation = await validateMeta({
-    logger,
-    meta,
-    compiledFileUrl,
-    ifEtagMatch,
-    ifModifiedSinceDate,
-    compileCacheSourcesValidation,
-    compileCacheAssetsValidation,
-  })
+    const metaIsValid = cacheValidity.meta.isValid
 
-  if (!metaValidation.valid) {
     const [compileTiming, compileResult] = await timeFunction("compile", () =>
       callCompile({
         logger,
@@ -175,34 +152,35 @@ const computeCompileReport = async ({
         compile,
       }),
     )
+
     return {
-      meta,
+      meta: metaIsValid ? cacheValidity.meta.data : null,
       compileResult,
-      compileResultStatus: "updated",
+      compileResultStatus: metaIsValid ? "updated" : "created",
       timing: {
-        ...cacheReadTiming,
-        ...metaValidation.timing,
+        ...readCacheTiming,
         ...compileTiming,
       },
     }
   }
 
+  const meta = cacheValidity.meta.data
   const { contentType, sources, assets } = meta
-  const { compiledSource, sourcesContent, assetsContent } = metaValidation.data
   return {
     meta,
     compileResult: {
+      compiledSource: String(
+        cacheValidity.compiledFile.data.compiledSourceBuffer,
+      ),
+      compiledEtag: cacheValidity.compiledFile.data.compiledEtag,
+      compiledMtime: cacheValidity.compiledFile.data.compiledMtime,
       contentType,
-      compiledSource,
       sources,
-      sourcesContent,
       assets,
-      assetsContent,
     },
     compileResultStatus: "cached",
     timing: {
-      ...cacheReadTiming,
-      ...metaValidation.timing,
+      ...readCacheTiming,
     },
   }
 }

package/src/internal/compiling/compile-directory/updateMeta.js

@@ -3,6 +3,7 @@ import {
   urlToFileSystemPath,
   bufferToEtag,
 } from "@jsenv/filesystem"
+import { utimesSync } from "node:fs"
 
 import { writeFileContent, testFilePresence } from "./fs-optimized-for-cache.js"
 import { getMetaJsonFileUrl } from "./compile-asset.js"
@@ -11,13 +12,11 @@ export const updateMeta = async ({
   logger,
   meta,
   compiledFileUrl,
-  cacheHitTracking,
   compileResult,
   compileResultStatus,
 }) => {
   const isNew = compileResultStatus === "created"
   const isUpdated = compileResultStatus === "updated"
-  const isCached = compileResultStatus === "cached"
   const {
     compiledSource,
     contentType,
@@ -65,6 +64,15 @@ ${sourcesToRemove.join(`\n`)}`)
       promises.push(
         writeFileContent(compiledFileUrl, compiledSource, {
           fileLikelyNotFound: isNew,
+        }).then(() => {
+          const mtime = compileResult.compiledMtime
+          // when compileResult.compiledMtime do not exists it means
+          // the client is not interested in it so
+          // -> moment we write the file is not important
+          // -> There is no need to update mtime
+          if (mtime) {
+            utimesSync(urlToFileSystemPath(compiledFileUrl), new Date(mtime), new Date(mtime))
+          }
         }),
       )
     }
@@ -85,7 +93,7 @@ ${sourcesToRemove.join(`\n`)}`)
 
   const metaJsonFileUrl = getMetaJsonFileUrl(compiledFileUrl)
 
-  if (isNew || isUpdated || (isCached && cacheHitTracking)) {
+  if (isNew || isUpdated) {
     let latestMeta
 
     const sourceAndAssetProps = {
@@ -120,14 +128,6 @@ ${sourcesToRemove.join(`\n`)}`)
       }
     }
 
-    if (cacheHitTracking) {
-      latestMeta = {
-        ...latestMeta,
-        matchCount: 1,
-        lastMatchMs: Number(Date.now()),
-      }
-    }
-
     logger.debug(
       `write compiled file meta at ${urlToFileSystemPath(metaJsonFileUrl)}`,
     )