@jsenv/core 26.0.1 → 27.0.0-alpha.2

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

@@ -1,243 +0,0 @@
-import {
-  resolveUrl,
-  urlToRelativeUrl,
-  readFile,
-  ensureWindowsDriveLetter,
-  urlIsInsideOf,
-} from "@jsenv/filesystem"
-
-import {
-  replaceBackSlashesWithSlashes,
-  startsWithWindowsDriveLetter,
-  windowsFilePathToUrl,
-} from "@jsenv/core/src/internal/windows_file_path_utils.js"
-import {
-  setJavaScriptSourceMappingUrl,
-  setCssSourceMappingUrl,
-  sourcemapToBase64Url,
-} from "@jsenv/core/src/internal/sourcemap_utils.js"
-
-import { generateCompilationAssetUrl } from "./compile_asset.js"
-import { testFilePresence } from "./fs_optimized_for_cache.js"
-
-const isWindows = process.platform === "win32"
-
-export const asCompilationResult = async (
-  { contentType, metadata = {}, code, map },
-  {
-    projectDirectoryUrl,
-    jsenvRemoteDirectory,
-    originalFileUrl,
-    compiledFileUrl,
-    sourcemapFileUrl,
-    sourcemapEnabled = true,
-    // removing sourcesContent from map decrease the sourceMap
-    // it also means client have to fetch source from server (additional http request)
-    // some client ignore sourcesContent property such as vscode-chrome-debugger
-    // Because it's the most complex scenario and we want to ensure client is always able
-    // to find source from the sourcemap, it's a good idea
-    // to exclude sourcesContent from sourcemap.
-    // However some ressource are abstract and it means additional http request for the browser.
-    // For these reasons it's simpler to keep source content in sourcemap.
-    sourcemapExcludeSources = false,
-    sourcemapMethod = "comment", // "comment", "inline"
-    originalFileContent,
-  },
-) => {
-  if (typeof contentType !== "string") {
-    throw new TypeError(`contentType must be a string, got ${contentType}`)
-  }
-  if (typeof projectDirectoryUrl !== "string") {
-    throw new TypeError(
-      `projectDirectoryUrl must be a string, got ${projectDirectoryUrl}`,
-    )
-  }
-  if (typeof originalFileContent !== "string") {
-    throw new TypeError(
-      `originalFileContent must be a string, got ${originalFileContent}`,
-    )
-  }
-  if (typeof originalFileUrl !== "string") {
-    throw new TypeError(
-      `originalFileUrl must be a string, got ${originalFileUrl}`,
-    )
-  }
-  if (typeof compiledFileUrl !== "string") {
-    throw new TypeError(
-      `compiledFileUrl must be a string, got ${compiledFileUrl}`,
-    )
-  }
-  if (typeof sourcemapFileUrl !== "string") {
-    throw new TypeError(
-      `sourcemapFileUrl must be a string, got ${sourcemapFileUrl}`,
-    )
-  }
-
-  const sources = []
-  const sourcesContent = []
-  const assets = []
-  const assetsContent = []
-  const addSource = ({ url, content }) => {
-    sources.push(url)
-    sourcesContent.push(content)
-  }
-  const addAsset = ({ url, content }) => {
-    assets.push(url)
-    assetsContent.push(content)
-  }
-
-  let output = code
-  if (sourcemapEnabled && map) {
-    if (map.sources.length === 0) {
-      // may happen in some cases where babel returns a wrong sourcemap
-      // there is at least one case where it happens
-      // a file with only import './whatever.js' inside
-      addSource({
-        url: originalFileUrl,
-        content: originalFileContent,
-      })
-    } else {
-      map.sources.forEach((source, index) => {
-        const sourceFileUrl = resolveSourceFile({
-          source,
-          sourcemapFileUrl,
-          originalFileUrl,
-          compiledFileUrl,
-          projectDirectoryUrl,
-        })
-        if (sourceFileUrl) {
-          // In case the file comes from a remote url
-          // we prefer to consider remote url as the real source for this code
-          map.sources[index] =
-            jsenvRemoteDirectory &&
-            jsenvRemoteDirectory.isFileUrlForRemoteUrl(sourceFileUrl)
-              ? jsenvRemoteDirectory.remoteUrlFromFileUrl(sourceFileUrl)
-              : urlToRelativeUrl(sourceFileUrl, sourcemapFileUrl)
-          sources[index] = sourceFileUrl
-        }
-      })
-      if (sources.length === 0) {
-        // happens when sourcemap is generated by webpack and looks like
-        // webpack://Package./src/file.js
-        // in that case we'll don't know how to find the source file
-        addSource({
-          url: originalFileUrl,
-          content: originalFileContent,
-        })
-      }
-      await Promise.all(
-        sources.map(async (sourceUrl, index) => {
-          const contentFromSourcemap = map.sourcesContent
-            ? map.sourcesContent[index]
-            : null
-          if (contentFromSourcemap) {
-            sourcesContent[index] = contentFromSourcemap
-          } else {
-            const contentFromFile = await readFile(sourceUrl)
-            sourcesContent[index] = contentFromFile
-          }
-        }),
-      )
-    }
-
-    if (sourcemapExcludeSources) {
-      delete map.sourcesContent
-    }
-    // we don't need sourceRoot because our path are relative or absolute to the current location
-    // we could comment this line because it is not set by babel because not passed during transform
-    delete map.sourceRoot
-
-    const setSourceMappingUrl =
-      contentType === "application/javascript"
-        ? setJavaScriptSourceMappingUrl
-        : setCssSourceMappingUrl
-
-    if (sourcemapMethod === "inline") {
-      output = setSourceMappingUrl(output, sourcemapToBase64Url(map))
-    } else if (sourcemapMethod === "comment") {
-      const sourcemapFileRelativePathForModule = urlToRelativeUrl(
-        sourcemapFileUrl,
-        compiledFileUrl,
-      )
-      output = setSourceMappingUrl(output, sourcemapFileRelativePathForModule)
-      addAsset({
-        url: sourcemapFileUrl,
-        content: stringifyMap(map),
-      })
-    }
-  } else {
-    addSource({
-      url: originalFileUrl,
-      content: originalFileContent,
-    })
-  }
-
-  const { coverage } = metadata
-  if (coverage) {
-    const coverageAssetFileUrl = generateCompilationAssetUrl(
-      compiledFileUrl,
-      "coverage.json",
-    )
-    addAsset({
-      url: coverageAssetFileUrl,
-      content: stringifyCoverage(coverage),
-    })
-  }
-
-  const { dependencies = [] } = metadata
-
-  return {
-    contentType,
-    compiledSource: output,
-    sourcemap: map,
-    sources,
-    sourcesContent,
-    assets,
-    assetsContent,
-    dependencies,
-  }
-}
-
-const resolveSourceFile = ({
-  source,
-  sourcemapFileUrl,
-  originalFileUrl,
-  compiledFileUrl,
-  projectDirectoryUrl,
-}) => {
-  const sourceFileUrl = resolveSourceUrl({ source, sourcemapFileUrl })
-  if (!urlIsInsideOf(sourceFileUrl, projectDirectoryUrl)) {
-    // do not track dependency outside project
-    // it means cache stays valid for those external sources
-    return null
-  }
-  const fileFound = testFilePresence(sourceFileUrl)
-  if (fileFound) {
-    return sourceFileUrl
-  }
-  // prefer original source file
-  const relativeUrl = urlToRelativeUrl(sourceFileUrl, compiledFileUrl)
-  const originalSourceUrl = resolveUrl(relativeUrl, originalFileUrl)
-  return originalSourceUrl
-}
-
-const resolveSourceUrl = ({ source, sourcemapFileUrl }) => {
-  if (isWindows) {
-    // we can receive:
-    // - "C:/Directory/file.js" path from babel
-    // - relative path like "directory\file.js" (-> we replace \ with slash)
-    if (startsWithWindowsDriveLetter(source)) {
-      return windowsFilePathToUrl(source)
-    }
-    const url = resolveUrl(
-      replaceBackSlashesWithSlashes(source),
-      sourcemapFileUrl,
-    )
-    return ensureWindowsDriveLetter(url, sourcemapFileUrl)
-  }
-  return resolveUrl(source, sourcemapFileUrl)
-}
-
-const stringifyMap = (object) => JSON.stringify(object, null, "  ")
-
-const stringifyCoverage = (object) => JSON.stringify(object, null, "  ")

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

