@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/building/url_versioning/url_versioning.js

@@ -1,65 +0,0 @@
-import { createHash } from "node:crypto"
-
-// https://github.com/rollup/rollup/blob/19e50af3099c2f627451a45a84e2fa90d20246d5/src/utils/FileEmitter.ts#L47
-export const generateContentHash = (
-  stringOrBuffer,
-  {
-    contentType = "application/octet-stream",
-    lineBreakNormalization = false,
-  } = {},
-) => {
-  const hash = createHash("sha256")
-  hash.update(
-    lineBreakNormalization && contentTypeIsTextual(contentType)
-      ? normalizeLineBreaks(stringOrBuffer)
-      : stringOrBuffer,
-  )
-  return hash.digest("hex").slice(0, 8)
-}
-
-const contentTypeIsTextual = (contentType) => {
-  if (contentType.startsWith("text/")) {
-    return true
-  }
-  // catch things like application/manifest+json, application/importmap+json
-  if (/^application\/\w+\+json$/.test(contentType)) {
-    return true
-  }
-  if (CONTENT_TYPE_AS_TEXT.includes(contentType)) {
-    return true
-  }
-  return false
-}
-
-const CONTENT_TYPE_AS_TEXT = [
-  "application/javascript",
-  "application/json",
-  "image/svg+xml",
-]
-
-const normalizeLineBreaks = (stringOrBuffer) => {
-  if (typeof stringOrBuffer === "string") {
-    const stringWithLinuxBreaks = stringOrBuffer.replace(/\r\n/g, "\n")
-    return stringWithLinuxBreaks
-  }
-  return normalizeLineBreaksForBuffer(stringOrBuffer)
-}
-
-// https://github.com/nodejs/help/issues/1738#issuecomment-458460503
-const normalizeLineBreaksForBuffer = (buffer) => {
-  const int32Array = new Int32Array(buffer, 0, buffer.length)
-  const int32ArrayWithLineBreaksNormalized = int32Array.filter(
-    (element, index, typedArray) => {
-      if (element === 0x0d) {
-        if (typedArray[index + 1] === 0x0a) {
-          // Windows -> Unix
-          return false
-        }
-        // Mac OS -> Unix
-        typedArray[index] = 0x0a
-      }
-      return true
-    },
-  )
-  return Buffer.from(int32ArrayWithLineBreaksNormalized)
-}

package/src/internal/building/webmanifest/jsenv_parse_webmanifest.js

@@ -1,48 +0,0 @@
-export const parseWebmanifestRessource = (
-  webmanifestRessource,
-  { notifyReferenceFound },
-  { minify },
-) => {
-  // const manifestUrl = manifestTarget.url
-  const manifestString = String(webmanifestRessource.bufferBeforeBuild)
-
-  const manifest = JSON.parse(manifestString)
-  const { icons = [] } = manifest
-
-  const iconReferences = icons.map((icon, index) => {
-    const iconReference = notifyReferenceFound({
-      referenceLabel: `web manifest icon ${index}`,
-      ressourceSpecifier: icon.src,
-    })
-    return iconReference
-  })
-
-  return ({ getUrlRelativeToImporter }) => {
-    if (icons.length === 0) {
-      if (minify) {
-        // this is to remove eventual whitespaces
-        webmanifestRessource.buildEnd(JSON.stringify(manifest))
-        return
-      }
-      webmanifestRessource.buildEnd(JSON.stringify(manifest, null, "  "))
-      return
-    }
-
-    const iconsAfterBuild = icons.map((icon, index) => {
-      const iconAfterBuild = { ...icon }
-      iconAfterBuild.src = getUrlRelativeToImporter(
-        iconReferences[index].ressource,
-      )
-      return iconAfterBuild
-    })
-    const manifestAfterBuild = { ...manifest }
-    manifestAfterBuild.icons = iconsAfterBuild
-    if (minify) {
-      webmanifestRessource.buildEnd(JSON.stringify(manifestAfterBuild))
-      return
-    }
-    webmanifestRessource.buildEnd(
-      JSON.stringify(manifestAfterBuild, null, "  "),
-    )
-  }
-}

