@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/browser_launcher/page_errors_and_logs.js

@@ -1,77 +0,0 @@
-export const trackPageErrorsAndLogs = (page, { onError, onConsole }) => {
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-error
-  const removeErrorListener = registerEvent({
-    object: page,
-    eventType: "error",
-    callback: onError,
-  })
-
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-pageerror
-  const removePageErrorListener = registerEvent({
-    object: page,
-    eventType: "pageerror",
-    callback: onError,
-  })
-
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-console
-  const removeConsoleListener = registerEvent({
-    object: page,
-    eventType: "console",
-    // https://github.com/microsoft/playwright/blob/master/docs/api.md#event-console
-    callback: async (consoleMessage) => {
-      onConsole({
-        type: consoleMessage.type(),
-        text: appendNewLine(extractTextFromConsoleMessage(consoleMessage)),
-      })
-    },
-  })
-
-  return () => {
-    removeErrorListener()
-    removePageErrorListener()
-    removeConsoleListener()
-  }
-}
-
-const appendNewLine = (string) => `${string}
-`
-
-const extractTextFromConsoleMessage = (consoleMessage) => {
-  return consoleMessage.text()
-  // ensure we use a string so that istanbul won't try
-  // to put any coverage statement inside it
-  // ideally we should use uneval no ?
-  // eslint-disable-next-line no-new-func
-  //   const functionEvaluatedBrowserSide = new Function(
-  //     "value",
-  //     `if (value instanceof Error) {
-  //   return value.stack
-  // }
-  // return value`,
-  //   )
-  //   const argValues = await Promise.all(
-  //     message.args().map(async (arg) => {
-  //       const jsHandle = arg
-  //       try {
-  //         return await jsHandle.executionContext().evaluate(functionEvaluatedBrowserSide, jsHandle)
-  //       } catch (e) {
-  //         return String(jsHandle)
-  //       }
-  //     }),
-  //   )
-  //   const text = argValues.reduce((previous, value, index) => {
-  //     let string
-  //     if (typeof value === "object") string = JSON.stringify(value, null, "  ")
-  //     else string = String(value)
-  //     if (index === 0) return `${previous}${string}`
-  //     return `${previous} ${string}`
-  //   }, "")
-  //   return text
-}
-
-const registerEvent = ({ object, eventType, callback }) => {
-  object.on(eventType, callback)
-  return () => {
-    object.removeListener(eventType, callback)
-  }
-}

package/src/internal/browser_utils/fetch_and_eval.js

@@ -1,27 +0,0 @@
-import { createDetailedMessage } from "@jsenv/logger"
-
-import { fetchUrl } from "./fetch_browser.js"
-
-export const fetchAndEval = async (url) => {
-  const response = await fetchUrl(url)
-
-  if (response.status >= 200 && response.status <= 299) {
-    const text = await response.text()
-    // eslint-disable-next-line no-eval
-    window.eval(appendSourceURL(text, url))
-  } else {
-    const text = await response.text()
-    throw new Error(
-      createDetailedMessage(`Unexpected response for script.`, {
-        ["script url"]: url,
-        ["response body"]: text,
-        ["response status"]: response.status,
-      }),
-    )
-  }
-}
-
-const appendSourceURL = (code, sourceURL) => {
-  return `${code}
-${"//#"} sourceURL=${sourceURL}`
-}

package/src/internal/browser_utils/fetch_and_eval_using_script.js

