@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/internal/dev_server/toolbar/execution/toolbar.execution.js

@@ -1,91 +0,0 @@
-import { removeForceHideElement, activateToolbarSection } from "../util/dom.js"
-import { enableVariant } from "../variant/variant.js"
-import { createHorizontalBreakpoint } from "../util/responsive.js"
-import { toggleTooltip } from "../tooltip/tooltip.js"
-import { notifyExecutionResult } from "../notification/toolbar.notification.js"
-
-const WINDOW_MEDIUM_WIDTH = 570
-
-export const renderExecutionInToolbar = ({ executedFileRelativeUrl }) => {
-  // reset file execution indicator ui
-  applyExecutionIndicator()
-  removeForceHideElement(document.querySelector("#execution-indicator"))
-
-  // apply responsive design on fileInput if needed + add listener on resize screen
-  const input = document.querySelector("#file-input")
-  const fileWidthBreakpoint = createHorizontalBreakpoint(WINDOW_MEDIUM_WIDTH)
-  const handleFileWidthBreakpoint = () => {
-    resizeInput(input, fileWidthBreakpoint)
-  }
-  handleFileWidthBreakpoint()
-  fileWidthBreakpoint.changed.listen(handleFileWidthBreakpoint)
-  input.value = executedFileRelativeUrl
-  resizeInput(input, fileWidthBreakpoint)
-
-  activateToolbarSection(document.querySelector("#file"))
-  removeForceHideElement(document.querySelector("#file"))
-
-  window.parent.__jsenv__.executionResultPromise.then(
-    ({ status, startTime, endTime }) => {
-      const execution = { status, startTime, endTime }
-      applyExecutionIndicator(execution)
-
-      const executionStorageKey = executedFileRelativeUrl
-      const previousExecution = sessionStorage.hasOwnProperty(
-        executionStorageKey,
-      )
-        ? JSON.parse(sessionStorage.getItem(executionStorageKey))
-        : undefined
-      notifyExecutionResult(
-        executedFileRelativeUrl,
-        execution,
-        previousExecution,
-      )
-
-      sessionStorage.setItem(executedFileRelativeUrl, JSON.stringify(execution))
-    },
-  )
-}
-
-const applyExecutionIndicator = ({
-  status = "running",
-  startTime,
-  endTime,
-} = {}) => {
-  const executionIndicator = document.querySelector("#execution-indicator")
-  enableVariant(executionIndicator, { execution: status })
-  const variantNode = executionIndicator.querySelector("[data-when-active]")
-
-  variantNode.querySelector("button").onclick = () =>
-    toggleTooltip(executionIndicator)
-  variantNode.querySelector(".tooltip").textContent = computeText({
-    status,
-    startTime,
-    endTime,
-  })
-}
-
-const computeText = ({ status, startTime, endTime }) => {
-  if (status === "completed") {
-    return `Execution completed in ${endTime - startTime}ms`
-  }
-
-  if (status === "errored") {
-    return `Execution failed in ${endTime - startTime}ms`
-  }
-
-  if (status === "running") {
-    return "Executing..."
-  }
-
-  return ""
-}
-
-const resizeInput = (input, fileWidthBreakpoint) => {
-  const size = fileWidthBreakpoint.isBelow() ? 20 : 40
-  if (input.value.length > size) {
-    input.style.width = `${size}ch`
-  } else {
-    input.style.width = `${input.value.length}ch`
-  }
-}

package/src/internal/error-stack-remapping/getOriginalCallsites.js

