@jsenv/core 25.3.0-alpha.0 → 25.4.2

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()
 

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

@@ -0,0 +1,174 @@
+import {
+  resolveUrl,
+  readFile,
+  writeFile,
+  ensureEmptyDirectory,
+} from "@jsenv/filesystem"
+
+import { compareCompileContexts } from "./compile_context.js"
+import { compareCompileProfiles } from "./compile_profile.js"
+
+export const setupJsenvDirectory = async ({
+  logger,
+  projectDirectoryUrl,
+  jsenvDirectoryRelativeUrl,
+  jsenvDirectoryClean,
+  compileServerCanWriteOnFilesystem,
+  compileContext,
+}) => {
+  const jsenvDirectoryUrl = resolveUrl(
+    jsenvDirectoryRelativeUrl,
+    projectDirectoryUrl,
+  )
+  const jsenvDirectoryMetaFileUrl = resolveUrl(
+    "__jsenv_meta__.json",
+    jsenvDirectoryUrl,
+  )
+  const compileDirectories = {}
+  const jsenvDirectoryMeta = {
+    jsenvDirectoryRelativeUrl,
+    compileContext,
+    compileDirectories,
+  }
+
+  const writeMetaFile = async () => {
+    await writeFile(
+      jsenvDirectoryMetaFileUrl,
+      JSON.stringify(jsenvDirectoryMeta, null, "  "),
+    )
+  }
+
+  if (compileServerCanWriteOnFilesystem) {
+    if (jsenvDirectoryClean) {
+      await ensureEmptyDirectory(jsenvDirectoryUrl)
+    }
+    await applyFileSystemEffects({
+      logger,
+      jsenvDirectoryUrl,
+      jsenvDirectoryMetaFileUrl,
+      writeMetaFile,
+      jsenvDirectoryMeta,
+    })
+  }
+
+  /*
+   * This function try to reuse existing compiled id
+   * (the goal being to reuse file that would be in a corresponding compile directory)
+   * To decide if we reuse a compile directory we need to know
+   * how the files inside that directory where generated
+   * and if what we want matches what we have, the compile id is reused
+   *
+   * Note: some parameters means only a subset of files would be invalid
+   * but to keep things simple the whole directory is ignored
+   */
+  const getOrCreateCompileId = async ({
+    runtimeName,
+    runtimeVersion,
+    compileProfile,
+  }) => {
+    const missingFeatureNames = Object.keys(compileProfile.missingFeatures)
+    if (missingFeatureNames.length === 0) {
+      return null
+    }
+    const existingCompileIds = Object.keys(compileDirectories)
+    const existingCompileId = existingCompileIds.find((compileIdCandidate) => {
+      const compileDirectoryCandidate = compileDirectories[compileIdCandidate]
+      return compareCompileProfiles(
+        compileDirectoryCandidate.compileProfile,
+        compileProfile,
+      )
+    })
+    const runtime = `${runtimeName}@${runtimeVersion}`
+    if (existingCompileId) {
+      const compileDirectory = compileDirectories[existingCompileId]
+      const { runtimes } = compileDirectory
+      if (!runtimes.includes(runtime)) {
+        runtimes.push(runtime)
+        await writeMetaFile()
+      }
+      return existingCompileId
+    }
+    const compileIdBase = generateCompileId({ compileProfile })
+    let compileId = compileIdBase
+    let integer = 1
+    while (existingCompileIds.includes(compileId)) {
+      compileId = `${compileIdBase}_${integer}`
+      integer++
+    }
+    compileDirectories[compileId] = {
+      compileProfile,
+      runtimes: [runtime],
+    }
+    await writeMetaFile()
+    return compileId
+  }
+
+  return {
+    compileDirectories,
+    getOrCreateCompileId,
+  }
+}
+
+const generateCompileId = ({ compileProfile }) => {
+  if (compileProfile.missingFeatures["transform-instrument"]) {
+    return `out_instrumented`
+  }
+  return `out`
+}
+
+const applyFileSystemEffects = async ({
+  logger,
+  jsenvDirectoryUrl,
+  jsenvDirectoryMetaFileUrl,
+  jsenvDirectoryMeta,
+  writeMetaFile,
+}) => {
+  try {
+    const source = await readFile(jsenvDirectoryMetaFileUrl)
+    if (source === "") {
+      logger.warn(
+        `${jsenvDirectoryMetaFileUrl} is empty -> clean ${jsenvDirectoryUrl} directory`,
+      )
+      await ensureEmptyDirectory(jsenvDirectoryUrl)
+      await writeMetaFile()
+      return
+    }
+    const jsenvDirectoryMetaPrevious = JSON.parse(source)
+    if (
+      !compareCompileContexts(
+        jsenvDirectoryMetaPrevious.compileContext,
+        jsenvDirectoryMeta.compileContext,
+      )
+    ) {
+      logger.debug(
+        `compile context has changed -> clean ${jsenvDirectoryUrl} directory`,
+      )
+      await ensureEmptyDirectory(jsenvDirectoryUrl)
+      await writeMetaFile()
+      return
+    }
+    // reuse existing compile directories
+    Object.assign(
+      jsenvDirectoryMeta.compileDirectories,
+      jsenvDirectoryMetaPrevious.compileDirectories,
+    )
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      logger.debug(
+        `${jsenvDirectoryMetaFileUrl} not found -> clean ${jsenvDirectoryUrl} directory`,
+      )
+      await ensureEmptyDirectory(jsenvDirectoryUrl)
+      await writeMetaFile()
+      return
+    }
+    if (e.name === "SyntaxError") {
+      logger.warn(
+        `${jsenvDirectoryMetaFileUrl} syntax error -> clean ${jsenvDirectoryUrl} directory`,
+      )
+      await ensureEmptyDirectory(jsenvDirectoryUrl)
+      await writeMetaFile()
+      return
+    }
+    throw e
+  }
+}

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

@@ -6,7 +6,7 @@ import {
 import { utimesSync } from "node:fs"
 
 import { writeFileContent, testFilePresence } from "./fs-optimized-for-cache.js"
-import { getMetaJsonFileUrl } from "./compile-asset.js"
+import { getMetaJsonFileUrl } from "./compile_asset.js"
 
 export const updateMeta = async ({
   logger,