@@ -1,47 +0,0 @@
-export const fetchAndEvalUsingScript = async (src) => {
-  return new Promise((resolve, reject) => {
-    const script = document.createElement("script")
-
-    const onwindowerror = (errorEvent) => {
-      if (errorEvent.filename === src) {
-        cleanup()
-        reject(errorEvent.error)
-      }
-    }
-
-    const onscripterror = () => {
-      cleanup()
-      reject(new Error(`Error loading ${src}`))
-    }
-
-    const onscriptload = () => {
-      cleanup()
-      resolve()
-    }
-
-    const cleanup = () => {
-      removeOnWindowError()
-      removeOnScriptError()
-      removeOnScriptLoad()
-      document.head.removeChild(script)
-    }
-
-    const removeOnWindowError = () =>
-      window.removeEventListener("error", onwindowerror)
-
-    const removeOnScriptError = () =>
-      script.removeEventListener("error", onscripterror)
-
-    const removeOnScriptLoad = () =>
-      script.removeEventListener("load", onscriptload)
-
-    window.addEventListener("error", onwindowerror)
-    script.addEventListener("error", onscripterror)
-    script.addEventListener("load", onscriptload)
-    script.charset = "utf-8"
-    script.crossOrigin = "anonymous"
-    script.src = src
-
-    document.head.appendChild(script)
-  })
-}

package/src/internal/browser_utils/fetch_browser.js

@@ -1,34 +0,0 @@
-import { fetchUsingXHR } from "./fetch_using_xhr.js"
-
-const fetchNative = async (url, { mode = "cors", ...options } = {}) => {
-  const response = await window.fetch(url, {
-    mode,
-    ...options,
-  })
-
-  return {
-    url: response.url,
-    status: response.status,
-    statusText: "",
-    headers: responseToHeaders(response),
-    text: () => response.text(),
-    json: () => response.json(),
-    blob: () => response.blob(),
-    arrayBuffer: () => response.arrayBuffer(),
-    formData: () => response.formData(),
-  }
-}
-
-const responseToHeaders = (response) => {
-  const headers = {}
-  response.headers.forEach((value, name) => {
-    headers[name] = value
-  })
-  return headers
-}
-
-export const fetchUrl =
-  typeof window.fetch === "function" &&
-  typeof window.AbortController === "function"
-    ? fetchNative
-    : fetchUsingXHR

package/src/internal/browser_utils/fetch_json.js

@@ -1,7 +0,0 @@
-import { fetchUrl } from "./fetch_browser.js"
-
-export const fetchJson = async (url, options = {}) => {
-  const response = await fetchUrl(url, options)
-  const object = await response.json()
-  return object
-}

package/src/internal/building/build_logs.js

