@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/browser_client/browser_client.js

@@ -1,220 +0,0 @@
-import { fetchUrl } from "@jsenv/core/src/internal/browser_utils/fetch_browser.js"
-import { fetchAndEval } from "@jsenv/core/src/internal/browser_utils/fetch_and_eval.js"
-import { unevalException } from "@jsenv/core/src/internal/runtime_client/uneval_exception.js"
-import { memoize } from "@jsenv/core/src/internal/memoize.js"
-
-import { createBrowserClient } from "./browser_client_factory.js"
-import { installBrowserErrorStackRemapping } from "./browser_error_stack_remap.js"
-import { displayErrorInDocument } from "./error_in_document.js"
-import { displayErrorNotification } from "./error_in_notification.js"
-
-const getNavigationStartTime = () => {
-  try {
-    return window.performance.timing.navigationStart
-  } catch (e) {
-    return Date.now()
-  }
-}
-
-const navigationStartTime = getNavigationStartTime()
-
-const readyPromise = new Promise((resolve) => {
-  if (document.readyState === "complete") {
-    resolve()
-  } else {
-    const loadCallback = () => {
-      window.removeEventListener("load", loadCallback)
-      resolve()
-    }
-    window.addEventListener("load", loadCallback)
-  }
-})
-
-const fileExecutionMap = {}
-
-const executionResultPromise = readyPromise.then(async () => {
-  const fileExecutionResultMap = {}
-  const fileExecutionResultPromises = []
-  let status = "completed"
-  let exceptionSource = ""
-  Object.keys(fileExecutionMap).forEach((key) => {
-    fileExecutionResultMap[key] = null // to get always same order for Object.keys(executionResult)
-    const fileExecutionResultPromise = fileExecutionMap[key]
-    fileExecutionResultPromises.push(fileExecutionResultPromise)
-    fileExecutionResultPromise.then((fileExecutionResult) => {
-      fileExecutionResultMap[key] = fileExecutionResult
-      if (fileExecutionResult.status === "errored") {
-        status = "errored"
-        exceptionSource = fileExecutionResult.exceptionSource
-      }
-    })
-  })
-  await Promise.all(fileExecutionResultPromises)
-
-  return {
-    status,
-    ...(status === "errored" ? { exceptionSource } : {}),
-    startTime: navigationStartTime,
-    endTime: Date.now(),
-    fileExecutionResultMap,
-  }
-})
-
-const executeFileUsingDynamicImport = async (
-  specifier,
-  identifier = specifier,
-) => {
-  const { currentScript } = document
-  const fileExecutionResultPromise = (async () => {
-    try {
-      const url = new URL(specifier, document.location.href).href
-      performance.mark(`jsenv_file_import_start`)
-      const namespace = await import(url)
-      performance.measure(`jsenv_file_import`, `jsenv_file_import_start`)
-      const executionResult = {
-        status: "completed",
-        namespace,
-        coverage: readCoverage(),
-      }
-      return executionResult
-    } catch (e) {
-      performance.measure(`jsenv_file_import`, `jsenv_file_import_start`)
-      const executionResult = {
-        status: "errored",
-        error: e,
-        coverage: readCoverage(),
-      }
-      onExecutionError(executionResult, { currentScript })
-      return executionResult
-    }
-  })()
-  fileExecutionMap[identifier] = fileExecutionResultPromise
-  return fileExecutionResultPromise
-}
-
-const executeFileUsingSystemJs = (specifier) => {
-  // si on a déja importer ce fichier ??
-  // if (specifier in fileExecutionMap) {
-
-  // }
-
-  const { currentScript } = document
-
-  const fileExecutionResultPromise = (async () => {
-    const browserRuntime = await getBrowserRuntime()
-    const executionResult = await browserRuntime.executeFile(specifier, {
-      measurePerformance: true,
-      collectPerformance: true,
-    })
-    if (executionResult.status === "errored") {
-      onExecutionError(executionResult, { currentScript })
-    }
-    return executionResult
-  })()
-  fileExecutionMap[specifier] = fileExecutionResultPromise
-  return fileExecutionResultPromise
-}
-
-const onExecutionError = (
-  executionResult,
-  {
-    currentScript,
-    errorExposureInConsole = true,
-    errorExposureInNotification = false,
-    errorExposureInDocument = true,
-  },
-) => {
-  const error = executionResult.error
-  if (error && error.code === "NETWORK_FAILURE") {
-    if (currentScript) {
-      const errorEvent = new Event("error")
-      currentScript.dispatchEvent(errorEvent)
-    }
-  } else if (typeof error === "object") {
-    const { parsingError } = error
-    const globalErrorEvent = new Event("error")
-    if (parsingError) {
-      globalErrorEvent.filename = parsingError.filename
-      globalErrorEvent.lineno = parsingError.lineNumber
-      globalErrorEvent.message = parsingError.message
-      globalErrorEvent.colno = parsingError.columnNumber
-    } else {
-      globalErrorEvent.filename = error.filename
-      globalErrorEvent.lineno = error.lineno
-      globalErrorEvent.message = error.message
-      globalErrorEvent.colno = error.columnno
-    }
-    window.dispatchEvent(globalErrorEvent)
-  }
-
-  if (errorExposureInConsole) {
-    console.error(error)
-  }
-  if (errorExposureInNotification) {
-    displayErrorNotification(error)
-  }
-  if (errorExposureInDocument) {
-    displayErrorInDocument(error)
-  }
-
-  executionResult.exceptionSource = unevalException(error)
-  delete executionResult.error
-}
-
-const getBrowserRuntime = memoize(async () => {
-  const compileServerOrigin = document.location.origin
-  const compileServerResponse = await fetchUrl(
-    `${compileServerOrigin}/__jsenv_compile_profile__`,
-  )
-  const compileServerMeta = await compileServerResponse.json()
-  const { jsenvDirectoryRelativeUrl, errorStackRemapping } = compileServerMeta
-  const jsenvDirectoryServerUrl = `${compileServerOrigin}/${jsenvDirectoryRelativeUrl}`
-  const afterJsenvDirectory = document.location.href.slice(
-    jsenvDirectoryServerUrl.length,
-  )
-  const parts = afterJsenvDirectory.split("/")
-  const compileId = parts[0]
-
-  const browserClient = await createBrowserClient({
-    compileServerOrigin,
-    jsenvDirectoryRelativeUrl,
-    compileId,
-  })
-
-  if (errorStackRemapping && Error.captureStackTrace) {
-    const { sourcemapMainFileRelativeUrl, sourcemapMappingFileRelativeUrl } =
-      compileServerMeta
-    await fetchAndEval(`${compileServerOrigin}/${sourcemapMainFileRelativeUrl}`)
-    const { SourceMapConsumer } = window.sourceMap
-    SourceMapConsumer.initialize({
-      "lib/mappings.wasm": `${compileServerOrigin}/${sourcemapMappingFileRelativeUrl}`,
-    })
-    const { getErrorOriginalStackString } = installBrowserErrorStackRemapping({
-      SourceMapConsumer,
-    })
-    const errorTransform = async (error) => {
-      // code can throw something else than an error
-      // in that case return it unchanged
-      if (!error || !(error instanceof Error)) return error
-      const originalStack = await getErrorOriginalStackString(error)
-      error.stack = originalStack
-      return error
-    }
-    const executeFile = browserClient.executeFile
-    browserClient.executeFile = (file, options = {}) => {
-      return executeFile(file, { errorTransform, ...options })
-    }
-  }
-  return browserClient
-})
-
-const livereloadingCallbacks = {}
-
-const readCoverage = () => window.__coverage__
-
-window.__jsenv__ = {
-  livereloadingCallbacks,
-  executionResultPromise,
-  executeFileUsingDynamicImport,
-  executeFileUsingSystemJs,
-}

