npm - @jsenv/core - Versions diffs - 26.0.1 → 27.0.0-alpha.2 - Mend

@jsenv/core 26.0.1 → 27.0.0-alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (465) hide show

package/src/internal/redirector/redirector.html DELETED Viewed

@@ -1,40 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Jsenv redirector</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta charset="utf-8" />
-    <link rel="icon" href="data:," />
-  </head>
-  <body>
-    <script type="importmap" src="../../../node_resolution.importmap"></script>
-    <script type="module">
-      import { scanBrowserRuntimeFeatures } from "../features/browser_feature_detection/browser_feature_detection.js"
-      const redirect = async () => {
-        const searchParams = new URLSearchParams(window.location.search)
-        const redirectTarget = searchParams.get("redirect")
-        const forceCompilation = searchParams.get("force_compilation")
-        const browserRuntimeProfile = await scanBrowserRuntimeFeatures({
-          forceCompilation: forceCompilation === "1",
-        })
-        const href = `${getDirectoryUrl(
-          browserRuntimeProfile,
-        )}${redirectTarget}`
-        // It's IMPORTANT to use location.replace and NOT location.href = url
-        // otherwise it would break the back button
-        window.location.replace(href)
-      }
-      const getDirectoryUrl = ({ jsenvDirectoryRelativeUrl, compileId }) => {
-        if (compileId) {
-          return `/${jsenvDirectoryRelativeUrl}${compileId}/`
-        }
-        return `/`
-      }
-      redirect()
-    </script>
-  </body>
-</html>

package/src/internal/regexp_escape.js DELETED Viewed

@@ -1,34 +0,0 @@
-// https://github.com/benjamingr/RegExp.escape/blob/master/polyfill.js
-export const escapeRegexpSpecialCharacters = (string) => {
-  string = String(string)
-  let i = 0
-  let escapedString = ""
-  while (i < string.length) {
-    const char = string[i]
-    i++
-    escapedString += isRegExpSpecialChar(char) ? `\\${char}` : char
-  }
-  return escapedString
-}
-const isRegExpSpecialChar = (char) => regexpSpecialChars.indexOf(char) > -1
-const regexpSpecialChars = [
-  "/",
-  "^",
-  "\\",
-  "[",
-  "]",
-  "(",
-  ")",
-  "{",
-  "}",
-  "?",
-  "+",
-  "*",
-  ".",
-  "|",
-  "$",
-]

package/src/internal/require.js DELETED Viewed

@@ -1,3 +0,0 @@
-import { createRequire } from "module"
-export const require = createRequire(import.meta.url)

package/src/internal/response_validation.js DELETED Viewed