@@ -1,134 +0,0 @@
-import { ANSI, UNICODE } from "@jsenv/log"
-
-import { getHtmlNodeLocation } from "@jsenv/core/src/internal/compile_server/html/html_ast.js"
-
-import { byteAsFileSize } from "../logs/byte_as_file_size.js"
-import { msAsDuration } from "../logs/ms_as_duration.js"
-import { stringifyUrlSite } from "./url_trace.js"
-
-export const formatBuildStartLog = ({ entryPoints }) => {
-  const entryFileRelativeUrls = Object.keys(entryPoints)
-  if (entryFileRelativeUrls.length === 1) {
-    return `
-building ${entryFileRelativeUrls[0]}...`
-  }
-
-  return `
-building ${entryFileRelativeUrls.length} entry files...`
-}
-
-export const formatUseImportMapFromHtml = (importMapInfoFromHtml) => {
-  return `
-use importmap from html ${showHtmlSourceLocation(importMapInfoFromHtml)}`
-}
-
-export const formatImportmapOutsideCompileDirectory = ({
-  importMapInfo,
-  compileDirectoryUrl,
-}) => {
-  return `
-WARNING: importmap file is outside compile directory.
-That's unusual you should certainly make importmap file relative.
-${showHtmlSourceLocation(importMapInfo)}
---- compile directory url ---
-${compileDirectoryUrl}
-`
-}
-
-export const formatRessourceHintNeverUsedWarning = (linkInfo) => {
-  return `
-WARNING: Ressource never used for ${
-    linkInfo.rel
-  } link in ${showHtmlSourceLocation(linkInfo)}
-`
-}
-
-export const formatBuildDoneInfo = ({
-  buildStats,
-  buildDirectoryRelativeUrl,
-}) => {
-  return `${formatBuildDoneDetails({ buildStats, buildDirectoryRelativeUrl })}
-${formatBuildSummary({ buildStats })}
-${UNICODE.OK} build end
-`
-}
-
-const formatBuildDoneDetails = ({ buildStats, buildDirectoryRelativeUrl }) => {
-  const { buildFileSizes } = buildStats
-  const buildFiles = Object.keys(buildFileSizes).map((key) => {
-    const buildFileSize = buildFileSizes[key]
-    return `${buildDirectoryRelativeUrl}${key} (${byteAsFileSize(
-      buildFileSize,
-    )})`
-  })
-  const buildFileCount = buildFiles.length
-  const { buildSourcemapFileSizes } = buildStats
-  const sourcemapFileCount = Object.keys(buildSourcemapFileSizes).length
-  let buildFilesDescription =
-    buildFileCount === 1 ? "build file" : `build files`
-  if (sourcemapFileCount === 1) {
-    buildFilesDescription += ` (excluding sourcemap file)`
-  } else if (sourcemapFileCount > 1) {
-    buildFilesDescription += ` (excluding sourcemap files)`
-  }
-  let message = `--- ${buildFilesDescription} ---
-${buildFiles.join("\n")}`
-  return message
-}
-
-const formatBuildSummary = ({ buildStats }) => {
-  const {
-    buildDuration,
-    projectFileSizes,
-    projectTotalFileSize,
-    buildFileSizes,
-    buildFileTotalSize,
-    buildSourcemapFileSizes,
-    buildSourcemapFileTotalSize,
-  } = buildStats
-
-  const projectFileCount = Object.keys(projectFileSizes).length
-  const buildFileCount = Object.keys(buildFileSizes).length
-  const buildSourcemapFileCount = Object.keys(buildSourcemapFileSizes).length
-
-  return `------- build summary -------
-${formatSummaryContent({
-  "project files": `${projectFileCount} (${byteAsFileSize(
-    projectTotalFileSize,
-  )})`,
-  "build files": `${buildFileCount} (${byteAsFileSize(buildFileTotalSize)})`,
-  ...(buildSourcemapFileCount === 0
-    ? {}
-    : {
-        "build sourcemap files": `${buildSourcemapFileCount} (${byteAsFileSize(
-          buildSourcemapFileTotalSize,
-        )})`,
-      }),
-  "build duration": msAsDuration(buildDuration),
-})}
-------------------------------`
-}
-
-const formatSummaryContent = (summaryData) => {
-  return Object.keys(summaryData).map((key) => {
-    return `${ANSI.color(`${key}:`, ANSI.GREY)} ${summaryData[key]}`
-  }).join(`
-`)
-}
-
-const showHtmlSourceLocation = ({
-  htmlNode,
-  htmlUrl,
-  htmlSource,
-  htmlAttributeName,
-}) => {
-  const { line, column } =
-    getHtmlNodeLocation(htmlNode, htmlAttributeName) || {}
-
-  return stringifyUrlSite({
-    url: htmlUrl,
-    line,
-    column,
-    source: htmlSource,
-  })
-}

package/src/internal/building/build_stats.js