@@ -1,217 +0,0 @@
-import { createDetailedMessage } from "@jsenv/logger"
-import { parseDataUrl, dataUrlToRawData } from "../dataUrl.utils.js"
-import { getJavaScriptSourceMappingUrl } from "../sourceMappingURLUtils.js"
-import { remapCallSite } from "./remapCallSite.js"
-
-export const getOriginalCallsites = async ({
-  stack,
-  resolveFile,
-  fetchFile,
-  SourceMapConsumer,
-  readErrorStack,
-  onFailure,
-}) => {
-  const urlToSourcemapConsumer = memoizeByFirstArgStringValue(
-    async (stackTraceFileUrl) => {
-      if (stackTraceFileUrl.startsWith("node:")) {
-        return null
-      }
-
-      try {
-        let text
-        try {
-          const fileResponse = await fetchFile(stackTraceFileUrl)
-          const { status } = fileResponse
-          if (status !== 200) {
-            if (status === 404) {
-              onFailure(`stack trace file not found at ${stackTraceFileUrl}`)
-            } else {
-              onFailure(
-                createDetailedMessage(
-                  `unexpected response fetching stack trace file.`,
-                  {
-                    ["response status"]: status,
-                    ["response text"]: fileResponse.body,
-                    ["stack trace file"]: stackTraceFileUrl,
-                  },
-                ),
-              )
-            }
-            return null
-          }
-          text = await fileResponse.text()
-        } catch (e) {
-          onFailure(
-            createDetailedMessage(`error while fetching stack trace file.`, {
-              ["fetch error stack"]: readErrorStack(e),
-              ["stack trace file"]: stackTraceFileUrl,
-            }),
-          )
-
-          return null
-        }
-
-        const jsSourcemapUrl = getJavaScriptSourceMappingUrl(text)
-        if (!jsSourcemapUrl) {
-          return null
-        }
-
-        let sourcemapUrl
-        let sourcemapString
-        if (jsSourcemapUrl.startsWith("data:")) {
-          sourcemapUrl = stackTraceFileUrl
-          sourcemapString = dataUrlToRawData(parseDataUrl(jsSourcemapUrl))
-        } else {
-          sourcemapUrl = resolveFile(jsSourcemapUrl, stackTraceFileUrl, {
-            type: "source-map",
-          })
-
-          try {
-            const sourcemapResponse = await fetchFile(sourcemapUrl)
-            const { status } = sourcemapResponse
-            if (status !== 200) {
-              if (status === 404) {
-                onFailure(`sourcemap file not found at ${sourcemapUrl}`)
-              } else {
-                onFailure(
-                  createDetailedMessage(
-                    `unexpected response for sourcemap file.`,
-                    {
-                      ["response status"]: status,
-                      ["response text"]: await sourcemapResponse.text(),
-                      ["sourcemap url"]: sourcemapUrl,
-                    },
-                  ),
-                )
-              }
-              return null
-            }
-            sourcemapString = await sourcemapResponse.text()
-          } catch (e) {
-            onFailure(
-              createDetailedMessage(`error while fetching sourcemap.`, {
-                ["fetch error stack"]: readErrorStack(e),
-                ["sourcemap url"]: sourcemapUrl,
-              }),
-            )
-            return null
-          }
-        }
-
-        let sourceMap
-        try {
-          sourceMap = JSON.parse(sourcemapString)
-        } catch (e) {
-          onFailure(
-            createDetailedMessage(`error while parsing sourcemap.`, {
-              ["parse error stack"]: readErrorStack(e),
-              ["sourcemap url"]: sourcemapUrl,
-            }),
-          )
-          return null
-        }
-
-        let { sourcesContent } = sourceMap
-
-        if (!sourcesContent) {
-          sourcesContent = []
-          sourceMap.sourcesContent = sourcesContent
-        }
-
-        let firstSourceMapSourceFailure = null
-
-        await Promise.all(
-          sourceMap.sources.map(async (source, index) => {
-            if (index in sourcesContent) return
-
-            const sourcemapSourceUrl = resolveFile(source, sourcemapUrl, {
-              type: "source",
-            })
-            try {
-              const sourceResponse = await fetchFile(sourcemapSourceUrl)
-              const { status } = sourceResponse
-              if (status !== 200) {
-                if (firstSourceMapSourceFailure) return
-
-                if (status === 404) {
-                  firstSourceMapSourceFailure = createDetailedMessage(
-                    `sourcemap source not found.`,
-                    {
-                      ["sourcemap source url"]: sourcemapSourceUrl,
-                      ["sourcemap url"]: sourcemapUrl,
-                    },
-                  )
-                  return
-                }
-                firstSourceMapSourceFailure = createDetailedMessage(
-                  `unexpected response for sourcemap source.`,
-                  {
-                    ["response status"]: status,
-                    ["response text"]: await sourceResponse.text(),
-                    ["sourcemap source url"]: sourcemapSourceUrl,
-                    ["sourcemap url"]: sourcemapUrl,
-                  },
-                )
-                return
-              }
-
-              const sourceString = await sourceResponse.text()
-              sourcesContent[index] = sourceString
-            } catch (e) {
-              if (firstSourceMapSourceFailure) return
-              firstSourceMapSourceFailure = createDetailedMessage(
-                `error while fetching sourcemap source.`,
-                {
-                  ["fetch error stack"]: readErrorStack(e),
-                  ["sourcemap source url"]: sourcemapSourceUrl,
-                  ["sourcemap url"]: sourcemapUrl,
-                },
-              )
-            }
-          }),
-        )
-
-        if (firstSourceMapSourceFailure) {
-          onFailure(firstSourceMapSourceFailure)
-          return null
-        }
-
-        return new SourceMapConsumer(sourceMap)
-      } catch (e) {
-        onFailure(
-          createDetailedMessage(
-            `error while preparing a sourceMap consumer for a stack trace file.`,
-            {
-              ["error stack"]: readErrorStack(e),
-              ["stack trace file"]: stackTraceFileUrl,
-            },
-          ),
-        )
-        return null
-      }
-    },
-  )
-
-  const originalCallsites = await Promise.all(
-    stack.map((callSite) =>
-      remapCallSite(callSite, {
-        resolveFile,
-        urlToSourcemapConsumer,
-        readErrorStack,
-        onFailure,
-      }),
-    ),
-  )
-  return originalCallsites
-}
-
-const memoizeByFirstArgStringValue = (fn) => {
-  const stringValueCache = {}
-  return (firstArgValue) => {
-    if (firstArgValue in stringValueCache)
-      return stringValueCache[firstArgValue]
-    const value = fn(firstArgValue)
-    stringValueCache[firstArgValue] = value
-    return value
-  }
-}