@@ -1,130 +0,0 @@
-import { stringifyUrlTrace } from "./building/url_trace.js"
-export const validateResponse = async (
-  response,
-  {
-    originalUrl,
-    urlTrace,
-    statusValidation = true,
-    contentTypeExpected = null,
-  } = {},
-) => {
-  const validity = { isValid: true }
-  if (statusValidation) {
-    const statusValidity = await checkStatus(response, {
-      originalUrl,
-      urlTrace,
-    })
-    mergeValidity(validity, "status", statusValidity)
-    if (!validity.isValid) {
-      return validity
-    }
-  }
-  if (contentTypeExpected) {
-    const contentTypeValidity = await checkContentType(response, {
-      originalUrl,
-      urlTrace,
-      contentTypeExpected,
-    })
-    mergeValidity(validity, "contentType", contentTypeValidity)
-    if (!validity.isValid) {
-      return validity
-    }
-  }
-  return validity
-}
-const mergeValidity = (parentValidity, childValidityName, childValidity) => {
-  parentValidity.isValid = childValidity.isValid
-  parentValidity.message = childValidity.message
-  parentValidity.details = childValidity.details
-  parentValidity[childValidityName] = childValidity
-}
-const checkStatus = async (response, { originalUrl, urlTrace }) => {
-  const url = originalUrl || response.url
-  const { status } = response
-  if (status < 200 || status > 299) {
-    return {
-      isValid: false,
-      message: `invalid response status on url`,
-      details: {
-        "response status": status,
-        url,
-        ...formatUrlTrace(urlTrace),
-        ...(response.headers["content-type"] === "application/json"
-          ? {
-              "response text": JSON.stringify(
-                await response.json(),
-                null,
-                "  ",
-              ),
-            }
-          : {
-              "response text": await response.text(),
-            }),
-      },
-    }
-  }
-  return { isValid: true }
-}
-const checkContentType = async (
-  response,
-  { originalUrl, urlTrace, contentTypeExpected },
-) => {
-  const url = originalUrl || response.url
-  const responseContentType = response.headers["content-type"] || ""
-  const isOk = Array.isArray(contentTypeExpected)
-    ? contentTypeExpected.includes(responseContentType)
-    : responseContentType === contentTypeExpected
-  if (!isOk) {
-    return {
-      isValid: false,
-      message: `invalid "content-type" on url`,
-      details: {
-        "content-type": `"${responseContentType}"`,
-        "expected content-type": formatExpectedContentType(contentTypeExpected),
-        url,
-        ...formatUrlTrace(urlTrace),
-      },
-    }
-  }
-  return {
-    isValid: true,
-  }
-}
-const formatExpectedContentType = (contentTypeExpected) => {
-  if (Array.isArray(contentTypeExpected)) {
-    return contentTypeExpected.map((value) => `"${value}"`).join(`,\n`)
-  }
-  return `"${contentTypeExpected}"`
-}
-const formatUrlTrace = (urlTrace) => {
-  if (!urlTrace) {
-    return {
-      "url trace": undefined,
-    }
-  }
-  if (typeof urlTrace === "function") {
-    const trace = urlTrace()
-    return {
-      "url trace": stringifyUrlTrace(trace),
-    }
-  }
-  if (Array.isArray(urlTrace)) {
-    return {
-      "url trace": stringifyUrlTrace(urlTrace),
-    }
-  }
-  return {
-    "url trace": urlTrace,
-  }
-}

package/src/internal/runtime_client/module_registration.js DELETED Viewed

