@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/internal/browser_runtime/browser_system.js

@@ -1,218 +0,0 @@
-/* eslint-env browser */
-
-import { getJavaScriptModuleResponseError } from "../runtime/module-registration.js"
-import "../runtime/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
-}

package/src/internal/browser_runtime/createBrowserRuntime.js

@@ -1,146 +0,0 @@
-/* eslint-env browser */
-
-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 "../browser_utils/fetch_browser.js"
-import { createImportResolverForImportmap } from "../import-resolution/import-resolver-importmap.js"
-import { memoize } from "../memoize.js"
-import { measureAsyncFnPerf } from "../perf_browser.js"
-
-import { createBrowserSystem } from "./browser_system.js"
-import { makeNamespaceTransferable } from "./makeNamespaceTransferable.js"
-
-const memoizedCreateBrowserSystem = memoize(createBrowserSystem)
-
-export const createBrowserRuntime = 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 = makeNamespaceTransferable(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_runtime/evalSource.js

@@ -1,11 +0,0 @@
-/* eslint-env browser */
-
-export const evalSource = (code, href) => {
-  // eslint-disable-next-line no-eval
-  return window.eval(appendSourceURL(code, href))
-}
-
-const appendSourceURL = (code, sourceURL) => {
-  return `${code}
-${"//#"} sourceURL=${sourceURL}`
-}

package/src/internal/browser_runtime/makeNamespaceTransferable.js

@@ -1,90 +0,0 @@
-export const makeNamespaceTransferable = (namespace) => {
-  const transferableNamespace = {}
-  Object.keys(namespace).forEach((key) => {
-    const value = namespace[key]
-    transferableNamespace[key] = isTransferable(value)
-      ? value
-      : hideNonTransferableValue(value)
-  })
-  return transferableNamespace
-}
-
-const hideNonTransferableValue = (value) => {
-  if (typeof value === "function") {
-    return `[[HIDDEN: ${value.name} function cannot be transfered]]`
-  }
-
-  if (typeof value === "symbol") {
-    return `[[HIDDEN: symbol function cannot be transfered]]`
-  }
-
-  return `[[HIDDEN: ${
-    value.constructor ? value.constructor.name : "object"
-  } cannot be transfered]]`
-}
-
-// https://stackoverflow.com/a/32673910/2634179
-const isTransferable = (value) => {
-  const seenArray = []
-  const visit = () => {
-    if (typeof value === "function") return false
-
-    if (typeof value === "symbol") return false
-
-    if (value === null) return false
-
-    if (typeof value === "object") {
-      const constructorName = value.constructor.namespace
-
-      if (supportedTypes.includes(constructorName)) {
-        return true
-      }
-
-      const maybe = maybeTypes.includes(constructorName)
-      if (maybe) {
-        const visited = seenArray.includes(value)
-        if (visited) {
-          // we don't really know until we are done visiting the object
-          // implementing it properly means waiting for the recursion to be done
-          // let's just
-          return true
-        }
-        seenArray.push(value)
-
-        if (constructorName === "Array" || constructorName === "Object") {
-          return Object.keys(value).every((key) => isTransferable(value[key]))
-        }
-        if (constructorName === "Map") {
-          return (
-            [...value.keys()].every(isTransferable) &&
-            [...value.values()].every(isTransferable)
-          )
-        }
-        if (constructorName === "Set") {
-          return [...value.keys()].every(isTransferable)
-        }
-      }
-
-      // Error, DOM Node and others
-      return false
-    }
-    return true
-  }
-
-  return visit(value)
-}
-
-const supportedTypes = [
-  "Boolean",
-  "Number",
-  "String",
-  "Date",
-  "RegExp",
-  "Blob",
-  "FileList",
-  "ImageData",
-  "ImageBitmap",
-  "ArrayBuffer",
-]
-
-const maybeTypes = ["Array", "Object", "Map", "Set"]

package/src/internal/browser_utils/fetchAndEvalUsingFetch.js

@@ -1,29 +0,0 @@
-/* eslint-env browser */
-
-import { createDetailedMessage } from "@jsenv/logger"
-
-import { fetchUrl } from "./fetch_browser.js"
-
-export const fetchAndEvalUsingFetch = 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/fetchAndEvalUsingScript.js

@@ -1,49 +0,0 @@
-/* eslint-env browser */
-
-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/fetchJson.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/browser_utils/fetch_browser.js

@@ -1,34 +0,0 @@
-import { fetchUsingXHR } from "./fetchUsingXHR.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