@jsenv/core 26.0.1 → 27.0.0-alpha.2

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

@@ -1,217 +0,0 @@
-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,
-  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) {
-    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/compile_server/jsenv_directory/file_lock_registry.js

@@ -1,24 +0,0 @@
-export const createLockRegistry = () => {
-  let lockArray = []
-  const lockForRessource = async (ressource) => {
-    const currentLock = lockArray.find((lock) => lock.ressource === ressource)
-    let unlockResolve
-    const unlocked = new Promise((resolve) => {
-      unlockResolve = resolve
-    })
-    const lock = {
-      ressource,
-      unlocked,
-    }
-    lockArray = [...lockArray, lock]
-
-    if (currentLock) await currentLock.unlocked
-
-    const unlock = () => {
-      lockArray = lockArray.filter((lockCandidate) => lockCandidate !== lock)
-      unlockResolve()
-    }
-    return unlock
-  }
-  return { lockForRessource }
-}

package/src/internal/compile_server/jsenv_directory/file_lock_registry.test.js

@@ -1,47 +0,0 @@
-import { assert } from "@jsenv/assert"
-
-import { createLockRegistry } from "./file_lock_registry.js"
-
-// a second lock on same ressource await first one to be unlocked
-{
-  const lockRegistry = createLockRegistry()
-  const lockA1 = lockRegistry.lockForRessource()
-  const lockA2 = lockRegistry.lockForRessource()
-
-  let a2Resolved = false
-  lockA2.then(() => {
-    a2Resolved = true
-  })
-
-  const unlockA1 = await lockA1
-  assert({ actual: a2Resolved, expected: false })
-  unlockA1()
-  await lockA2
-}
-
-// concurrent lock on same ressource again
-{
-  const lockRegistry = createLockRegistry()
-  const lockA = lockRegistry.lockForRessource()
-  const lockB = lockRegistry.lockForRessource()
-  const lockC = lockRegistry.lockForRessource()
-
-  const unlockA = await lockA
-
-  unlockA()
-  const unlockB = await lockB
-  unlockB()
-  const unlockC = await lockC
-  unlockC()
-  await lockC
-}
-
-// lock on different ressources do not have to await each other
-{
-  const lockRegistry = createLockRegistry()
-  const lockA = lockRegistry.lockForRessource("a")
-  const lockB = lockRegistry.lockForRessource("b")
-
-  await lockA
-  await lockB
-}

package/src/internal/compile_server/jsenv_directory/fs_optimized_for_cache.js

@@ -1,57 +0,0 @@
-import { dirname } from "node:path"
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs"
-
-import { urlToFileSystemPath } from "@jsenv/filesystem"
-
-// readFileSync seems faster than readFile
-// and in our case we are talking about a dev server
-// in other words it's not super important to handle concurrent connections
-// https://gist.github.com/adamhooper/9e0e2583e0f22ace0e0840b9c09e395d
-// https://stackoverflow.com/questions/42321861/fs-readfile-is-very-slow-am-i-making-too-many-request
-export const readFileContent = async (url) => {
-  const buffer = readFileSync(urlToFileSystemPath(url))
-  return String(buffer)
-}
-
-export const writeFileContent = async (
-  url,
-  content,
-  { fileLikelyNotFound = false } = {},
-) => {
-  const filePath = urlToFileSystemPath(url)
-  const directoryPath = dirname(filePath)
-
-  const ensureParentDirectory = () => {
-    try {
-      mkdirSync(directoryPath, { recursive: true })
-    } catch (error) {
-      if (error.code === "EEXIST") {
-        return
-      }
-      throw error
-    }
-  }
-
-  if (fileLikelyNotFound) {
-    // whenever outside knows file is likely not exisiting
-    // ensure parent directory exists first
-    ensureParentDirectory()
-    writeFileSync(filePath, content)
-  } else {
-    // most of the time when you want to write a file it's likely existing (at least the parent directory)
-    try {
-      writeFileSync(filePath, content)
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        ensureParentDirectory()
-        writeFileSync(filePath, content)
-        return
-      }
-      throw error
-    }
-  }
-}
-
-export const testFilePresence = (url) => {
-  return existsSync(urlToFileSystemPath(url))
-}

package/src/internal/compile_server/jsenv_directory/jsenv_directory.js

@@ -1,183 +0,0 @@
-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, "  "),
-    )
-  }
-
-  const compiledFileWriteSignal = { onwrite: () => {} }
-  if (compileServerCanWriteOnFilesystem) {
-    if (jsenvDirectoryClean) {
-      await ensureEmptyDirectory(jsenvDirectoryUrl)
-    }
-    await applyFileSystemEffects({
-      logger,
-      jsenvDirectoryUrl,
-      jsenvDirectoryMetaFileUrl,
-      jsenvDirectoryMeta,
-    })
-    // We want ".jsenv" directory to appear on the filesystem only
-    // if there is a compiled file inside (and not immediatly when compile server starts)
-    // To do this we wait for a file to be written to write "__jsenv_meta__.json" file
-    compiledFileWriteSignal.onwrite = async () => {
-      compiledFileWriteSignal.onwrite = () => {}
-      await writeMetaFile()
-    }
-  }
-
-  /*
-   * 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)
-        writeMetaFile()
-      }
-      return existingCompileId
-    }
-    const compileIdBase = generateCompileId({ compileProfile, runtime })
-    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,
-    compiledFileWriteSignal,
-  }
-}
-
-const generateCompileId = ({ compileProfile, runtime }) => {
-  if (runtime.name === "jsenv_build") {
-    return `out_build`
-  }
-  if (compileProfile.missingFeatures["transform-instrument"]) {
-    return `out_instrumented`
-  }
-  if (compileProfile.moduleOutFormat === "systemjs") {
-    return `out_system`
-  }
-  return `out`
-}
-
-const applyFileSystemEffects = async ({
-  logger,
-  jsenvDirectoryUrl,
-  jsenvDirectoryMetaFileUrl,
-  jsenvDirectoryMeta,
-}) => {
-  try {
-    const source = await readFile(jsenvDirectoryMetaFileUrl)
-    if (source === "") {
-      logger.warn(
-        `${jsenvDirectoryMetaFileUrl} is empty -> clean ${jsenvDirectoryUrl} directory`,
-      )
-      await ensureEmptyDirectory(jsenvDirectoryUrl)
-      return
-    }
-    const jsenvDirectoryMetaPrevious = JSON.parse(source)
-    if (
-      !compareCompileContexts(
-        jsenvDirectoryMetaPrevious.compileContext,
-        jsenvDirectoryMeta.compileContext,
-      )
-    ) {
-      logger.debug(
-        `compile context has changed -> clean ${jsenvDirectoryUrl} directory`,
-      )
-      await ensureEmptyDirectory(jsenvDirectoryUrl)
-      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)
-      return
-    }
-    if (e.name === "SyntaxError") {
-      logger.warn(
-        `${jsenvDirectoryMetaFileUrl} syntax error -> clean ${jsenvDirectoryUrl} directory`,
-      )
-      await ensureEmptyDirectory(jsenvDirectoryUrl)
-      return
-    }
-    throw e
-  }
-}