package/src/internal/error-stack-remapping/installBrowserErrorStackRemapping.js

@@ -1,45 +0,0 @@
-/* eslint-env browser */
-
-import { installErrorStackRemapping } from "./installErrorStackRemapping.js"
-
-export const installBrowserErrorStackRemapping = (options = {}) =>
-  installErrorStackRemapping({
-    fetchFile: async (url) => {
-      // browser having Error.captureStackTrace got window.fetch
-      // and this executes only when Error.captureStackTrace exists
-      // so no need for polyfill or whatever here
-      const response = await window.fetch(url, {
-        // by default a script tag is in "no-cors"
-        // so we also fetch url with "no-cors"
-        mode: "no-cors",
-      })
-      // we read response test before anything because once memoized fetch
-      // gets annoying preventing you to read
-      // body multiple times, even using response.clone()
-      const text = await response.text()
-      return {
-        status: response.status,
-        url: response.url,
-        statusText: response.statusText,
-        headers: responseToHeaders(response),
-        text: () => text,
-        json: response.json.bind(response),
-        blob: response.blob.bind(response),
-        arrayBuffer: response.arrayBuffer.bind(response),
-      }
-    },
-    resolveFile: (specifier, importer = window.location.href) => {
-      // browsers having Error.captureStrackTrace got window.URL
-      // and this executes only when Error.captureStackTrace exists
-      return String(new URL(specifier, importer))
-    },
-    ...options,
-  })
-
-const responseToHeaders = (response) => {
-  const headers = {}
-  response.headers.forEach((value, name) => {
-    headers[name] = value
-  })
-  return headers
-}

package/src/internal/error-stack-remapping/installErrorStackRemapping.js

