@jsenv/core 25.2.1 → 25.4.1

package/src/buildProject.js

@@ -1,9 +1,7 @@
-import { createLogger, createDetailedMessage } from "@jsenv/logger"
 import { resolveDirectoryUrl } from "@jsenv/filesystem"
+import { createLogger, createDetailedMessage } from "@jsenv/logger"
 import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 
-import { shakeBabelPluginMap } from "@jsenv/core/src/internal/generateGroupMap/shake_babel_plugin_map.js"
-import { COMPILE_ID_BEST } from "@jsenv/core/src/internal/CONSTANTS.js"
 import {
   assertProjectDirectoryUrl,
   assertProjectDirectoryExists,
@@ -13,7 +11,11 @@ import { buildUsingRollup } from "@jsenv/core/src/internal/building/buildUsingRo
 import {
   jsenvBrowserRuntimeSupport,
   jsenvNodeRuntimeSupport,
-} from "@jsenv/core/src/internal/generateGroupMap/jsenvRuntimeSupport.js"
+} from "@jsenv/core/src/internal/runtime_support/jsenv_runtime_support.js"
+import {
+  isNodePartOfSupportedRuntimes,
+  isBrowserPartOfSupportedRuntimes,
+} from "@jsenv/core/src/internal/runtime_support/runtime_support.js"
 
 /**
  * Generate optimized version of source files into a directory
@@ -126,19 +128,15 @@ export const buildProject = async ({
       `format must be "systemjs" when importMapInWebWorkers is enabled`,
     )
   }
-
   projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
   await assertProjectDirectoryExists({ projectDirectoryUrl })
-
-  assertentryPoints({ entryPoints })
-
+  assertEntryPoints({ entryPoints })
   if (Object.keys(entryPoints).length === 0) {
     logger.error(`entryPoints is an empty object`)
     return {
       rollupBuilds: {},
     }
   }
-
   assertBuildDirectoryRelativeUrl({ buildDirectoryRelativeUrl })
   const buildDirectoryUrl = resolveDirectoryUrl(
     buildDirectoryRelativeUrl,
@@ -151,7 +149,6 @@ export const buildProject = async ({
 
   const buildOperation = Abort.startOperation()
   buildOperation.addAbortSignal(signal)
-
   if (handleSIGINT) {
     buildOperation.addAbortSource((abort) => {
       return raceProcessTeardownEvents(
@@ -162,7 +159,6 @@ export const buildProject = async ({
       )
     })
   }
-
   const compileServer = await startCompileServer({
     signal: buildOperation.signal,
     logLevel: compileServerLogLevel,
@@ -210,12 +206,26 @@ export const buildProject = async ({
     compileServerCanReadFromFilesystem: filesystemCache,
     compileServerCanWriteOnFilesystem: filesystemCache,
   })
-
   buildOperation.addEndCallback(async () => {
     await compileServer.stop(`build cleanup`)
   })
-
-  const { outDirectoryRelativeUrl, origin: compileServerOrigin } = compileServer
+  const node = isNodePartOfSupportedRuntimes(runtimeSupport)
+  const browser = isBrowserPartOfSupportedRuntimes(runtimeSupport)
+  const { compileId, compileProfile } =
+    await compileServer.createCompileIdFromRuntimeReport({
+      env: {
+        browser,
+        node,
+      },
+      name: "jsenv_build",
+      version: "1",
+      runtimeSupport,
+      // "rollup_plugin_jsenv.js" expects to hit the compile server
+      // so we force compilation by adding a fake feature called "force_compilation"
+      // one day we'll test how code behaves if zero transformations is required during
+      // the build and update code as needed
+      forceCompilation: true,
+    })
 
   try {
     const result = await buildUsingRollup({
@@ -224,9 +234,6 @@ export const buildProject = async ({
 
       entryPoints,
       projectDirectoryUrl,
-      compileServerOrigin,
-      compileDirectoryRelativeUrl: `${outDirectoryRelativeUrl}${COMPILE_ID_BEST}/`,
-      jsenvDirectoryRelativeUrl: compileServer.jsenvDirectoryRelativeUrl,
       buildDirectoryUrl,
       buildDirectoryClean,
       assetManifestFile,
@@ -244,19 +251,17 @@ export const buildProject = async ({
       systemJsUrl,
       globalName,
       globals,
-      babelPluginMap: shakeBabelPluginMap({
-        babelPluginMap: compileServer.babelPluginMap,
-        missingFeatureNames:
-          compileServer.compileServerGroupMap[COMPILE_ID_BEST]
-            .missingFeatureNames,
-      }),
-      runtimeSupport,
       workers,
       serviceWorkers,
       serviceWorkerFinalizer,
       classicWorkers,
       classicServiceWorkers,
-      importMapInWebWorkers,
+
+      node,
+      browser,
+      compileServer,
+      compileProfile,
+      compileId,
 
       urlVersioning,
       lineBreakNormalization,
@@ -287,7 +292,7 @@ export const buildProject = async ({
   }
 }
 
-const assertentryPoints = ({ entryPoints }) => {
+const assertEntryPoints = ({ entryPoints }) => {
   if (typeof entryPoints !== "object") {
     throw new TypeError(`entryPoints must be an object, got ${entryPoints}`)
   }

package/src/dev_server.js

@@ -1,11 +1,12 @@
+import { setupRoutes } from "@jsenv/server"
 import {
   normalizeStructuredMetaMap,
   collectFiles,
   urlToRelativeUrl,
 } from "@jsenv/filesystem"
-import { setupRoutes } from "@jsenv/server"
 
 import { REDIRECTOR_BUILD_URL } from "@jsenv/core/dist/build_manifest.js"
+import { setUrlSearchParamsDescriptor } from "@jsenv/core/src/internal/url_utils.js"
 import { jsenvCoreDirectoryUrl } from "./internal/jsenvCoreDirectoryUrl.js"
 import {
   assertProjectDirectoryUrl,
@@ -13,14 +14,13 @@ import {
 } from "./internal/argUtils.js"
 import {
   startCompileServer,
-  computeOutDirectoryRelativeUrl,
+  assertAndNormalizeJsenvDirectoryRelativeUrl,
 } from "./internal/compiling/startCompileServer.js"
-import { jsenvExplorableConfig } from "./jsenvExplorableConfig.js"
-
 import {
   sourcemapMainFileInfo,
   sourcemapMappingFileInfo,
 } from "./internal/jsenvInternalFiles.js"
+import { jsenvExplorableConfig } from "./jsenvExplorableConfig.js"
 
 export const startDevServer = async ({
   signal = new AbortController().signal,
@@ -28,7 +28,7 @@ export const startDevServer = async ({
   port,
   ip,
   protocol,
-  http2,
+  http2 = false, // disable by default for now because it is buggy on safari
   certificate,
   privateKey,
   plugins,
@@ -38,7 +38,6 @@ export const startDevServer = async ({
   explorableConfig = jsenvExplorableConfig,
   mainFileRelativeUrl,
   jsenvDirectoryRelativeUrl,
-  outDirectoryName = "dev",
   jsenvToolbar = true,
   livereloading = true,
   inlineImportMapIntoHTML = true,
@@ -66,7 +65,6 @@ export const startDevServer = async ({
 }) => {
   projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
   await assertProjectDirectoryExists({ projectDirectoryUrl })
-
   if (mainFileRelativeUrl === undefined) {
     mainFileRelativeUrl = urlToRelativeUrl(
       new URL(
@@ -76,13 +74,10 @@ export const startDevServer = async ({
       projectDirectoryUrl,
     )
   }
-
-  const outDirectoryRelativeUrl = computeOutDirectoryRelativeUrl({
+  jsenvDirectoryRelativeUrl = assertAndNormalizeJsenvDirectoryRelativeUrl({
     projectDirectoryUrl,
     jsenvDirectoryRelativeUrl,
-    outDirectoryName,
   })
-
   const compileServer = await startCompileServer({
     signal,
     handleSIGINT,
@@ -103,14 +98,14 @@ export const startDevServer = async ({
       }),
       "jsenv:exploring_json": createExploringJsonService({
         projectDirectoryUrl,
-        outDirectoryRelativeUrl,
+        jsenvDirectoryRelativeUrl,
         mainFileRelativeUrl,
         explorableConfig,
         livereloading,
       }),
       "jsenv:explorables_json": createExplorableJsonService({
         projectDirectoryUrl,
-        outDirectoryRelativeUrl,
+        jsenvDirectoryRelativeUrl,
         explorableConfig,
       }),
     },
@@ -120,7 +115,6 @@ export const startDevServer = async ({
     jsenvEventSourceClientInjection: true,
     jsenvToolbarInjection: jsenvToolbar,
     jsenvDirectoryRelativeUrl,
-    outDirectoryName,
     inlineImportMapIntoHTML,
 
     compileServerCanReadFromFilesystem,
@@ -155,20 +149,45 @@ const createRedirectorService = async ({
       return {
         status: 307,
         headers: {
-          location: `${request.origin}/${redirectorRelativeUrlForProject}?redirect=${redirectTarget}`,
+          location: setUrlSearchParamsDescriptor(
+            `${request.origin}/${redirectorRelativeUrlForProject}`,
+            {
+              redirect: redirectTarget,
+            },
+          ),
         },
       }
     },
+    // compile server (compiled file service to be precised)
+    // is already implementing this redirection when a compile id do not exists
+    // and "redirect" is not a valid compile id
+    // That being said I prefer to keep it to be explicit and shortcircuit the logic
     "/.jsenv/redirect/:rest*": (request) => {
       const redirectTarget = request.ressource.slice("/.jsenv/redirect/".length)
       return {
         status: 307,
         headers: {
-          location: `${
-            request.origin
-          }/${redirectorRelativeUrlForProject}?redirect=${encodeURIComponent(
-            redirectTarget,
-          )}`,
+          location: setUrlSearchParamsDescriptor(
+            `${request.origin}/${redirectorRelativeUrlForProject}`,
+            {
+              redirect: redirectTarget,
+            },
+          ),
+        },
+      }
+    },
+    "/.jsenv/force/:rest*": (request) => {
+      const redirectTarget = request.ressource.slice("/.jsenv/force/".length)
+      return {
+        status: 307,
+        headers: {
+          location: setUrlSearchParamsDescriptor(
+            `${request.origin}/${redirectorRelativeUrlForProject}`,
+            {
+              redirect: redirectTarget,
+              force_compilation: 1,
+            },
+          ),
         },
       }
     },
@@ -177,98 +196,98 @@ const createRedirectorService = async ({
 
 const createExploringJsonService = ({
   projectDirectoryUrl,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
   explorableConfig,
   livereloading,
   mainFileRelativeUrl,
 }) => {
   return (request) => {
     if (
-      request.ressource === "/.jsenv/exploring.json" &&
-      request.method === "GET"
+      request.ressource !== "/.jsenv/exploring.json" ||
+      request.method !== "GET"
     ) {
-      const data = {
+      return null
+    }
+    const data = {
+      projectDirectoryUrl,
+      jsenvDirectoryRelativeUrl,
+      jsenvCoreDirectoryRelativeUrl: urlToRelativeUrl(
+        jsenvCoreDirectoryUrl,
         projectDirectoryUrl,
-        outDirectoryRelativeUrl,
-        jsenvDirectoryRelativeUrl: urlToRelativeUrl(
-          jsenvCoreDirectoryUrl,
-          projectDirectoryUrl,
-        ),
-        exploringHtmlFileRelativeUrl: mainFileRelativeUrl,
-        sourcemapMainFileRelativeUrl: urlToRelativeUrl(
-          sourcemapMainFileInfo.url,
-          jsenvCoreDirectoryUrl,
-        ),
-        sourcemapMappingFileRelativeUrl: urlToRelativeUrl(
-          sourcemapMappingFileInfo.url,
-          jsenvCoreDirectoryUrl,
-        ),
-        explorableConfig,
-        livereloading,
-      }
-      const json = JSON.stringify(data)
-      return {
-        status: 200,
-        headers: {
-          "cache-control": "no-store",
-          "content-type": "application/json",
-          "content-length": Buffer.byteLength(json),
-        },
-        body: json,
-      }
+      ),
+      exploringHtmlFileRelativeUrl: mainFileRelativeUrl,
+      sourcemapMainFileRelativeUrl: urlToRelativeUrl(
+        sourcemapMainFileInfo.url,
+        jsenvCoreDirectoryUrl,
+      ),
+      sourcemapMappingFileRelativeUrl: urlToRelativeUrl(
+        sourcemapMappingFileInfo.url,
+        jsenvCoreDirectoryUrl,
+      ),
+      explorableConfig,
+      livereloading,
+    }
+    const json = JSON.stringify(data)
+    return {
+      status: 200,
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(json),
+      },
+      body: json,
     }
-    return null
   }
 }
 
 const createExplorableJsonService = ({
   projectDirectoryUrl,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
   explorableConfig,
 }) => {
   return async (request) => {
     if (
-      request.ressource === "/.jsenv/explorables.json" &&
-      request.method === "GET"
+      request.ressource !== "/.jsenv/explorables.json" ||
+      request.method !== "GET"
     ) {
-      const structuredMetaMapRelativeForExplorable = {}
-      Object.keys(explorableConfig).forEach((explorableGroup) => {
-        const explorableGroupConfig = explorableConfig[explorableGroup]
-        structuredMetaMapRelativeForExplorable[explorableGroup] = {
-          "**/.jsenv/": false, // temporary (in theory) to avoid visting .jsenv directory in jsenv itself
-          ...explorableGroupConfig,
-          [outDirectoryRelativeUrl]: false,
-        }
-      })
-      const structuredMetaMapForExplorable = normalizeStructuredMetaMap(
-        structuredMetaMapRelativeForExplorable,
-        projectDirectoryUrl,
-      )
-      const matchingFileResultArray = await collectFiles({
-        directoryUrl: projectDirectoryUrl,
-        structuredMetaMap: structuredMetaMapForExplorable,
-        predicate: (meta) =>
-          Object.keys(meta).some((explorableGroup) =>
-            Boolean(meta[explorableGroup]),
-          ),
-      })
-      const explorableFiles = matchingFileResultArray.map(
-        ({ relativeUrl, meta }) => ({
-          relativeUrl,
-          meta,
-        }),
-      )
-      const json = JSON.stringify(explorableFiles)
-      return {
-        status: 200,
-        headers: {
-          "cache-control": "no-store",
-          "content-type": "application/json",
-          "content-length": Buffer.byteLength(json),
-        },
-        body: json,
+      return null
+    }
+    const structuredMetaMapRelativeForExplorable = {}
+    Object.keys(explorableConfig).forEach((explorableGroup) => {
+      const explorableGroupConfig = explorableConfig[explorableGroup]
+      structuredMetaMapRelativeForExplorable[explorableGroup] = {
+        "**/.jsenv/": false, // temporary (in theory) to avoid visting .jsenv directory in jsenv itself
+        ...explorableGroupConfig,
+        [jsenvDirectoryRelativeUrl]: false,
       }
+    })
+    const structuredMetaMapForExplorable = normalizeStructuredMetaMap(
+      structuredMetaMapRelativeForExplorable,
+      projectDirectoryUrl,
+    )
+    const matchingFileResultArray = await collectFiles({
+      directoryUrl: projectDirectoryUrl,
+      structuredMetaMap: structuredMetaMapForExplorable,
+      predicate: (meta) =>
+        Object.keys(meta).some((explorableGroup) =>
+          Boolean(meta[explorableGroup]),
+        ),
+    })
+    const explorableFiles = matchingFileResultArray.map(
+      ({ relativeUrl, meta }) => ({
+        relativeUrl,
+        meta,
+      }),
+    )
+    const json = JSON.stringify(explorableFiles)
+    return {
+      status: 200,
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(json),
+      },
+      body: json,
     }