@@ -1,207 +0,0 @@
-import { createDetailedMessage } from "@jsenv/logger"
-export const fromFunctionReturningNamespace = (fn, data) => {
-  return fromFunctionReturningRegisteredModule(() => {
-    // should we compute the namespace here
-    // or as it is done below, defer to execute ?
-    // I think defer to execute is better
-    return [
-      [],
-      (_export) => {
-        return {
-          execute: () => {
-            const namespace = fn()
-            _export(namespace)
-          },
-        }
-      },
-    ]
-  }, data)
-}
-export const getJavaScriptModuleResponseError = async (
-  response,
-  {
-    url,
-    importerUrl,
-    compileServerOrigin,
-    compileDirectoryRelativeUrl,
-    jsonContentTypeAccepted,
-  },
-) => {
-  if (response.status === 404) {
-    return new Error(
-      createDetailedMessage(
-        `JavaScript module file cannot be found`,
-        getModuleDetails({
-          url,
-          importerUrl,
-          compileServerOrigin,
-          compileDirectoryRelativeUrl,
-          notFound: true,
-        }),
-      ),
-    )
-  }
-  const contentType = response.headers["content-type"] || ""
-  if (response.status === 500 && contentType === "application/json") {
-    const bodyAsJson = await response.json()
-    if (
-      bodyAsJson.message &&
-      bodyAsJson.filename &&
-      "columnNumber" in bodyAsJson
-    ) {
-      const error = new Error(
-        createDetailedMessage(`JavaScript module file cannot be parsed`, {
-          ["parsing error message"]: bodyAsJson.message,
-          ...getModuleDetails({
-            url,
-            importerUrl,
-            compileServerOrigin,
-            compileDirectoryRelativeUrl,
-          }),
-        }),
-      )
-      error.parsingError = bodyAsJson
-      return error
-    }
-  }
-  if (response.status < 200 || response.status >= 300) {
-    return new Error(
-      createDetailedMessage(
-        `JavaScript module file response status is unexpected`,
-        {
-          ["status"]: response.status,
-          ["allowed status"]: "200 to 299",
-          ["statusText"]: response.statusText,
-          ...getModuleDetails({
-            url,
-            importerUrl,
-            compileServerOrigin,
-            compileDirectoryRelativeUrl,
-          }),
-        },
-      ),
-    )
-  }
-  if (
-    jsonContentTypeAccepted &&
-    (contentType === "application/json" || contentType.endsWith("+json"))
-  ) {
-    return null
-  }
-  if (
-    contentType !== "application/javascript" &&
-    contentType !== "text/javascript"
-  ) {
-    return new Error(
-      createDetailedMessage(
-        `Failed to load module script: Expected a JavaScript module script but the server responded with a MIME type of "${contentType}". Strict MIME type checking is enforced for module scripts per HTML spec.`,
-        {
-          ...getModuleDetails({
-            url,
-            importerUrl,
-            compileServerOrigin,
-            compileDirectoryRelativeUrl,
-          }),
-          suggestion: `Use import.meta.url or import assertions as documented in https://github.com/jsenv/jsenv-core/blob/master/docs/building/readme.md#How-to-reference-assets`,
-        },
-      ),
-    )
-  }
-  return null
-}
-export const fromFunctionReturningRegisteredModule = (fn, data) => {
-  try {
-    return fn()
-  } catch (error) {
-    if (error.name === "SyntaxError") {
-      throw new Error(
-        createDetailedMessage(`Syntax error in module.`, {
-          "syntax error stack": error.stack,
-          ...getModuleDetails(data),
-        }),
-      )
-    }
-    throw new Error(
-      createDetailedMessage(`Module instantiation error.`, {
-        ["instantiation error stack"]: error.stack,
-        ...getModuleDetails(data),
-      }),
-    )
-  }
-}
-export const getModuleDetails = ({
-  url,
-  importerUrl,
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  notFound = false,
-}) => {
-  const relativeUrl = tryToFindProjectRelativeUrl(url, {
-    compileServerOrigin,
-    compileDirectoryRelativeUrl,
-  })
-  const importerRelativeUrl = tryToFindProjectRelativeUrl(importerUrl, {
-    compileServerOrigin,
-    compileDirectoryRelativeUrl,
-  })
-  const details = notFound
-    ? {
-        ...(importerUrl
-          ? { ["import declared in"]: importerRelativeUrl || importerUrl }
-          : {}),
-        ...(relativeUrl ? { file: relativeUrl } : {}),
-        ["file url"]: url,
-      }
-    : {
-        ...(relativeUrl ? { file: relativeUrl } : {}),
-        ["file url"]: url,
-        ...(importerUrl
-          ? { ["imported by"]: importerRelativeUrl || importerUrl }
-          : {}),
-      }
-  return details
-}
-export const tryToFindProjectRelativeUrl = (
-  url,
-  { compileServerOrigin, compileDirectoryRelativeUrl },
-) => {
-  if (!url) {
-    return null
-  }
-  if (!url.startsWith(`${compileServerOrigin}/`)) {
-    return null
-  }
-  if (url === compileServerOrigin) {
-    return null
-  }
-  const afterOrigin = url.slice(`${compileServerOrigin}/`.length)
-  if (!afterOrigin.startsWith(compileDirectoryRelativeUrl)) {
-    return null
-  }
-  const afterCompileDirectory = afterOrigin.slice(
-    compileDirectoryRelativeUrl.length,
-  )
-  return afterCompileDirectory
-}
-// const textToBase64 =
-//   typeof window === "object"
-//     ? (text) => window.btoa(window.unescape(window.encodeURIComponent(text)))
-//     : (text) => Buffer.from(text, "utf8").toString("base64")