@@ -1,141 +0,0 @@
-import { createDetailedMessage } from "@jsenv/logger"
-import { stackToString } from "./stackToString.js"
-import { getOriginalCallsites } from "./getOriginalCallsites.js"
-
-export const installErrorStackRemapping = ({
-  fetchFile,
-  resolveFile,
-  SourceMapConsumer,
-  indent = "  ",
-}) => {
-  if (typeof fetchFile !== "function") {
-    throw new TypeError(`fetchFile must be a function, got ${fetchFile}`)
-  }
-  if (typeof SourceMapConsumer !== "function") {
-    throw new TypeError(
-      `sourceMapConsumer must be a function, got ${SourceMapConsumer}`,
-    )
-  }
-  if (typeof indent !== "string") {
-    throw new TypeError(`indent must be a string, got ${indent}`)
-  }
-
-  const errorRemappingCache = new WeakMap()
-  const errorRemapFailureCallbackMap = new WeakMap()
-
-  let installed = false
-  const previousPrepareStackTrace = Error.prepareStackTrace
-  const install = () => {
-    if (installed) return
-    installed = true
-    Error.prepareStackTrace = prepareStackTrace
-  }
-
-  const uninstall = () => {
-    if (!installed) return
-    installed = false
-    Error.prepareStackTrace = previousPrepareStackTrace
-  }
-
-  // ensure we do not use prepareStackTrace for thoose error
-  // otherwise we would recursively remap error stack
-  // and if the reason causing the failure is still here
-  // it would create an infinite loop
-  const readErrorStack = (error) => {
-    uninstall()
-    const stack = error.stack
-    install()
-    return stack
-  }
-
-  const prepareStackTrace = (error, stack) => {
-    const onFailure = (failureData) => {
-      const failureCallbackArray = errorRemapFailureCallbackMap.get(error)
-      if (failureCallbackArray) {
-        failureCallbackArray.forEach((callback) => callback(failureData))
-      }
-    }
-
-    const stackRemappingPromise = getOriginalCallsites({
-      stack,
-      error,
-      resolveFile,
-      fetchFile: memoizeFetch(fetchFile),
-      SourceMapConsumer,
-      readErrorStack,
-      indent,
-      onFailure,
-    })
-    errorRemappingCache.set(error, stackRemappingPromise)
-
-    return stackToString(stack, { error, indent })
-  }
-
-  const getErrorOriginalStackString = async (
-    error,
-    {
-      onFailure = (message) => {
-        console.warn(message)
-      },
-    } = {},
-  ) => {
-    if (onFailure) {
-      const remapFailureCallbackArray = errorRemapFailureCallbackMap.get(error)
-      if (remapFailureCallbackArray) {
-        errorRemapFailureCallbackMap.set(error, [
-          ...remapFailureCallbackArray,
-          onFailure,
-        ])
-      } else {
-        errorRemapFailureCallbackMap.set(error, [onFailure])
-      }
-    }
-
-    // ensure Error.prepareStackTrace gets triggered by reading error.stack now
-    const { stack } = error
-    const promise = errorRemappingCache.get(error)
-
-    if (promise) {
-      try {
-        const originalCallsites = await promise
-        errorRemapFailureCallbackMap.get(error)
-
-        const firstCall = originalCallsites[0]
-        if (firstCall) {
-          Object.assign(error, {
-            filename: firstCall.getFileName(),
-            lineno: firstCall.getLineNumber(),
-            columnno: firstCall.getColumnNumber(),
-          })
-        }
-        return stackToString(originalCallsites, { error, indent })
-      } catch (e) {
-        onFailure(
-          createDetailedMessage(`error while computing original stack.`, {
-            ["stack from error while computing"]: readErrorStack(e),
-            ["stack from error to remap"]: stack,
-          }),
-        )
-        return stack
-      }
-    }
-
-    return stack
-  }
-
-  install()
-
-  return { getErrorOriginalStackString, uninstall }
-}
-
-const memoizeFetch = (fetchUrl) => {
-  const urlCache = {}
-  return async (url) => {
-    if (url in urlCache) {
-      return urlCache[url]
-    }
-    const responsePromise = fetchUrl(url)
-    urlCache[url] = responsePromise
-    return responsePromise
-  }
-}

package/src/internal/error-stack-remapping/installNodeErrorStackRemapping.js

@@ -1,20 +0,0 @@
-import { ensureWindowsDriveLetter, resolveUrl } from "@jsenv/filesystem"
-import { require } from "@jsenv/core/src/internal/require.js"
-import { fetchUrl } from "../fetchUrl.js"
-import { installErrorStackRemapping } from "./installErrorStackRemapping.js"
-
-export const installNodeErrorStackRemapping = ({
-  projectDirectoryUrl,
-  ...options
-}) => {
-  const { SourceMapConsumer } = require("source-map")
-
-  return installErrorStackRemapping({
-    SourceMapConsumer,
-    fetchFile: fetchUrl,
-    resolveFile: (specifier, importer = projectDirectoryUrl) => {
-      return ensureWindowsDriveLetter(resolveUrl(specifier, importer), importer)
-    },
-    ...options,
-  })
-}