package/src/internal/browser_client/browser_client_factory.js

@@ -1,144 +0,0 @@
-import { normalizeImportMap } from "@jsenv/importmap/src/normalizeImportMap.js"
-
-// do not use memoize from @jsenv/filesystem to avoid pulling @jsenv/filesystem code into the browser build
-import { fetchUrl } from "@jsenv/core/src/internal/browser_utils/fetch_browser.js"
-import { createImportResolverForImportmap } from "@jsenv/core/src/internal/import_resolution/import_resolver_importmap.js"
-import { memoize } from "@jsenv/core/src/internal/memoize.js"
-
-import { createBrowserSystem } from "./browser_system.js"
-import { measureAsyncFnPerf } from "./perf_browser.js"
-import { makeModuleNamespaceTransferable } from "./module_namespace_transfer.js"
-
-const memoizedCreateBrowserSystem = memoize(createBrowserSystem)
-
-export const createBrowserClient = async ({
-  compileServerOrigin,
-  jsenvDirectoryRelativeUrl,
-  compileId,
-}) => {
-  const fetchSource = (url, { contentTypeExpected }) => {
-    return fetchUrl(url, {
-      credentials: "same-origin",
-      contentTypeExpected,
-    })
-  }
-
-  const fetchJson = async (url) => {
-    const response = await fetchSource(url, {
-      contentTypeExpected: "application/json",
-    })
-    const json = await response.json()
-    return json
-  }
-
-  const compileServerMetaUrl = String(
-    new URL("__jsenv_compile_profile__", `${compileServerOrigin}/`),
-  )
-  const { importDefaultExtension } = await fetchJson(compileServerMetaUrl)
-  const compileDirectoryRelativeUrl = `${jsenvDirectoryRelativeUrl}${compileId}/`
-  // if there is an importmap in the document we use it instead of fetching.
-  // systemjs style with systemjs-importmap
-  const importmapScript = document.querySelector(
-    `script[type="systemjs-importmap"]`,
-  )
-  let importMap
-  let importMapUrl
-  if (importmapScript) {
-    let importmapRaw
-    if (importmapScript.src) {
-      importMapUrl = importmapScript.src
-      const importmapFileResponse = await fetchSource(importMapUrl, {
-        contentTypeExpected: "application/importmap+json",
-      })
-      importmapRaw =
-        importmapFileResponse.status === 404
-          ? {}
-          : await importmapFileResponse.json()
-    } else {
-      importMapUrl = document.location.href
-      importmapRaw = JSON.parse(importmapScript.textContent) || {}
-    }
-    importMap = normalizeImportMap(importmapRaw, importMapUrl)
-  }
-
-  const importResolver = await createImportResolverForImportmap({
-    // projectDirectoryUrl,
-    compileServerOrigin,
-    compileDirectoryRelativeUrl,
-    importMap,
-    importMapUrl,
-    importDefaultExtension,
-  })
-
-  const importFile = async (specifier) => {
-    const browserSystem = await memoizedCreateBrowserSystem({
-      compileServerOrigin,
-      compileDirectoryRelativeUrl,
-      fetchSource,
-      importResolver,
-    })
-    return browserSystem.import(specifier)
-  }
-
-  const executeFile = async (
-    specifier,
-    {
-      transferableNamespace = false,
-      executionExposureOnWindow = false,
-      errorTransform = (error) => error,
-      measurePerformance,
-    } = {},
-  ) => {
-    const browserSystem = await memoizedCreateBrowserSystem({
-      compileServerOrigin,
-      compileDirectoryRelativeUrl,
-      fetchSource,
-      importResolver,
-    })
-
-    const importUsingSystemJs = async () => {
-      try {
-        let namespace = await browserSystem.import(specifier)
-
-        if (transferableNamespace) {
-          namespace = makeModuleNamespaceTransferable(namespace)
-        }
-
-        return {
-          status: "completed",
-          namespace,
-          coverage: readCoverage(),
-        }
-      } catch (error) {
-        let transformedError
-        try {
-          transformedError = await errorTransform(error)
-        } catch (e) {
-          transformedError = error
-        }
-
-        return {
-          status: "errored",
-          error: transformedError,
-          coverage: readCoverage(),
-        }
-      }
-    }
-
-    const executionResult = await (measurePerformance
-      ? measureAsyncFnPerf(importUsingSystemJs, `jsenv_file_import`)
-      : importUsingSystemJs())
-    if (executionExposureOnWindow) {
-      window.__executionResult__ = executionResult
-    }
-    return executionResult
-  }
-
-  return {
-    compileDirectoryRelativeUrl,
-    importFile,
-    executeFile,
-  }
-}
-
-const readCoverage = () => window.__coverage__