@@ -1,100 +0,0 @@
-import { resolveUrl, urlToExtension } from "@jsenv/filesystem"
-
-import { isReferencedOnlyByRessourceHint } from "./ressource_builder_util.js"
-
-export const createBuildStats = ({
-  buildFileContents,
-  ressourceBuilder,
-  buildDuration,
-}) => {
-  const projectFileContents = getProjectFileContents(ressourceBuilder)
-  const projectFileSizeInfo = sizeInfoFromFileContents(projectFileContents)
-
-  const { sourceFileContents, sourcemapFileContents } =
-    extractSourcemapFiles(buildFileContents)
-  const buildFileSizeInfo = sizeInfoFromFileContents(sourceFileContents)
-  const sourcemapFileSizeInfo = sizeInfoFromFileContents(sourcemapFileContents)
-
-  return {
-    projectFileSizes: projectFileSizeInfo.fileSizes,
-    projectTotalFileSize: projectFileSizeInfo.totalSize,
-    buildFileSizes: buildFileSizeInfo.fileSizes,
-    buildFileTotalSize: buildFileSizeInfo.totalSize,
-    buildSourcemapFileSizes: sourcemapFileSizeInfo.fileSizes,
-    buildSourcemapFileTotalSize: sourcemapFileSizeInfo.totalSize,
-    buildDuration,
-  }
-}
-
-const extractSourcemapFiles = (fileContents) => {
-  const sourceFileContents = {}
-  const sourcemapFileContents = {}
-  Object.keys(fileContents).forEach((key) => {
-    const url = resolveUrl(key, "http://example.com")
-    if (urlToExtension(url) === ".map") {
-      sourcemapFileContents[key] = fileContents[key]
-    } else {
-      sourceFileContents[key] = fileContents[key]
-    }
-  })
-  return {
-    sourceFileContents,
-    sourcemapFileContents,
-  }
-}
-
-const sizeInfoFromFileContents = (fileContents) => {
-  const fileSizes = {}
-  let totalSize = 0
-  Object.keys(fileContents).forEach((key) => {
-    const fileSize = Buffer.byteLength(fileContents[key])
-    fileSizes[key] = fileSize
-    totalSize += fileSize
-  })
-  return { fileSizes, totalSize }
-}
-
-const getProjectFileContents = (ressourceBuilder) => {
-  const projectFileContents = {}
-  const { ressourceMap } = ressourceBuilder.inspect()
-
-  Object.keys(ressourceMap).forEach((url) => {
-    const ressource = ressourceMap[url]
-    const {
-      isInline,
-      isExternal,
-      isPlaceholder,
-      isSourcemap,
-      bufferBeforeBuild,
-    } = ressource
-    if (isInline) {
-      // inline ressources are not files
-      return
-    }
-    if (isExternal) {
-      // external ressource are not handled, we would not have the bufferBeforeBuild
-      return
-    }
-    if (isReferencedOnlyByRessourceHint(ressource)) {
-      // ressource is only referenced by ressource hint (link preload for example)
-      // it's never actually loaded
-      // -> we don't gave the bufferBeforeBuild (the ressource file content)
-      return
-    }
-    if (isPlaceholder) {
-      // placeholders (used for sourcemap files)
-      // means the file did not exists in the project is there is a placeholder
-      // to generate it in the build
-      return
-    }
-    if (isSourcemap && !bufferBeforeBuild) {
-      // sourcemap generated by rollup do not have bufferBeforeBuild
-      return
-    }
-    if (!bufferBeforeBuild) {
-      throw new Error(`bufferBeforeBuild missing for ${url}`)
-    }
-    projectFileContents[url] = bufferBeforeBuild
-  })
-  return projectFileContents
-}

package/src/internal/building/build_url_generator.js