-    return null
   }
 }

package/src/execute.js

@@ -1,6 +1,6 @@
 import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 
-import { normalizeRuntimeSupport } from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
+import { normalizeRuntimeSupport } from "@jsenv/core/src/internal/runtime_support/runtime_support.js"
 import {
   assertProjectDirectoryUrl,
   assertProjectDirectoryExists,
@@ -61,14 +61,12 @@ export const execute = async ({
 }) => {
   projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
   await assertProjectDirectoryExists({ projectDirectoryUrl })
-
   if (typeof fileRelativeUrl !== "string") {
     throw new TypeError(
       `fileRelativeUrl must be a string, got ${fileRelativeUrl}`,
     )
   }
   fileRelativeUrl = fileRelativeUrl.replace(/\\/g, "/")
-
   if (typeof runtime !== "object") {
     throw new TypeError(`runtime must be an object, got ${runtime}`)
   }
@@ -77,7 +75,6 @@ export const execute = async ({
       `runtime.launch must be a function, got ${runtime.launch}`,
     )
   }
-
   const executeOperation = Abort.startOperation()
   executeOperation.addAbortSignal(signal)
   if (handleSIGINT) {
@@ -90,7 +87,6 @@ export const execute = async ({
       )
     })
   }
-
   try {
     const compileServer = await startCompileServer({
       signal: executeOperation.signal,
@@ -99,7 +95,6 @@ export const execute = async ({
       projectDirectoryUrl,
       jsenvDirectoryRelativeUrl,
       jsenvDirectoryClean,
-      outDirectoryName: "dev",
 
       importDefaultExtension,
 
@@ -133,7 +128,7 @@ export const execute = async ({
         projectDirectoryUrl,
         compileServerOrigin: compileServer.origin,
         compileServerId: compileServer.id,
-        outDirectoryRelativeUrl: compileServer.outDirectoryRelativeUrl,
+        jsenvDirectoryRelativeUrl: compileServer.jsenvDirectoryRelativeUrl,
         ...runtimeParams,
       },
       executeParams: {
@@ -161,7 +156,7 @@ export const execute = async ({
 
     if (collectCompileServerInfo) {
       result.compileServerOrigin = compileServer.origin
-      result.outDirectoryRelativeUrl = compileServer.outDirectoryRelativeUrl
+      result.jsenvDirectoryRelativeUrl = compileServer.jsenvDirectoryRelativeUrl
     }
 
     if (result.status === "errored") {

package/src/internal/browser_launcher/{browser_runtime_report.js → browser_runtime_profile.js}

@@ -1,34 +1,39 @@
-export const getBrowserRuntimeReport = async ({
+export const getBrowserRuntimeProfile = async ({
   page,
-  coverageHandledFromOutside,
   runtime,
   compileServerId,
+  coverageHandledFromOutside,
+  forceSource,
+  forceCompilation,
 }) => {
   const cache = cacheFromParams({
     runtime,
     compileServerId,
     coverageHandledFromOutside,
+    forceSource,
+    forceCompilation,
   })
   const entry = cache.read()
   if (entry) {
     return entry
   }
-  const browserRuntimeFeaturesReport = await page.evaluate(
+  const browserRuntimeProfile = await page.evaluate(
+    /* eslint-disable no-undef */
     /* istanbul ignore next */
-    async ({ coverageHandledFromOutside }) => {
-      // eslint-disable-next-line no-undef
+    async ({ coverageHandledFromOutside, forceSource, forceCompilation }) => {
       await window.readyPromise
-
-      // eslint-disable-next-line no-undef
-      return window.scanBrowserRuntimeFeatures({
+      const runtimeProfile = await window.scanBrowserRuntimeFeatures({
         coverageHandledFromOutside,
-        failFastOnFeatureDetection: true,
+        forceSource,
+        forceCompilation,
       })
+      return runtimeProfile
     },
-    { coverageHandledFromOutside },
+    /* eslint-enable no-undef */
+    { coverageHandledFromOutside, forceSource, forceCompilation },
   )
-  cache.write(browserRuntimeFeaturesReport)
-  return browserRuntimeFeaturesReport
+  cache.write(browserRuntimeProfile)
+  return browserRuntimeProfile
 }
 
 let currentCacheParams
@@ -37,13 +42,16 @@ const cacheFromParams = ({
   runtime,
   compileServerId,
   coverageHandledFromOutside,
+  forceSource,
+  forceCompilation,
 }) => {
   const params = {
     compileServerId,
     coverageHandledFromOutside,
+    forceSource,
+    forceCompilation,
   }
   const runtimeLabel = `${runtime.name}/${runtime.version}`
-
   if (!currentCacheParams) {
     currentCacheParams = params
     currentCacheValue = {}
@@ -54,7 +62,6 @@ const cacheFromParams = ({
       },
     }
   }
-
   if (JSON.stringify(currentCacheParams) !== JSON.stringify(params)) {
     return {
       read: () => null,
@@ -65,7 +72,6 @@ const cacheFromParams = ({
       },
     }
   }
-
   return {
     read: () => currentCacheValue[runtimeLabel],
     write: (value) => {