@jsenv/core 25.2.0 → 25.4.0

package/src/internal/compiling/jsenvCompilerForHtml.js

@@ -36,7 +36,7 @@ import {
   visitHtmlAst,
   addHtmlNodeAttribute,
 } from "./compileHtml.js"
-import { generateCompilationAssetUrl } from "./compile-directory/compile-asset.js"
+import { generateCompilationAssetUrl } from "./jsenv_directory/compile_asset.js"
 
 export const compileHtml = async ({
   // cancellationToken,
@@ -46,12 +46,11 @@ export const compileHtml = async ({
   projectDirectoryUrl,
   jsenvRemoteDirectory,
   compileServerOrigin,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
 
+  compileProfile,
   compileId,
   babelPluginMap,
-  moduleOutFormat,
-  importMetaFormat,
   topLevelAwait,
   jsenvScriptInjection = true,
   jsenvEventSourceClientInjection,
@@ -61,7 +60,7 @@ export const compileHtml = async ({
   sourcemapMethod,
   code,
 }) => {
-  const compileDirectoryUrl = `${projectDirectoryUrl}${outDirectoryRelativeUrl}${compileId}/`
+  const compileDirectoryUrl = `${projectDirectoryUrl}${jsenvDirectoryRelativeUrl}${compileId}/`
   const browserRuntimeBuildUrlRelativeToProject = urlToRelativeUrl(
     BROWSER_RUNTIME_BUILD_URL,
     projectDirectoryUrl,
@@ -133,7 +132,7 @@ export const compileHtml = async ({
       specifier,
     })
   }
-  if (moduleOutFormat !== "esmodule") {
+  if (compileProfile.moduleOutFormat !== "esmodule") {
     const ressourceHints = collectRessourceHints(htmlAst)
     await visitRessourceHints({
       ressourceHints,
@@ -141,13 +140,15 @@ export const compileHtml = async ({
     })
   }
   await visitImportmapScript({
-    htmlAst,
     logger,
     url,
     compiledUrl,
     projectDirectoryUrl,
     compileDirectoryUrl,
-    moduleOutFormat,
+
+    compileProfile,
+
+    htmlAst,
     scripts,
     addHtmlMutation,
     addHtmlSourceFile,
@@ -161,9 +162,8 @@ export const compileHtml = async ({
     url,
     compiledUrl,
 
+    compileProfile,
     babelPluginMap,
-    moduleOutFormat,
-    importMetaFormat,
     topLevelAwait,
     sourcemapMethod,
 
@@ -246,13 +246,15 @@ const visitRessourceHints = async ({ ressourceHints, addHtmlMutation }) => {
 }
 
 const visitImportmapScript = async ({
-  htmlAst,
   logger,
   url,
   compiledUrl,
   projectDirectoryUrl,
   compileDirectoryUrl,
-  moduleOutFormat,
+
+  compileProfile,
+
+  htmlAst,
   scripts,
   addHtmlMutation,
   addHtmlSourceFile,
@@ -280,7 +282,7 @@ const visitImportmapScript = async ({
         scriptInjections: [
           {
             type:
-              moduleOutFormat === "systemjs"
+              compileProfile.moduleOutFormat === "systemjs"
                 ? "systemjs-importmap"
                 : "importmap",
             text: defaultImportMapAsText,
@@ -330,7 +332,7 @@ const visitImportmapScript = async ({
     addHtmlMutation(() => {
       removeHtmlNodeAttribute(firstImportmapScript, srcAttribute)
       setHtmlNodeText(firstImportmapScript, importmapAsText)
-      if (moduleOutFormat === "systemjs") {
+      if (compileProfile.moduleOutFormat === "systemjs") {
         const typeAttribute = getHtmlNodeAttributeByName(
           firstImportmapScript,
           "type",
@@ -357,7 +359,7 @@ const visitImportmapScript = async ({
   addHtmlMutation(() => {
     removeHtmlNodeAttribute(firstImportmapScript, srcAttribute)
     setHtmlNodeText(firstImportmapScript, importmapAsText)
-    if (moduleOutFormat === "systemjs") {
+    if (compileProfile.moduleOutFormat === "systemjs") {
       const typeAttribute = getHtmlNodeAttributeByName(
         firstImportmapScript,
         "type",
@@ -371,14 +373,13 @@ const visitImportmapScript = async ({
 const visitScripts = async ({
   logger,
   projectDirectoryUrl,
-  compileServerOrigin,
   jsenvRemoteDirectory,
+  compileServerOrigin,
   url,
   compiledUrl,
 
+  compileProfile,
   babelPluginMap,
-  moduleOutFormat,
-  importMetaFormat,
   topLevelAwait,
   sourcemapMethod,
 
@@ -398,7 +399,7 @@ const visitScripts = async ({
     if (type === "module") {
       if (src) {
         addHtmlMutation(() => {
-          if (moduleOutFormat === "systemjs") {
+          if (compileProfile.moduleOutFormat === "systemjs") {
             removeHtmlNodeAttribute(script, typeAttribute)
           }
           if (integrityAttribute) {
@@ -406,7 +407,7 @@ const visitScripts = async ({
           }
           removeHtmlNodeAttribute(script, srcAttribute)
           const jsenvMethod =
-            moduleOutFormat === "systemjs"
+            compileProfile.moduleOutFormat === "systemjs"
               ? "executeFileUsingSystemJs"
               : "executeFileUsingDynamicImport"
           let specifier
@@ -427,7 +428,6 @@ const visitScripts = async ({
         })
         return
       }
-
       const scriptId = getIdForInlineHtmlNode(script, scripts)
       const inlineScriptName = `${scriptId}.js`
       const scriptOriginalUrl = resolveUrl(inlineScriptName, url)
@@ -443,9 +443,8 @@ const visitScripts = async ({
           compiledUrl: scriptCompiledUrl,
 
           type: "module",
+          compileProfile,
           babelPluginMap,
-          moduleOutFormat,
-          importMetaFormat,
           topLevelAwait,
 
           sourcemapMethod,
@@ -454,12 +453,12 @@ const visitScripts = async ({
       })
       const specifier = `./${urlToRelativeUrl(scriptCompiledUrl, compiledUrl)}`
       addHtmlMutation(() => {
-        if (moduleOutFormat === "systemjs") {
+        if (compileProfile.moduleOutFormat === "systemjs") {
           removeHtmlNodeAttribute(script, typeAttribute)
         }
         removeHtmlNodeAttribute(script, srcAttribute)
         const jsenvMethod =
-          moduleOutFormat === "systemjs"
+          compileProfile.moduleOutFormat === "systemjs"
             ? "executeFileUsingSystemJs"
             : "executeFileUsingDynamicImport"
         setHtmlNodeText(
@@ -491,7 +490,10 @@ const visitScripts = async ({
         if (fileIsInsideJsenvDistDirectory) {
           return
         }
-
+        const isRemoteUrl = jsenvRemoteDirectory.isRemoteUrl(src)
+        if (isRemoteUrl && jsenvRemoteDirectory.isPreservedUrl(src)) {
+          return
+        }
         const scriptCompiledUrl = generateCompilationAssetUrl(
           compiledUrl,
           urlToFilename(scriptOriginalUrl),
@@ -501,6 +503,7 @@ const visitScripts = async ({
           // the transformation here and not in compile server
           // (because compile server would think it's a module script
           // and add things like systemjs)
+          // we could take into account the integrity her
           const scriptResponse = await fetchUrl(scriptOriginalUrl)
           if (scriptResponse.status !== 200) {
             logger.warn(
@@ -528,9 +531,8 @@ const visitScripts = async ({
             compiledUrl: scriptCompiledUrl,
 
             type: "classic",
+            compileProfile,
             babelPluginMap,
-            moduleOutFormat,
-            importMetaFormat,
             topLevelAwait,
 
             sourcemapMethod,
@@ -563,9 +565,8 @@ const visitScripts = async ({
           compiledUrl: scriptCompiledUrl,
 
           type: "classic",
+          compileProfile,
           babelPluginMap,
-          moduleOutFormat,
-          importMetaFormat,
           topLevelAwait,
 
           code: textNode.value,
@@ -588,9 +589,8 @@ const transformHtmlScript = async ({
   compiledUrl,
 
   type,
+  compileProfile,
   babelPluginMap,
-  moduleOutFormat,
-  importMetaFormat,
   topLevelAwait,
 
   code,
@@ -605,8 +605,8 @@ const transformHtmlScript = async ({
       compiledUrl,
 
       babelPluginMap,
-      moduleOutFormat: type === "module" ? moduleOutFormat : "global",
-      importMetaFormat,
+      moduleOutFormat:
+        type === "module" ? compileProfile.moduleOutFormat : "global",
       topLevelAwait: type === "module" ? topLevelAwait : false,
       babelHelpersInjectionAsImport: type === "module" ? undefined : false,
 

package/src/internal/compiling/jsenvCompilerForImportmap.js

@@ -7,12 +7,12 @@ export const compileImportmap = async ({
   url,
   compiledUrl,
   projectDirectoryUrl,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
   compileId,
 }) => {
   const jsenvImportmap = getDefaultImportmap(compiledUrl, {
     projectDirectoryUrl,
-    compileDirectoryUrl: `${projectDirectoryUrl}${outDirectoryRelativeUrl}${compileId}/`,
+    compileDirectoryUrl: `${projectDirectoryUrl}${jsenvDirectoryRelativeUrl}${compileId}/`,
   })
   const projectImportmap = JSON.parse(code)
   const importmap = composeTwoImportMaps(jsenvImportmap, projectImportmap)

package/src/internal/compiling/jsenvCompilerForJavaScript.js

@@ -9,11 +9,10 @@ export const compileJavascript = async ({
   url,
   compiledUrl,
 
+  compileProfile,
   babelPluginMap,
   workerUrls,
   serviceWorkerUrls,
-  moduleOutFormat,
-  importMetaFormat,
   topLevelAwait,
   prependSystemJs,
 
@@ -33,8 +32,7 @@ export const compileJavascript = async ({
     compiledUrl,
 
     babelPluginMap,
-    moduleOutFormat,
-    importMetaFormat,
+    moduleOutFormat: compileProfile.moduleOutFormat,
     topLevelAwait,
     prependSystemJs,
 

package/src/internal/compiling/jsenv_directory/comparison_utils.js

@@ -0,0 +1,24 @@
+export const sameValueInTwoObjects = (object, secondObject) => {
+  const objectKeys = Object.keys(object)
+  const secondObjectKeys = Object.keys(secondObject)
+  if (!sameValuesInTwoArrays(objectKeys, secondObjectKeys)) {
+    return false
+  }
+  return objectKeys.every((key) => {
+    const objectKeyValue = object[key]
+    const secondObjectKeyValue = secondObject[key]
+    if (
+      typeof objectKeyValue === "object" &&
+      objectKeyValue !== null &&
+      typeof secondObjectKeyValue === "object" &&
+      secondObjectKeyValue !== null
+    ) {
+      return sameValueInTwoObjects(objectKeyValue, secondObjectKeyValue)
+    }
+    return objectKeyValue === secondObjectKeyValue
+  })
+}
+
+export const sameValuesInTwoArrays = (array, secondArray) => {
+  return array.every((value) => secondArray.includes(value))
+}

package/src/internal/compiling/jsenv_directory/compile_context.js

@@ -0,0 +1,68 @@
+import { resolveUrl, readFile } from "@jsenv/filesystem"
+
+import {
+  TOOLBAR_INJECTOR_BUILD_URL,
+  EVENT_SOURCE_CLIENT_BUILD_URL,
+  BROWSER_RUNTIME_BUILD_URL,
+} from "@jsenv/core/dist/build_manifest.js"
+import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/internal/jsenvCoreDirectoryUrl.js"
+
+import {
+  sameValuesInTwoArrays,
+  sameValueInTwoObjects,
+} from "./comparison_utils.js"
+
+const COMPARERS = {
+  preservedUrls: sameValueInTwoObjects,
+  workers: sameValuesInTwoArrays,
+  serviceWorkers: sameValuesInTwoArrays,
+  replaceProcessEnvNodeEnv: (a, b) => a === b,
+  inlineImportMapIntoHTML: (a, b) => a === b,
+
+  jsenvCorePackageVersion: (a, b) => a === b,
+  TOOLBAR_INJECTOR_BUILD_URL: (a, b) => a === b,
+  EVENT_SOURCE_CLIENT_BUILD_URL: (a, b) => a === b,
+  BROWSER_RUNTIME_BUILD_URL: (a, b) => a === b,
+}
+
+export const compareCompileContexts = (
+  compileContext,
+  secondCompileContext,
+) => {
+  return Object.keys(COMPARERS).every((key) => {
+    return COMPARERS[key](compileContext[key], secondCompileContext[key])
+  })
+}
+
+export const createCompileContext = async ({
+  preservedUrls,
+  workers,
+  serviceWorkers,
+  replaceProcessEnvNodeEnv,
+  inlineImportMapIntoHTML,
+}) => {
+  return {
+    preservedUrls,
+    workers,
+    serviceWorkers,
+    replaceProcessEnvNodeEnv,
+    inlineImportMapIntoHTML,
+
+    // when "jsenvCorePackageVersion" is different, it means compile logic may have changed
+    jsenvCorePackageVersion: await readJsenvCoreVersionFromPackageFile(),
+    TOOLBAR_INJECTOR_BUILD_URL,
+    EVENT_SOURCE_CLIENT_BUILD_URL,
+    BROWSER_RUNTIME_BUILD_URL,
+  }
+}
+
+const readJsenvCoreVersionFromPackageFile = async () => {
+  const jsenvCorePackageFileUrl = resolveUrl(
+    "./package.json",
+    jsenvCoreDirectoryUrl,
+  )
+  const jsenvCoreVersion = await readFile(jsenvCorePackageFileUrl, {
+    as: "json",
+  }).version
+  return jsenvCoreVersion
+}

package/src/internal/compiling/jsenv_directory/compile_profile.js

@@ -0,0 +1,218 @@
+import { featuresCompatFromRuntime } from "@jsenv/core/src/internal/features/features_compat_from_runtime.js"
+import { featuresCompatFromRuntimeSupport } from "@jsenv/core/src/internal/features/features_compat_from_runtime_support.js"
+
+import { sameValueInTwoObjects } from "./comparison_utils.js"
+
+const COMPARERS = {
+  missingFeatures: sameValueInTwoObjects,
+  preservedUrls: sameValueInTwoObjects,
+  moduleOutFormat: (a, b) => a === b,
+  sourcemapMethod: (a, b) => a === b,
+  sourcemapExcludeSources: (a, b) => a === b,
+  jsenvEventSourceClientInjection: (a, b) => a === b,
+  jsenvToolbarInjection: (a, b) => a === b,
+}
+
+export const createCompileProfile = ({
+  importDefaultExtension,
+  preservedUrls,
+  customCompilers,
+  babelPluginMapWithoutSyntax,
+  workerUrls,
+  importMapInWebWorkers,
+  moduleOutFormat,
+  sourcemapMethod,
+  sourcemapExcludeSources,
+  jsenvEventSourceClientInjection,
+  jsenvToolbarInjection,
+
+  runtimeReport,
+}) => {
+  const { env = {} } = runtimeReport
+
+  const features = {}
+  if (importDefaultExtension) {
+    features["import_default_extension"] = true
+  }
+  const customCompilerPatterns = Object.keys(customCompilers)
+  if (customCompilerPatterns.length > 0) {
+    features["custom_compiler_patterns"] = customCompilerPatterns
+  }
+  Object.keys(babelPluginMapWithoutSyntax).forEach((babelPluginName) => {
+    // if we need to be compatible only with node
+    // ignore "new-stylesheet-as-jsenv-import" and "transform-import-assertions"
+    // (we consider they won't be used in the code we are about to execute)
+    if (env.node && !env.browser) {
+      if (
+        babelPluginName === "new-stylesheet-as-jsenv-import" ||
+        babelPluginName === "transform-import-assertions"
+      ) {
+        return
+      }
+    }
+    features[babelPluginName] = babelPluginValueAsJSON(
+      babelPluginMapWithoutSyntax[babelPluginName],
+    )
+  })
+
+  if (env.browser) {
+    Object.assign(features, {
+      script_type_module: true,
+      import_dynamic: true,
+      top_level_await: true,
+      importmap: true,
+      import_assertion_type_json: true,
+      import_assertion_type_css: true,
+    })
+  }
+  if (env.browser && workerUrls.length > 0) {
+    features["worker_type_module"] = true
+  }
+  if (env.browser && importMapInWebWorkers) {
+    features["worker_importmap"] = true
+  }
+  const featureNames = Object.keys(features)
+
+  const supportedFeatureNames = []
+  const { featuresReport = {} } = runtimeReport
+  Object.keys(featuresReport).forEach((featureName) => {
+    if (featuresReport[featureName]) {
+      supportedFeatureNames.push(featureName)
+    }
+  })
+  const { name, version } = runtimeReport
+  if (name && version) {
+    const { availableFeatureNames } = featuresCompatFromRuntime({
+      runtimeName: name,
+      runtimeVersion: version,
+      featureNames,
+    })
+    availableFeatureNames.forEach((featureName) => {
+      const runtimeReportResult = featuresReport[featureName]
+      if (runtimeReportResult === undefined) {
+        supportedFeatureNames.push(featureName)
+      }
+    })
+  }
+  const { runtimeSupport } = runtimeReport
+  if (runtimeSupport) {
+    const { availableFeatureNames } = featuresCompatFromRuntimeSupport({
+      runtimeSupport,
+      featureNames,
+    })
+    availableFeatureNames.forEach((featureName) => {
+      const runtimeReportResult = featuresReport[featureName]
+      if (runtimeReportResult === undefined) {
+        supportedFeatureNames.push(featureName)
+      }
+    })
+  }
+  Object.keys(featureEffects).forEach((featureName) => {
+    if (featuresReport[featureName]) {
+      featureEffects[featureName]({
+        supportedFeatureNames,
+      })
+    }
+  })
+
+  const missingFeatures = {}
+  if (!runtimeReport.forceSource) {
+    featureNames.forEach((featureName) => {
+      const supported = supportedFeatureNames.includes(featureName)
+      if (supported) {
+        return
+      }
+      missingFeatures[featureName] = features[featureName]
+    })
+    if (moduleOutFormat === undefined) {
+      if (runtimeReport.moduleOutFormat) {
+        moduleOutFormat = runtimeReport.moduleOutFormat
+        if (moduleOutFormat !== "esmodule") {
+          missingFeatures["module_format"] = moduleOutFormat
+        }
+      } else {
+        const systemJsIsRequired =
+          featuresRelatedToSystemJs.some((featureName) => {
+            return Boolean(missingFeatures[featureName])
+          }) || !featuresReport["import_http"]
+        moduleOutFormat = systemJsIsRequired ? "systemjs" : "esmodule"
+      }
+    }
+    if (runtimeReport.forceCompilation) {
+      missingFeatures["compilation_forced"] = true
+    }
+  }
+  return {
+    missingFeatures,
+    preservedUrls,
+    moduleOutFormat,
+    sourcemapMethod,
+    sourcemapExcludeSources,
+    jsenvEventSourceClientInjection,
+    jsenvToolbarInjection,
+  }
+}
+
+const featuresRelatedToSystemJs = [
+  "script_type_module",
+  "import_dynamic",
+  "top_level_await",
+  "importmap",
+  "import_assertion_type_json",
+  "import_assertion_type_css",
+  "worker_type_module",
+  "worker_importmap",
+]
+
+const featureEffects = {
+  coverage_js: ({ supportedFeatureNames }) => {
+    supportedFeatureNames.push("transform-instrument")
+  },
+  new_stylesheet: ({ supportedFeatureNames }) => {
+    supportedFeatureNames.push("new-stylesheet-as-jsenv-import")
+  },
+}
+
+export const compareCompileProfiles = (
+  compileProfile,
+  secondCompileProfile,
+) => {
+  return Object.keys(COMPARERS).every((key) => {
+    return COMPARERS[key](compileProfile[key], secondCompileProfile[key])
+  })
+}
+
+export const shakeBabelPluginMap = ({ babelPluginMap, compileProfile }) => {
+  const babelPluginMapShaked = {}
+  const { missingFeatures } = compileProfile
+  Object.keys(babelPluginMap).forEach((babelPluginName) => {
+    if (missingFeatures[babelPluginName]) {
+      babelPluginMapShaked[babelPluginName] = babelPluginMap[babelPluginName]
+    }
+  })
+  Object.keys(babelPluginMap).forEach((key) => {
+    if (key.startsWith("syntax-")) {
+      babelPluginMapShaked[key] = babelPluginMap[key]
+    }
+    if (key === "transform-replace-expressions") {
+      babelPluginMapShaked[key] = babelPluginMap[key]
+    }
+  })
+  return babelPluginMapShaked
+}
+
+const babelPluginValueAsJSON = (babelPluginValue) => {
+  if (Array.isArray(babelPluginValue)) {
+    if (babelPluginValue.length === 1) {
+      return true
+    }
+    if (babelPluginValue.length === 2) {
+      return babelPluginValue[1]
+    }
+    return true
+  }
+  if (typeof babelPluginValue === "object") {
+    return babelPluginValue.options
+  }
+  return true
+}

package/src/internal/compiling/{compile-directory/createLockRegistry.test.js → jsenv_directory/file_lock_registry.test.js}

@@ -1,5 +1,6 @@
 import { assert } from "@jsenv/assert"
-import { createLockRegistry } from "./createLockRegistry.js"
+
+import { createLockRegistry } from "./file_lock_registry.js"
 
 // a second lock on same ressource await first one to be unlocked
 {

package/src/internal/compiling/{compile-directory → jsenv_directory}/getOrGenerateCompiledFile.js

@@ -3,8 +3,8 @@ import { urlToFileSystemPath, readFile } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/logger"
 
 import { validateCache } from "./validateCache.js"
-import { getMetaJsonFileUrl } from "./compile-asset.js"
-import { createLockRegistry } from "./createLockRegistry.js"
+import { getMetaJsonFileUrl } from "./compile_asset.js"
+import { createLockRegistry } from "./file_lock_registry.js"
 
 const { lockForRessource } = createLockRegistry()