package/src/internal/browser_client/browser_error_stack_remap.js

@@ -1,43 +0,0 @@
-import { installErrorStackRemapping } from "@jsenv/core/src/internal/error_stack_remap/install_error_stack_remapping.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/browser_client/browser_system.js

@@ -1,216 +0,0 @@
-import { getJavaScriptModuleResponseError } from "@jsenv/core/src/internal/runtime_client/module_registration.js"
-import "@jsenv/core/src/internal/runtime_client/s.js"
-
-export const createBrowserSystem = ({
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  importResolver,
-  fetchSource,
-}) => {
-  if (typeof window.System === "undefined") {
-    throw new Error(`window.System is undefined`)
-  }
-
-  const browserSystem = window.System
-
-  const resolve = (specifier, importer = document.location.href) => {
-    return importResolver.resolveImport(specifier, importer)
-  }
-
-  browserSystem.resolve = resolve
-
-  const instantiate = browserSystem.instantiate
-  browserSystem.instantiate = async function (url, importerUrl) {
-    const { importType, urlWithoutImportType } = extractImportTypeFromUrl(url)
-    if (importType === "json") {
-      const jsonModule = await instantiateAsJsonModule(urlWithoutImportType, {
-        browserSystem,
-        fetchSource,
-      })
-      return jsonModule
-    }
-
-    if (importType === "css") {
-      const cssModule = await instantiateAsCssModule(urlWithoutImportType, {
-        browserSystem,
-        importerUrl,
-        compileDirectoryRelativeUrl,
-        fetchSource,
-      })
-      return cssModule
-    }
-
-    try {
-      const registration = await instantiate.call(this, url, importerUrl)
-      if (!registration) {
-        throw new Error(
-          `no registration found for JS at ${url}
---- importer url ---
-${importerUrl}
---- navigator.vendor ---
-${window.navigator.vendor}`,
-        )
-      }
-      return registration
-    } catch (e) {
-      const jsenvError = await createDetailedInstantiateError({
-        instantiateError: e,
-        url,
-        importerUrl,
-        compileServerOrigin,
-        compileDirectoryRelativeUrl,
-        fetchSource,
-      })
-      throw jsenvError
-    }
-  }
-
-  browserSystem.createContext = (importerUrl) => {
-    return {
-      url: importerUrl,
-      resolve: (specifier) => resolve(specifier, importerUrl),
-    }
-  }
-
-  return browserSystem
-}
-
-const extractImportTypeFromUrl = (url) => {
-  const urlObject = new URL(url)
-  const { search } = urlObject
-  const searchParams = new URLSearchParams(search)
-
-  const importType = searchParams.get("import_type")
-  if (!importType) {
-    return {}
-  }
-
-  searchParams.delete("import_type")
-  urlObject.search = String(searchParams)
-  return {
-    importType,
-    urlWithoutImportType: urlObject.href,
-  }
-}
-
-const instantiateAsJsonModule = async (url, { browserSystem, fetchSource }) => {
-  const response = await fetchSource(url, {
-    contentTypeExpected: "application/json",
-  })
-  const json = await response.json()
-  browserSystem.register([], (_export) => {
-    return {
-      execute: () => {
-        _export("default", json)
-      },
-    }
-  })
-  const registration = browserSystem.getRegister(url)
-  if (!registration) {
-    throw new Error(
-      `no registration found for JSON at ${url}. Navigator.vendor: ${window.navigator.vendor}. JSON text: ${json}`,
-    )
-  }
-  return registration
-}
-
-const instantiateAsCssModule = async (
-  url,
-  { importerUrl, compileDirectoryRelativeUrl, browserSystem, fetchSource },
-) => {
-  const response = await fetchSource(url, {
-    contentTypeExpected: "text/css",
-  })
-
-  // There is a logic inside "toolbar.eventsource.js" which is reloading
-  // all link rel="stylesheet" when file ending with ".css" are modified
-  // But here it would not work because we have to replace the css in
-  // the adopted stylsheet + all module importing this css module
-  // should be reinstantiated
-  // -> store a livereload callback forcing whole page reload
-  const compileDirectoryServerUrl = `${window.location.origin}/${compileDirectoryRelativeUrl}`
-  const originalFileRelativeUrl = response.url.slice(
-    compileDirectoryServerUrl.length,
-  )
-  window.__jsenv__.livereloadingCallbacks[originalFileRelativeUrl] = ({
-    reloadPage,
-  }) => {
-    reloadPage()
-  }
-
-  const cssText = await response.text()
-  const cssTextWithBaseUrl = cssWithBaseUrl({
-    cssText,
-    cssUrl: url,
-    baseUrl: importerUrl,
-  })
-
-  browserSystem.register([], (_export) => {
-    return {
-      execute: () => {
-        const sheet = new CSSStyleSheet()
-        sheet.replaceSync(cssTextWithBaseUrl)
-        _export("default", sheet)
-      },
-    }
-  })
-  const registration = browserSystem.getRegister(url)
-  if (!registration) {
-    throw new Error(
-      `no registration found for CSS at ${url}. Navigator.vendor: ${window.navigator.vendor}. CSS text: ${cssTextWithBaseUrl}`,
-    )
-  }
-  return registration
-}
-
-// CSSStyleSheet accepts a "baseUrl" parameter
-// as documented in https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet/CSSStyleSheet#parameters
-// Unfortunately the polyfill do not seems to implement it
-// So we reuse "systemjs" strategy from https://github.com/systemjs/systemjs/blob/98609dbeef01ec62447e4b21449ce47e55f818bd/src/extras/module-types.js#L37
-const cssWithBaseUrl = ({ cssUrl, cssText, baseUrl }) => {
-  const cssDirectoryUrl = new URL("./", cssUrl).href
-  const baseDirectoryUrl = new URL("./", baseUrl).href
-  if (cssDirectoryUrl === baseDirectoryUrl) {
-    return cssText
-  }
-
-  const cssTextRelocated = cssText.replace(
-    /url\(\s*(?:(["'])((?:\\.|[^\n\\"'])+)\1|((?:\\.|[^\s,"'()\\])+))\s*\)/g,
-    (match, quotes, relUrl1, relUrl2) => {
-      const absoluteUrl = new URL(relUrl1 || relUrl2, cssUrl).href
-      return `url(${quotes}${absoluteUrl}${quotes})`
-    },
-  )
-  return cssTextRelocated
-}
-
-const createDetailedInstantiateError = async ({
-  instantiateError,
-  url,
-  importerUrl,
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  fetchSource,
-}) => {
-  let response
-  try {
-    response = await fetchSource(url, {
-      importerUrl,
-      contentTypeExpected: "application/javascript",
-    })
-  } catch (e) {
-    e.code = "NETWORK_FAILURE"
-    return e
-  }
-
-  const jsModuleResponseError = await getJavaScriptModuleResponseError(
-    response,
-    {
-      url,
-      importerUrl,
-      compileServerOrigin,
-      compileDirectoryRelativeUrl,
-    },
-  )
-  return jsModuleResponseError || instantiateError
-}