package/src/internal/compile_server/commonjs/rollup_plugin_commonjs_named_exports.js

@@ -1,187 +0,0 @@
-// https://github.com/snowpackjs/snowpack/blob/main/esinstall/src/rollup-plugins/rollup-plugin-wrap-install-targets.ts
-
-import { readFileSync } from "node:fs"
-import { fileURLToPath } from "node:url"
-import { VM as VM2 } from "vm2"
-import isValidIdentifier from "is-valid-identifier"
-import resolve from "resolve"
-import { init, parse } from "cjs-module-lexer"
-import { fileSystemPathToUrl } from "@jsenv/filesystem"
-
-export const rollupPluginCommonJsNamedExports = ({ logger }) => {
-  const inputSummaries = {}
-  const cjsScannedNamedExports = {}
-
-  return {
-    async buildStart({ input }) {
-      await init()
-
-      Object.keys(input).forEach((key) => {
-        const inputFilePath = input[key]
-        const inputFileUrl = fileSystemPathToUrl(inputFilePath)
-        inputSummaries[inputFileUrl] = {
-          all: true,
-          default: true,
-          namespace: true,
-          named: [],
-        }
-
-        const cjsExports =
-          detectStaticExports({ logger, fileUrl: inputFileUrl }) ||
-          detectExportsUsingSandboxedRuntime({ logger, fileUrl: inputFileUrl })
-
-        if (cjsExports && cjsExports.length) {
-          cjsScannedNamedExports[inputFileUrl] = cjsExports
-        }
-        input[key] = `jsenv:${inputFileUrl}`
-      })
-    },
-    resolveId(source) {
-      if (source.startsWith("jsenv:")) {
-        return source
-      }
-
-      return null
-    },
-    load(id) {
-      if (!id.startsWith("jsenv:")) {
-        return null
-      }
-
-      const inputFileUrl = id.substring("jsenv:".length)
-      const inputSummary = inputSummaries[inputFileUrl]
-      let uniqueNamedExports = inputSummary.named
-      const scannedNamedExports = cjsScannedNamedExports[inputFileUrl]
-      if (scannedNamedExports) {
-        uniqueNamedExports = scannedNamedExports || []
-        inputSummary.default = true
-      }
-      const codeForExports = generateCodeForExports({
-        uniqueNamedExports,
-        inputSummary,
-        inputFileUrl,
-      })
-      return codeForExports
-    },
-  }
-}
-
-/*
- * Attempt #1: Static analysis: Lower Fidelity, but faster.
- * Do our best job to statically scan a file for named exports. This uses "cjs-module-lexer", the
- * same CJS export scanner that Node.js uses internally. Very fast, but only works on some modules,
- * depending on how they were build/written/compiled.
- */
-const detectStaticExports = ({ logger, fileUrl, visited = new Set() }) => {
-  const isMainEntrypoint = visited.size === 0
-  // Prevent infinite loops via circular dependencies.
-  if (visited.has(fileUrl)) {
-    return []
-  }
-  visited.add(fileUrl)
-
-  const fileContents = readFileSync(new URL(fileUrl), "utf8")
-  try {
-    const { exports, reexports } = parse(fileContents)
-    // If re-exports were detected (`exports.foo = require(...)`) then resolve them here.
-    let resolvedReexports = []
-    if (reexports.length > 0) {
-      reexports.forEach((reexport) => {
-        const reExportedFilePath = resolve.sync(reexport, {
-          basedir: fileURLToPath(new URL("./", fileUrl)),
-        })
-        const reExportedFileUrl = fileSystemPathToUrl(reExportedFilePath)
-        const staticExports = detectStaticExports({
-          logger,
-          fileUrl: reExportedFileUrl,
-          visited,
-        })
-        if (staticExports) {
-          resolvedReexports = [...resolvedReexports, ...staticExports]
-        }
-      })
-    }
-    const resolvedExports = Array.from(
-      new Set([...exports, ...resolvedReexports]),
-    ).filter(isValidNamedExport)
-
-    if (isMainEntrypoint && resolvedExports.length === 0) {
-      return undefined
-    }
-
-    return resolvedExports
-  } catch (err) {
-    // Safe to ignore, this is usually due to the file not being CJS.
-    logger.debug(`detectStaticExports ${fileUrl}: ${err.message}`)
-    return undefined
-  }
-}
-
-/*
- * Attempt #2b - Sandboxed runtime analysis: More powerful, but slower.
- * This will only work on UMD and very simple CJS files (require not supported).
- * Uses VM2 to run safely sandbox untrusted code (no access no Node.js primitives, just JS).
- * If nothing was detected, return undefined.
- */
-const detectExportsUsingSandboxedRuntime = ({ logger, fileUrl }) => {
-  try {
-    const fileContents = readFileSync(new URL(fileUrl), "utf8")
-    const vm = new VM2({ wasm: false, fixAsync: false })
-    const codeToRun = wrapCodeToRunInVm(fileContents)
-    const vmResult = vm.run(codeToRun)
-    const exportsResult = Object.keys(vmResult)
-    logger.debug(
-      `detectExportsUsingSandboxedRuntime success ${fileUrl}: ${exportsResult}`,
-    )
-    return exportsResult.filter((identifier) => isValidIdentifier(identifier))
-  } catch (err) {
-    logger.debug(
-      `detectExportsUsingSandboxedRuntime error ${fileUrl}: ${err.message}`,
-    )
-    return undefined
-  }
-}
-
-const isValidNamedExport = (name) =>
-  name !== "default" && name !== "__esModule" && isValidIdentifier(name)
-
-const wrapCodeToRunInVm = (code) => {
-  return `const exports = {};
-const module = { exports };
-${code};;
-module.exports;`
-}
-
-const generateCodeForExports = ({
-  uniqueNamedExports,
-  inputSummary,
-  inputFileUrl,
-}) => {
-  const from =
-    process.platform === "win32"
-      ? inputFileUrl.slice("file:///".length)
-      : inputFileUrl.slice("file://".length)
-  const lines = [
-    ...(inputSummary.namespace ? [stringifyNamespaceReExport({ from })] : []),
-    ...(inputSummary.default ? [stringifyDefaultReExport({ from })] : []),
-    stringifyNamedReExports({
-      namedExports: uniqueNamedExports,
-      from,
-    }),
-  ]
-  return lines.join(`
-`)
-}
-
-const stringifyNamespaceReExport = ({ from }) => {
-  return `export * from "${from}";`
-}
-
-const stringifyDefaultReExport = ({ from }) => {
-  return `import __jsenv_default_import__ from "${from}";
-export default __jsenv_default_import__;`
-}
-
-const stringifyNamedReExports = ({ namedExports, from }) => {
-  return `export { ${namedExports.join(",")} } from "${from}";`
-}