@@ -1,153 +0,0 @@
-import { urlToBasename, urlToExtension } from "@jsenv/filesystem"
-
-import { generateContentHash } from "./url_versioning/url_versioning.js"
-
-export const createBuildUrlGenerator = ({
-  entryPointUrls,
-  asOriginalUrl,
-  lineBreakNormalization,
-}) => {
-  const availableNameGenerator = createAvailableNameGenerator()
-
-  const prepareBuildUrlForRessource = (ressource) => {
-    const buildRelativeUrlPattern = getBuildRelativeUrlPattern({
-      entryPointUrls,
-      asOriginalUrl,
-      availableNameGenerator,
-      ressource,
-    })
-    const buildRelativeUrlWithoutHash = buildRelativeUrlPattern.replace(
-      "_[hash]",
-      "",
-    )
-    return {
-      buildRelativeUrlPattern,
-      buildRelativeUrlWithoutHash,
-    }
-  }
-
-  const computeBuildRelativeUrl = (ressource) => {
-    const buildRelativeUrl = renderFileNamePattern(
-      ressource.buildRelativeUrlPattern,
-      {
-        hash: () =>
-          generateContentHash(ressource.bufferAfterBuild, {
-            contentType: ressource.contentType,
-            lineBreakNormalization,
-          }),
-      },
-    )
-    return buildRelativeUrl
-  }
-
-  return { prepareBuildUrlForRessource, computeBuildRelativeUrl }
-}
-
-const getBuildRelativeUrlPattern = ({
-  entryPointUrls,
-  asOriginalUrl,
-  availableNameGenerator,
-  ressource,
-}) => {
-  if (ressource.isEntryPoint) {
-    const originalUrl = asOriginalUrl(ressource.url)
-    const entryPointBuildRelativeUrlPattern = entryPointUrls[originalUrl]
-    return entryPointBuildRelativeUrlPattern
-  }
-
-  // inline ressource
-  // TODO: should inherit importer directory location because inline
-  if (ressource.isInline) {
-    // const importerBuildRelativeUrlWithoutHash =
-    //   ressource.importer.buildRelativeUrlWithoutHash
-    const name = urlToBasename(ressource.url)
-    const extension = urlToExtension(ressource.url)
-    // no need to ensure name is unique because it's already done
-    return `${name}_[hash]${extension}`
-  }
-
-  // importmap.
-  // the goal is to put the importmap at the same relative path
-  // than in the project to avoid having to re-resolve mappings
-  if (ressource.contentType === "application/importmap+json") {
-    const name = availableNameGenerator.getAvailableNameInDirectory(
-      urlToBasename(ressource.url),
-      "/",
-    )
-    const extension = urlToExtension(ressource.url)
-    return `${name}_[hash]${extension}`
-  }
-
-  // service worker:
-  // - MUST be at the root (same level than the HTML file)
-  //   otherwise it might be registered for the scope "/assets/" instead of "/"
-  // - MUST not be versioned
-  if (ressource.isServiceWorker) {
-    const name = availableNameGenerator.getAvailableNameInDirectory(
-      urlToBasename(ressource.url),
-      "/",
-    )
-    const extension = urlToExtension(ressource.url)
-    return `${name}${extension}`
-  }
-
-  if (ressource.isWorker) {
-    const name = availableNameGenerator.getAvailableNameInDirectory(
-      urlToBasename(ressource.url),
-      "/",
-    )
-    const extension = urlToExtension(ressource.url)
-    return `${name}_[hash]${extension}`
-  }
-
-  if (ressource.isJsModule) {
-    const name = availableNameGenerator.getAvailableNameInDirectory(
-      urlToBasename(ressource.url),
-      "/",
-    )
-    return `${name}_[hash].js`
-  }
-
-  const name = availableNameGenerator.getAvailableNameInDirectory(
-    urlToBasename(ressource.url),
-    "assets/",
-  )
-  const extension = urlToExtension(ressource.url)
-  return ressource.urlVersioningDisabled
-    ? `assets/${name}${extension}`
-    : `assets/${name}_[hash]${extension}`
-}
-
-const createAvailableNameGenerator = () => {
-  const cache = {}
-  const getAvailableNameInDirectory = (name, directory) => {
-    let names = cache[directory]
-    if (!names) {
-      names = []
-      cache[directory] = names
-    }
-
-    let nameCandidate = name
-    let integer = 1
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      if (!names.includes(nameCandidate)) {
-        names.push(nameCandidate)
-        return nameCandidate
-      }
-      integer++
-      nameCandidate = `${name}${integer}`
-    }
-  }
-
-  return {
-    getAvailableNameInDirectory,
-  }
-}
-
-const renderFileNamePattern = (pattern, replacements) => {
-  return pattern.replace(/\[(\w+)\]/g, (_match, type) => {
-    const replacement = replacements[type](_match)
-    return replacement
-  })
-}