@jsenv/core 23.6.0 → 23.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "23.6.0",
+  "version": "23.7.1",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {
@@ -50,6 +50,9 @@
     "prepublishOnly": "node ./script/publish/remove_postinstall.mjs && npm run dist",
     "postpublish": "node ./script/publish/restore_postinstall.mjs"
   },
+  "peerDependencies": {
+    "playwright": "1.x"
+  },
   "dependencies": {
     "@babel/core": "7.16.0",
     "@babel/helper-module-imports": "7.15.4",
@@ -94,7 +97,6 @@
     "node-fetch": "3.0.0",
     "parse5": "6.0.1",
     "pidtree": "0.5.0",
-    "playwright": "1.16.2",
     "postcss": "8.3.9",
     "postcss-value-parser": "4.1.0",
     "regenerator-runtime": "0.13.9",

package/src/buildProject.js

@@ -88,7 +88,7 @@ export const buildProject = async ({
   jsenvDirectoryRelativeUrl,
   jsenvDirectoryClean,
 
-  // when true .jsenv/out-build directory is generated
+  // when true .jsenv/build directory is generated
   // with all intermediated files used to produce the final build files.
   // it might improve buildProject speed for subsequent build generation
   // but this is to be proven and not absolutely required
@@ -158,7 +158,7 @@ export const buildProject = async ({
     // than exploring-server. This is because here we compile for rollup
     // that is expecting esmodule format, not systemjs
     // + some more differences like import.meta.dev
-    outDirectoryName: "out-build",
+    outDirectoryName: "build",
     importDefaultExtension,
     moduleOutFormat: "esmodule", // rollup will transform into systemjs
     importMetaFormat: format, // but ensure import.meta are correctly transformed into the right format

package/src/execute.js

@@ -99,7 +99,7 @@ export const execute = async ({
       projectDirectoryUrl,
       jsenvDirectoryRelativeUrl,
       jsenvDirectoryClean,
-      outDirectoryName: "out-dev",
+      outDirectoryName: "dev",
 
       importDefaultExtension,
 

package/src/internal/browser-launcher/jsenv-browser-system.js

@@ -141,7 +141,7 @@ const onExecutionError = (executionResult, { currentScript }) => {
 const getBrowserRuntime = memoize(async () => {
   const compileServerOrigin = document.location.origin
   const compileMetaResponse = await fetchUrl(
-    `${compileServerOrigin}/.jsenv/compile-meta.json`,
+    `${compileServerOrigin}/.jsenv/__compile_server_meta__.json`,
   )
   const compileMeta = await compileMetaResponse.json()
   const { outDirectoryRelativeUrl, errorStackRemapping } = compileMeta

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

@@ -137,7 +137,6 @@ const computeCompileReport = async ({
         logger,
         originalFileUrl,
         fileContentFallback,
-        request,
         compile,
       }),
     )
@@ -178,7 +177,6 @@ const callCompile = async ({
   logger,
   originalFileUrl,
   fileContentFallback,
-  request,
   compile,
 }) => {
   logger.debug(`compile ${originalFileUrl}`)
@@ -191,7 +189,6 @@ const callCompile = async ({
   const compileReturnValue = await compile({
     code: codeBeforeCompile,
     map: undefined,
-    request,
   })
   if (typeof compileReturnValue !== "object" || compileReturnValue === null) {
     throw new TypeError(

package/src/internal/compiling/compileFile.js

@@ -85,13 +85,7 @@ export const compileFile = async ({
       responseHeaders = {},
     } = compileResult
 
-    if (
-      compileResultStatus !== "cached" &&
-      compileCacheStrategy !== "none" &&
-      // a cutom compiler explicitely disables cache by returning "cache-control": "no-store"
-      // this file must not be cached on the filesystem and always re-generated
-      responseHeaders["cache-control"] !== "no-store"
-    ) {
+    if (compileResultStatus !== "cached" && compileCacheStrategy !== "none") {
       updateMeta({
         logger,
         meta,

package/src/internal/compiling/createCompiledFileService.js

@@ -86,9 +86,9 @@ export const createCompiledFileService = ({
     }
 
     const { compileId, afterCompileId } = requestCompileInfo
-    // serve files inside /.jsenv/out/* directly without compilation
+    // serve files inside /.jsenv/* directly without compilation
     // this is just to allow some files to be written inside outDirectory and read directly
-    // if asked by the client (such as env.json, groupMap.json, meta.json)
+    // if asked by the client (such __compile_server_meta__.json)
     if (!compileId) {
       return fetchFileSystem(
         new URL(request.ressource.slice(1), projectDirectoryUrl),
@@ -155,9 +155,8 @@ export const createCompiledFileService = ({
       compileCacheStrategy,
       projectFileRequestedCallback,
       request,
-      compile: ({ signal, code, map }) => {
+      compile: ({ code, map }) => {
         return compiler({
-          signal,
           logger,
 
           code,
@@ -168,6 +167,7 @@ export const createCompiledFileService = ({
           compileServerOrigin: request.origin,
           outDirectoryRelativeUrl,
           compileId,
+          request,
 
           runtimeSupport,
           moduleOutFormat,

package/src/internal/compiling/startCompileServer.js

@@ -256,7 +256,7 @@ export const startCompileServer = async ({
     }
   }
 
-  const outJSONFiles = createOutJSONFiles({
+  const compileServerMetaFileInfo = createCompileServerMetaFileInfo({
     projectDirectoryUrl,
     jsenvDirectoryRelativeUrl,
     outDirectoryRelativeUrl,
@@ -271,29 +271,28 @@ export const startCompileServer = async ({
     sourcemapExcludeSources,
   })
   if (compileServerCanWriteOnFilesystem) {
-    await setupOutDirectory({
+    await cleanOutDirectoryIfNeeded({
       logger,
-      outDirectoryMeta: outJSONFiles.meta.data,
       outDirectoryUrl,
       jsenvDirectoryUrl,
       jsenvDirectoryClean,
+      compileServerMetaFileInfo,
     })
+    writeFile(
+      compileServerMetaFileInfo.url,
+      JSON.stringify(compileServerMetaFileInfo.data, null, "  "),
+    )
+    logger.debug(`-> ${compileServerMetaFileInfo.url}`)
   }
 
   const jsenvServices = {
     "service:compilation asset": createCompilationAssetFileService({
       projectDirectoryUrl,
     }),
-    "service:browser script": createBrowserScriptService({
+    "service:compile server meta": createCompileServerMetaService({
       projectDirectoryUrl,
-      outDirectoryRelativeUrl,
-    }),
-    "service:out files": await createOutFilesService({
-      logger,
-      projectDirectoryUrl,
-      compileServerCanWriteOnFilesystem,
       outDirectoryUrl,
-      outJSONFiles,
+      compileServerMetaFileInfo,
     }),
     "service: compile proxy": createCompileProxyService({
       projectDirectoryUrl,
@@ -458,12 +457,12 @@ const assertArguments = ({
   }
 }
 
-const setupOutDirectory = async ({
+const cleanOutDirectoryIfNeeded = async ({
   logger,
-  outDirectoryMeta,
   outDirectoryUrl,
   jsenvDirectoryClean,
   jsenvDirectoryUrl,
+  compileServerMetaFileInfo,
 }) => {
   if (jsenvDirectoryClean) {
     logger.debug(
@@ -471,24 +470,23 @@ const setupOutDirectory = async ({
     )
     await ensureEmptyDirectory(jsenvDirectoryUrl)
   }
-  const metaFileUrl = resolveUrl("./meta.json", outDirectoryUrl)
 
-  let previousOutDirectoryMeta
+  let previousCompileServerMeta
   try {
-    const source = await readFile(metaFileUrl)
-    previousOutDirectoryMeta = JSON.parse(source)
+    const source = await readFile(compileServerMetaFileInfo.url)
+    previousCompileServerMeta = JSON.parse(source)
   } catch (e) {
     if (e && e.code === "ENOENT") {
-      previousOutDirectoryMeta = null
+      previousCompileServerMeta = null
     } else {
       throw e
     }
   }
 
-  if (previousOutDirectoryMeta !== null) {
+  if (previousCompileServerMeta !== null) {
     const outDirectoryChanges = getOutDirectoryChanges(
-      previousOutDirectoryMeta,
-      outDirectoryMeta,
+      previousCompileServerMeta,
+      compileServerMetaFileInfo.data,
     )
 
     if (outDirectoryChanges) {
@@ -512,12 +510,15 @@ const setupOutDirectory = async ({
   }
 }
 
-const getOutDirectoryChanges = (previousOutDirectoryMeta, outDirectoryMeta) => {
+const getOutDirectoryChanges = (
+  previousCompileServerMeta,
+  compileServerMeta,
+) => {
   const changes = []
 
-  Object.keys(outDirectoryMeta).forEach((key) => {
-    const now = outDirectoryMeta[key]
-    const previous = previousOutDirectoryMeta[key]
+  Object.keys(compileServerMeta).forEach((key) => {
+    const now = compileServerMeta[key]
+    const previous = previousCompileServerMeta[key]
     if (!compareValueJson(now, previous)) {
       changes.push(key)
     }
@@ -528,7 +529,7 @@ const getOutDirectoryChanges = (previousOutDirectoryMeta, outDirectoryMeta) => {
   }
 
   // in case basic comparison from above is not enough
-  if (!compareValueJson(previousOutDirectoryMeta, outDirectoryMeta)) {
+  if (!compareValueJson(previousCompileServerMeta, compileServerMeta)) {
     return { somethingChanged: true }
   }
 
@@ -539,7 +540,6 @@ const compareValueJson = (left, right) => {
   return JSON.stringify(left) === JSON.stringify(right)
 }
 
-// eslint-disable-next-line valid-jsdoc
 /**
  * We need to get two things:
  * { projectFileRequestedCallback, trackMainAndDependencies }
@@ -869,46 +869,6 @@ const createCompilationAssetFileService = ({ projectDirectoryUrl }) => {
   }
 }
 
-const createBrowserScriptService = ({
-  projectDirectoryUrl,
-  outDirectoryRelativeUrl,
-}) => {
-  const sourcemapMainFileRelativeUrl = urlToRelativeUrl(
-    sourcemapMainFileInfo.url,
-    projectDirectoryUrl,
-  )
-  const sourcemapMappingFileRelativeUrl = urlToRelativeUrl(
-    sourcemapMappingFileInfo.url,
-    projectDirectoryUrl,
-  )
-
-  return (request) => {
-    if (
-      request.method === "GET" &&
-      request.ressource === "/.jsenv/compile-meta.json"
-    ) {
-      const body = JSON.stringify({
-        outDirectoryRelativeUrl,
-        errorStackRemapping: true,
-        sourcemapMainFileRelativeUrl,
-        sourcemapMappingFileRelativeUrl,
-      })
-
-      return {
-        status: 200,
-        headers: {
-          "cache-control": "no-store",
-          "content-type": "application/json",
-          "content-length": Buffer.byteLength(body),
-        },
-        body,
-      }
-    }
-
-    return null
-  }
-}
-
 const createSourceFileService = ({
   projectDirectoryUrl,
   projectFileRequestedCallback,
@@ -931,7 +891,7 @@ const createSourceFileService = ({
   }
 }
 
-const createOutJSONFiles = ({
+const createCompileServerMetaFileInfo = ({
   projectDirectoryUrl,
   jsenvDirectoryRelativeUrl,
   outDirectoryRelativeUrl,
@@ -947,13 +907,14 @@ const createOutJSONFiles = ({
   sourcemapMethod,
   sourcemapExcludeSources,
 }) => {
-  const outJSONFiles = {}
   const outDirectoryUrl = resolveUrl(
     outDirectoryRelativeUrl,
     projectDirectoryUrl,
   )
-
-  const metaOutFileUrl = resolveUrl("./meta.json", outDirectoryUrl)
+  const compileServerMetaFileUrl = resolveUrl(
+    "./__compile_server_meta__.json",
+    outDirectoryUrl,
+  )
   const jsenvCorePackageFileUrl = resolveUrl(
     "./package.json",
     jsenvCoreDirectoryUrl,
@@ -961,43 +922,40 @@ const createOutJSONFiles = ({
   const jsenvCorePackageFilePath = urlToFileSystemPath(jsenvCorePackageFileUrl)
   const jsenvCorePackageVersion = readPackage(jsenvCorePackageFilePath).version
   const customCompilerPatterns = Object.keys(customCompilers)
-  const outDirectoryMeta = {
-    jsenvCorePackageVersion,
+  const sourcemapMainFileRelativeUrl = urlToRelativeUrl(
+    sourcemapMainFileInfo.url,
+    projectDirectoryUrl,
+  )
+  const sourcemapMappingFileRelativeUrl = urlToRelativeUrl(
+    sourcemapMappingFileInfo.url,
+    projectDirectoryUrl,
+  )
+  const compileServerMeta = {
+    jsenvDirectoryRelativeUrl,
+    outDirectoryRelativeUrl,
+    importDefaultExtension,
+
     babelPluginMap: babelPluginMapAsData(babelPluginMap),
     compileServerGroupMap,
+    customCompilerPatterns,
     replaceProcessEnvNodeEnv,
     processEnvNodeEnv,
-    customCompilerPatterns,
-    jsenvToolbarInjection,
+    inlineImportMapIntoHTML,
+
     sourcemapMethod,
     sourcemapExcludeSources,
-  }
-  outJSONFiles.meta = {
-    url: metaOutFileUrl,
-    data: outDirectoryMeta,
-  }
+    sourcemapMainFileRelativeUrl,
+    sourcemapMappingFileRelativeUrl,
+    errorStackRemapping: true,
 
-  const envOutFileUrl = resolveUrl("./env.json", outDirectoryUrl)
-  env = {
-    ...env,
-    jsenvDirectoryRelativeUrl,
-    outDirectoryRelativeUrl,
-    importDefaultExtension,
-    inlineImportMapIntoHTML,
-    customCompilerPatterns,
-  }
-  outJSONFiles.env = {
-    url: envOutFileUrl,
-    data: env,
+    jsenvCorePackageVersion,
+    jsenvToolbarInjection,
+    env,
   }
-
-  const groupMapOutFileUrl = resolveUrl("./groupMap.json", outDirectoryUrl)
-  outJSONFiles.groupMap = {
-    url: groupMapOutFileUrl,
-    data: compileServerGroupMap,
+  return {
+    url: compileServerMetaFileUrl,
+    data: compileServerMeta,
   }
-
-  return outJSONFiles
 }
 
 const babelPluginMapAsData = (babelPluginMap) => {
@@ -1019,14 +977,12 @@ const babelPluginMapAsData = (babelPluginMap) => {
   return data
 }
 
-const createOutFilesService = async ({
-  logger,
+const createCompileServerMetaService = ({
   projectDirectoryUrl,
-  compileServerCanWriteOnFilesystem,
   outDirectoryUrl,
-  outJSONFiles,
+  compileServerMetaFileInfo,
 }) => {
-  const isOutRootFile = (url) => {
+  const isCompileServerMetaFile = (url) => {
     if (!urlIsInsideOf(url, outDirectoryUrl)) {
       return false
     }
@@ -1037,64 +993,29 @@ const createOutFilesService = async ({
     return true
   }
 
-  if (compileServerCanWriteOnFilesystem) {
-    await Promise.all(
-      Object.keys(outJSONFiles).map(async (name) => {
-        const outJSONFile = outJSONFiles[name]
-        await writeFile(
-          outJSONFile.url,
-          JSON.stringify(outJSONFile.data, null, "  "),
-        )
-        logger.debug(`-> ${outJSONFile.url}`)
-      }),
-    )
-
-    return async (request) => {
-      const requestUrl = resolveUrl(
-        request.ressource.slice(1),
-        projectDirectoryUrl,
-      )
-      if (!isOutRootFile(requestUrl)) {
-        return null
-      }
-      return fetchFileSystem(
-        new URL(request.ressource.slice(1), projectDirectoryUrl),
-        {
-          headers: request.headers,
-          etagEnabled: true,
-        },
-      )
-    }
-  }
   // serve from memory
   return (request) => {
     const requestUrl = resolveUrl(
       request.ressource.slice(1),
       projectDirectoryUrl,
     )
-    if (!isOutRootFile(requestUrl)) {
-      return null
-    }
-
-    const outJSONFileKey = Object.keys(outJSONFiles).find((name) => {
-      return outJSONFiles[name].url === requestUrl
-    })
-    if (!outJSONFileKey) {
+    if (
+      isCompileServerMetaFile(requestUrl) ||
+      // allow to request it directly from .jsenv
+      request.ressource === "/.jsenv/__compile_server_meta__.json"
+    ) {
+      const body = JSON.stringify(compileServerMetaFileInfo.data, null, "  ")
       return {
-        status: 404,
+        status: 200,
+        headers: {
+          "content-type": urlToContentType(requestUrl),
+          "content-length": Buffer.byteLength(body),
+        },
+        body,
       }
     }
 
-    const outJSONFile = outJSONFiles[outJSONFileKey]
-    const body = JSON.stringify(outJSONFile.data, null, "  ")
-    return {
-      status: 200,
-      headers: {
-        "content-type": urlToContentType(requestUrl),
-        "content-length": Buffer.byteLength(body),
-      },
-      body,
-    }
+    return null
   }
 }
 

package/src/internal/executing/coverage/babel_plugin_instrument.js

@@ -1,90 +1,90 @@
-import {
-  resolveUrl,
-  normalizeStructuredMetaMap,
-  urlToMeta,
-} from "@jsenv/filesystem"
-
-import { require } from "../../require.js"
-
-// https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
-
-export const babelPluginInstrument = (api, options) => {
-  const { programVisitor } = require("istanbul-lib-instrument")
-
-  const { types } = api
-  const {
-    useInlineSourceMaps = false,
-    projectDirectoryUrl,
-    coverageConfig = { "./**/*": true },
-  } = options
-
-  const structuredMetaMapForCover = normalizeStructuredMetaMap(
-    {
-      cover: coverageConfig,
-    },
-    projectDirectoryUrl,
-  )
-  const shouldInstrument = (relativeUrl) => {
-    return urlToMeta({
-      url: resolveUrl(relativeUrl, projectDirectoryUrl),
-      structuredMetaMap: structuredMetaMapForCover,
-    }).cover
-  }
-
-  return {
-    name: "transform-instrument",
-    visitor: {
-      Program: {
-        enter(path) {
-          const { file } = this
-          const { opts } = file
-
-          const relativeUrl = optionsToRelativeUrl(opts)
-          if (!relativeUrl) {
-            console.warn("file without relativeUrl", relativeUrl)
-            return
-          }
-          if (!shouldInstrument(relativeUrl)) return
-
-          this.__dv__ = null
-
-          let inputSourceMap
-
-          if (useInlineSourceMaps) {
-            // https://github.com/istanbuljs/babel-plugin-istanbul/commit/a9e15643d249a2985e4387e4308022053b2cd0ad#diff-1fdf421c05c1140f6d71444ea2b27638R65
-            inputSourceMap =
-              opts.inputSourceMap || file.inputMap
-                ? file.inputMap.sourcemap
-                : null
-          } else {
-            inputSourceMap = opts.inputSourceMap
-          }
-
-          this.__dv__ = programVisitor(
-            types,
-            opts.filenameRelative || opts.filename,
-            {
-              coverageVariable: "__coverage__",
-              inputSourceMap,
-            },
-          )
-          this.__dv__.enter(path)
-        },
-
-        exit(path) {
-          if (!this.__dv__) {
-            return
-          }
-          const object = this.__dv__.exit(path)
-          // object got two properties: fileCoverage and sourceMappingURL
-          this.file.metadata.coverage = object.fileCoverage
-        },
-      },
-    },
-  }
-}
-
-const optionsToRelativeUrl = ({ filenameRelative }) => {
-  if (filenameRelative) return filenameRelative
-  return ""
-}
+import {
+  resolveUrl,
+  normalizeStructuredMetaMap,
+  urlToMeta,
+} from "@jsenv/filesystem"
+
+import { require } from "../../require.js"
+
+// https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
+
+export const babelPluginInstrument = (api, options) => {
+  const { programVisitor } = require("istanbul-lib-instrument")
+
+  const { types } = api
+  const {
+    useInlineSourceMaps = false,
+    projectDirectoryUrl,
+    coverageConfig = { "./**/*": true },
+  } = options
+
+  const structuredMetaMapForCover = normalizeStructuredMetaMap(
+    {
+      cover: coverageConfig,
+    },
+    projectDirectoryUrl,
+  )
+  const shouldInstrument = (relativeUrl) => {
+    return urlToMeta({
+      url: resolveUrl(relativeUrl, projectDirectoryUrl),
+      structuredMetaMap: structuredMetaMapForCover,
+    }).cover
+  }
+
+  return {
+    name: "transform-instrument",
+    visitor: {
+      Program: {
+        enter(path) {
+          const { file } = this
+          const { opts } = file
+
+          const relativeUrl = optionsToRelativeUrl(opts)
+          if (!relativeUrl) {
+            console.warn("file without relativeUrl", relativeUrl)
+            return
+          }
+          if (!shouldInstrument(relativeUrl)) return
+
+          this.__dv__ = null
+
+          let inputSourceMap
+
+          if (useInlineSourceMaps) {
+            // https://github.com/istanbuljs/babel-plugin-istanbul/commit/a9e15643d249a2985e4387e4308022053b2cd0ad#diff-1fdf421c05c1140f6d71444ea2b27638R65
+            inputSourceMap =
+              opts.inputSourceMap || file.inputMap
+                ? file.inputMap.sourcemap
+                : null
+          } else {
+            inputSourceMap = opts.inputSourceMap
+          }
+
+          this.__dv__ = programVisitor(
+            types,
+            opts.filenameRelative || opts.filename,
+            {
+              coverageVariable: "__coverage__",
+              inputSourceMap,
+            },
+          )
+          this.__dv__.enter(path)
+        },
+
+        exit(path) {
+          if (!this.__dv__) {
+            return
+          }
+          const object = this.__dv__.exit(path)
+          // object got two properties: fileCoverage and sourceMappingURL
+          this.file.metadata.coverage = object.fileCoverage
+        },
+      },
+    },
+  }
+}
+
+const optionsToRelativeUrl = ({ filenameRelative }) => {
+  if (filenameRelative) return filenameRelative
+  return ""
+}