package/src/internal/compile_server/compile_file.js

@@ -1,273 +0,0 @@
-import {
-  urlToRelativeUrl,
-  fileSystemPathToUrl,
-  resolveUrl,
-  bufferToEtag,
-  urlIsInsideOf,
-} from "@jsenv/filesystem"
-import { convertFileSystemErrorToResponseProperties } from "@jsenv/server/src/internal/convertFileSystemErrorToResponseProperties.js"
-
-import { reuseOrCreateCompiledFile } from "./jsenv_directory/reuse_or_create_compiled_file.js"
-import { updateCompileCache } from "./jsenv_directory/update_compile_cache.js"
-
-export const compileFile = async ({
-  logger,
-
-  projectDirectoryUrl,
-  jsenvDirectory,
-  jsenvRemoteDirectory,
-  originalFileUrl,
-  compiledFileUrl,
-
-  projectFileRequestedCallback = () => {},
-  request,
-  responseHeaders = {},
-  pushResponse,
-  importmapInfos,
-  compile,
-  compileCacheStrategy,
-  compileCacheSourcesValidation,
-  compileCacheAssetsValidation,
-}) => {
-  if (
-    compileCacheStrategy !== "etag" &&
-    compileCacheStrategy !== "mtime" &&
-    compileCacheStrategy !== "none"
-  ) {
-    throw new Error(
-      `compileCacheStrategy must be "etag", "mtime" or "none", got ${compileCacheStrategy}`,
-    )
-  }
-
-  projectFileRequestedCallback(
-    urlToRelativeUrl(originalFileUrl, projectDirectoryUrl),
-    request,
-  )
-
-  const clientCacheDisabled = request.headers["cache-control"] === "no-cache"
-
-  try {
-    const { meta, compileResult, compileResultStatus, timing } =
-      await reuseOrCreateCompiledFile({
-        logger,
-        projectDirectoryUrl,
-        originalFileUrl,
-        compiledFileUrl,
-        jsenvRemoteDirectory,
-
-        request,
-        compileCacheStrategy,
-        compileCacheSourcesValidation,
-        compileCacheAssetsValidation,
-        compile,
-      })
-
-    if (compileCacheStrategy === "etag" && !compileResult.compiledEtag) {
-      // happens when file was just compiled so etag was not computed
-      compileResult.compiledEtag = bufferToEtag(
-        Buffer.from(compileResult.compiledSource),
-      )
-    }
-
-    if (compileCacheStrategy === "mtime" && !compileResult.compiledMtime) {
-      // happens when file was just compiled so it's not yet written on filesystem
-      // Here we know the compiled file will be written on the filesystem
-      // We could wait for the file to be written before responding to the client
-      // but it could delay a bit the response.
-      // Inside "updateMeta" the file might be written synchronously
-      // or batched to be written later for perf reasons.
-      // From this side of the code we would like to be agnostic about this to allow
-      // eventual perf improvments in that field.
-      // For this reason the "mtime" we send to the client is decided here
-      // by "compileResult.compiledMtime = Date.now()"
-      // "updateMeta" will respect this and when it will write the compiled file it will
-      // use "utimes" to ensure the file mtime is the one we sent to the client
-      // This is important so that a request sending an mtime
-      // can be compared with the compiled file mtime on the filesystem
-      // In the end etag is preffered over mtime by default so this will rarely
-      // be useful
-      compileResult.compiledMtime = Date.now()
-    }
-
-    const { contentType, compiledEtag, compiledMtime, compiledSource } =
-      compileResult
-
-    if (compileResult.responseHeaders) {
-      responseHeaders = {
-        ...responseHeaders,
-        ...compileResult.responseHeaders,
-      }
-    }
-
-    if (compileResultStatus !== "cached" && compileCacheStrategy !== "none") {
-      // we MUST await updateMeta otherwise we might get 404
-      // when serving sourcemap files
-      await updateCompileCache({
-        logger,
-        jsenvDirectory,
-        meta,
-        compileResult,
-        compileResultStatus,
-        compiledFileUrl,
-        // originalFileUrl,
-      })
-    }
-
-    compileResult.sources.forEach((source) => {
-      const sourceFileUrl = resolveUrl(source, compiledFileUrl)
-      projectFileRequestedCallback(
-        urlToRelativeUrl(sourceFileUrl, projectDirectoryUrl),
-        request,
-      )
-    })
-
-    if (request.http2) {
-      const dependencyResolver = getDependencyResolver({
-        compileResult,
-        importmapInfos,
-        request,
-      })
-      if (dependencyResolver) {
-        compileResult.dependencies.forEach((dependency) => {
-          const dependencyUrl = dependencyResolver.resolve(dependency)
-          if (!urlIsInsideOf(dependencyUrl, request.origin)) {
-            // ignore external urls
-            return
-          }
-          if (dependencyUrl.startsWith("data:")) {
-            return
-          }
-          const dependencyRelativeUrl = urlToRelativeUrl(
-            dependencyUrl,
-            request.origin,
-          )
-          pushResponse({ path: `/${dependencyRelativeUrl}` })
-        })
-      }
-    }
-
-    // when a compiled version of the source file was just created or updated
-    // we don't want to rely on filesystem because we might want to delay
-    // when the file is written for perf reasons
-    // Moreover we already got the data in RAM
-    const respondUsingRAM = (finalizeResponse = () => {}) => {
-      const response = {
-        status: 200,
-        headers: {
-          "content-length": Buffer.byteLength(compiledSource),
-          "content-type": contentType,
-          "cache-control": "no-store",
-          ...responseHeaders,
-        },
-        body: compiledSource,
-        timing,
-      }
-      finalizeResponse(response)
-      return response
-    }
-
-    if (!clientCacheDisabled && compileCacheStrategy === "etag") {
-      if (
-        request.headers["if-none-match"] &&
-        compileResultStatus === "cached"
-      ) {
-        return {
-          status: 304,
-          headers: {
-            "cache-control": "private,max-age=0,must-revalidate",
-          },
-          timing,
-        }
-      }
-      return respondUsingRAM((response) => {
-        // eslint-disable-next-line dot-notation
-        response.headers["etag"] = compiledEtag
-        response.headers["cache-control"] = "private,max-age=0,must-revalidate"
-      })
-    }
-
-    if (!clientCacheDisabled && compileCacheStrategy === "mtime") {
-      if (
-        request.headers["if-modified-since"] &&
-        compileResultStatus === "cached"
-      ) {
-        return {
-          status: 304,
-          headers: {
-            "cache-control": "private,max-age=0,must-revalidate",
-          },
-          timing,
-        }
-      }
-      return respondUsingRAM((response) => {
-        response.headers["last-modified"] = new Date(
-          compiledMtime,
-        ).toUTCString()
-        response.headers["cache-control"] = "private,max-age=0,must-revalidate"
-      })
-    }
-
-    return respondUsingRAM()
-  } catch (error) {
-    if (error && error.code === "PARSE_ERROR") {
-      const { data } = error
-      const { filename } = data
-      if (filename) {
-        const relativeUrl = urlToRelativeUrl(
-          fileSystemPathToUrl(filename),
-          projectDirectoryUrl,
-        )
-        projectFileRequestedCallback(relativeUrl, request)
-      }
-      // on the correspondig file
-      const json = JSON.stringify(data)
-      return {
-        status: 500,
-        statusText: "parse error",
-        headers: {
-          "cache-control": "no-store",
-          "content-length": Buffer.byteLength(json),
-          "content-type": "application/json",
-        },
-        body: json,
-      }
-    }
-    if (error && error.asResponse) {
-      return error.asResponse()
-    }
-    if (error && error.statusText === "Unexpected directory operation") {
-      return {
-        status: 403,
-      }
-    }
-    return convertFileSystemErrorToResponseProperties(error)
-  }
-}
-
-const getDependencyResolver = ({ compileResult, importmapInfos, request }) => {
-  const importmapKeys = Object.keys(importmapInfos)
-  const requestUrl = resolveUrl(request.ressource, request.origin)
-
-  if (
-    compileResult.contentType === "application/javascript" &&
-    // we cannot trust importmapKeys because when html is restored from cache
-    // it would be empty
-    importmapKeys.length > 0
-  ) {
-    // js resolution is special, we cannot just do resolveUrl of the import specifier
-    // because there can be importmap (bare specifier, import without extension, custom remapping, ...)
-    // And we would push 404 to the browser
-    // BUT I tried to push everything to the browser and it was a big fail:
-    // server is trying to push streams but browser rejects most push streams
-    // either because main file is already fetched or an other file request the same ressource
-    return null
-  }
-
-  return {
-    type: "url_resolution",
-    resolve: (dependency) => {
-      const dependencyUrl = resolveUrl(dependency, requestUrl)
-      return dependencyUrl
-    },
-  }
-}