@@ -1,184 +0,0 @@
-/*
-
-One thing to keep in mind:
-the sourcemap.sourcesContent will contains a json file transformed to js
-while urlResponseBodyMap will contain the json file raw source because the corresponding
-json file etag is used to invalidate the cache
-
-*/
-
-import { readFileSync } from "node:fs"
-import {
-  urlToRelativeUrl,
-  urlToFileSystemPath,
-  resolveUrl,
-} from "@jsenv/filesystem"
-
-import { setJavaScriptSourceMappingUrl } from "@jsenv/core/src/internal/sourcemap_utils.js"
-
-export const compilationResultFromBuild = (
-  { rollupBuild, urlResponseBodyMap },
-  { mainFileName, projectDirectoryUrl, compiledFileUrl, sourcemapFileUrl },
-) => {
-  if (typeof projectDirectoryUrl !== "string") {
-    throw new TypeError(
-      `projectDirectoryUrl must be a string, got ${projectDirectoryUrl}`,
-    )
-  }
-  if (typeof compiledFileUrl !== "string") {
-    throw new TypeError(
-      `compiledFileUrl must be a string, got ${compiledFileUrl}`,
-    )
-  }
-  if (typeof sourcemapFileUrl !== "string") {
-    throw new TypeError(
-      `sourcemapFileUrl must be a string, got ${sourcemapFileUrl}`,
-    )
-  }
-
-  const sources = []
-  const sourcesContent = []
-
-  if (mainFileName === undefined) {
-    mainFileName = Object.keys(rollupBuild).find(
-      (key) => rollupBuild[key].isEntry,
-    )
-  }
-
-  const trackDependencies = (dependencyMap) => {
-    Object.keys(dependencyMap).forEach((moduleUrl) => {
-      // do not track dependency outside project
-      if (!moduleUrl.startsWith(projectDirectoryUrl)) {
-        return
-      }
-
-      if (!sources.includes(moduleUrl)) {
-        sources.push(moduleUrl)
-        sourcesContent.push(dependencyMap[moduleUrl])
-      }
-    })
-  }
-
-  const assets = []
-  const assetsContent = []
-
-  const mainRollupFile = rollupBuild[mainFileName]
-  const mainFile = parseRollupFile(mainRollupFile, {
-    urlResponseBodyMap,
-    sourcemapFileUrl,
-    sourcemapFileRelativeUrlForModule: urlToRelativeUrl(
-      sourcemapFileUrl,
-      compiledFileUrl,
-    ),
-  })
-  // mainFile.sourcemap.file = fileUrlToRelativePath(originalFileUrl, sourcemapFileUrl)
-  trackDependencies(mainFile.dependencyMap)
-  assets.push(sourcemapFileUrl)
-  assetsContent.push(JSON.stringify(mainFile.sourcemap, null, "  "))
-
-  Object.keys(rollupBuild).forEach((fileName) => {
-    if (fileName === mainFileName) return
-
-    const rollupFile = rollupBuild[fileName]
-    if (rollupFile.type === "asset") return
-
-    const file = parseRollupFile(rollupFile, {
-      urlResponseBodyMap,
-      compiledFileUrl,
-      sourcemapFileUrl: resolveUrl(rollupFile.map.file, compiledFileUrl),
-    })
-    trackDependencies(file.dependencyMap)
-    assets.push(resolveUrl(fileName), compiledFileUrl)
-    assetsContent.push(file.content)
-    assets.push(resolveUrl(`${fileName}.map`, compiledFileUrl))
-    assetsContent.push(JSON.stringify(rollupFile.sourcemap, null, "  "))
-  })
-
-  return {
-    contentType: "application/javascript",
-    compiledSource: mainFile.content,
-    sources,
-    sourcesContent,
-    assets,
-    assetsContent,
-  }
-}
-
-const parseRollupFile = (
-  rollupFile,
-  {
-    urlResponseBodyMap,
-    sourcemapFileUrl,
-    sourcemapFileRelativeUrlForModule = `./${rollupFile.fileName}.map`,
-  },
-) => {
-  const dependencyMap = {}
-  const mainModuleSourcemap = rollupFile.map
-
-  mainModuleSourcemap.sources.forEach((source, index) => {
-    const moduleUrl = resolveUrl(source, sourcemapFileUrl)
-    dependencyMap[moduleUrl] = getModuleContent({
-      urlResponseBodyMap,
-      mainModuleSourcemap,
-      moduleUrl,
-      moduleIndex: index,
-    })
-  })
-
-  const sourcemap = rollupFile.map
-
-  const content = setJavaScriptSourceMappingUrl(
-    rollupFile.code,
-    sourcemapFileRelativeUrlForModule,
-  )
-
-  return {
-    dependencyMap,
-    content,
-    sourcemap,
-  }
-}
-
-const getModuleContent = ({
-  urlResponseBodyMap,
-  mainModuleSourcemap,
-  moduleUrl,
-  moduleIndex,
-}) => {
-  if (moduleUrl in urlResponseBodyMap) {
-    return urlResponseBodyMap[moduleUrl]
-  }
-
-  // try to read it from mainModuleSourcemap
-  const sourcesContent = mainModuleSourcemap.sourcesContent || []
-  if (moduleIndex in sourcesContent) {
-    const contentFromRollupSourcemap = sourcesContent[moduleIndex]
-    if (
-      contentFromRollupSourcemap !== null &&
-      contentFromRollupSourcemap !== undefined
-    ) {
-      return contentFromRollupSourcemap
-    }
-  }
-
-  // try to get it from filesystem
-  if (moduleUrl.startsWith("file:///")) {
-    const moduleFilePath = urlToFileSystemPath(moduleUrl)
-    // this could be async but it's ok for now
-    // making it async could be harder than it seems
-    // because sourcesContent must be in sync with sources
-    try {
-      const moduleFileBuffer = readFileSync(moduleFilePath)
-      const moduleFileString = String(moduleFileBuffer)
-      return moduleFileString
-    } catch (e) {
-      if (e && e.code === "ENOENT") {
-        throw new Error(`module file not found at ${moduleUrl}`)
-      }
-      throw e
-    }
-  }
-
-  // it's an external ressource like http, throw
-  throw new Error(`cannot fetch module content from ${moduleUrl}`)
-}

package/src/internal/compile_server/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/compile_server/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_CLIENT_BUILD_URL,
-} from "@jsenv/core/dist/build_manifest.js"
-import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/jsenv_file_urls.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_CLIENT_BUILD_URL,
-  }
-}
-
-const readJsenvCoreVersionFromPackageFile = async () => {
-  const jsenvCorePackageFileUrl = resolveUrl(
-    "./package.json",
-    jsenvCoreDirectoryUrl,
-  )
-  const jsenvCorePackage = await readFile(jsenvCorePackageFileUrl, {
-    as: "json",
-  })
-  const version = jsenvCorePackage.version
-  return version
-}