@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/internal/compiling/jsenvCompilerForJavaScript.js

@@ -1,61 +0,0 @@
-import { generateSourcemapUrl } from "@jsenv/core/src/internal/sourceMappingURLUtils.js"
-
-import { transformJs } from "./js-compilation-service/transformJs.js"
-import { transformResultToCompilationResult } from "./transformResultToCompilationResult.js"
-
-export const compileJavascript = async ({
-  projectDirectoryUrl,
-  jsenvRemoteDirectory,
-  url,
-  compiledUrl,
-
-  compileProfile,
-  babelPluginMap,
-  topLevelAwait,
-  prependSystemJs,
-
-  code,
-  map,
-  sourcemapExcludeSources,
-  sourcemapMethod,
-}) => {
-  if (prependSystemJs === undefined) {
-    const { searchParams } = new URL(url)
-    prependSystemJs =
-      searchParams.has("worker") || searchParams.has("service_worker")
-  }
-  const transformResult = await transformJs({
-    projectDirectoryUrl,
-    jsenvRemoteDirectory,
-    url,
-    compiledUrl,
-
-    babelPluginMap,
-    moduleOutFormat: compileProfile.moduleOutFormat,
-    topLevelAwait,
-    prependSystemJs,
-
-    code,
-    map,
-  })
-  return transformResultToCompilationResult(
-    {
-      contentType: "application/javascript",
-      metadata: transformResult.metadata,
-      code: transformResult.code,
-      map: transformResult.map,
-    },
-    {
-      projectDirectoryUrl,
-      jsenvRemoteDirectory,
-      originalFileUrl: url,
-      compiledFileUrl: compiledUrl,
-      // sourcemap are not inside the asset folder because
-      // of https://github.com/microsoft/vscode-chrome-debug-core/issues/544
-      sourcemapFileUrl: generateSourcemapUrl(compiledUrl),
-      sourcemapExcludeSources,
-      sourcemapMethod,
-      originalFileContent: code,
-    },
-  )
-}

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

@@ -1,27 +0,0 @@
-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.length === secondArray.length &&
-    array.every((value) => secondArray.includes(value))
-  )
-}

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

@@ -1,24 +0,0 @@
-import { urlToFilename, urlToOrigin, urlToPathname } from "@jsenv/filesystem"
-
-export const urlIsCompilationAsset = (url) => {
-  const filename = urlToFilename(url)
-
-  // sourcemap are not inside the asset folder because
-  // of https://github.com/microsoft/vscode-chrome-debug-core/issues/544
-  if (filename.endsWith(".map")) {
-    return true
-  }
-
-  return filename.includes("__asset__")
-}
-
-export const getMetaJsonFileUrl = (compileFileUrl) =>
-  generateCompilationAssetUrl(compileFileUrl, "meta.json")
-
-export const generateCompilationAssetUrl = (compiledFileUrl, assetName) => {
-  // we want to remove eventual search params from url
-  const origin = urlToOrigin(compiledFileUrl)
-  const pathname = urlToPathname(compiledFileUrl)
-  const compilationAssetUrl = `${origin}${pathname}__asset__${assetName}`
-  return compilationAssetUrl
-}

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

@@ -1,60 +0,0 @@
-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 { sameValueInTwoObjects } from "./comparison_utils.js"
-
-const COMPARERS = {
-  preservedUrls: sameValueInTwoObjects,
-  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,
-  replaceProcessEnvNodeEnv,
-  inlineImportMapIntoHTML,
-}) => {
-  return {
-    preservedUrls,
-    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 jsenvCorePackage = await readFile(jsenvCorePackageFileUrl, {
-    as: "json",
-  })
-  const version = jsenvCorePackage.version
-  return version
-}

package/src/internal/compiling/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/compiling/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/compiling/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/compiling/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))
-}