@jsenv/core 27.0.0-alpha.9 → 27.0.0-alpha.92

package/src/omega/{runtime_support/runtime_support.js → compat/runtime_compat.js}

@@ -1,39 +1,38 @@
-import { findHighestVersion } from "@jsenv/utils/semantic_versioning/highest_version.js"
-import { featureCompats } from "./features_compatibility.js"
+import { findHighestVersion } from "@jsenv/utils/src/semantic_versioning/highest_version.js"
 
-export const RUNTIME_SUPPORT = {
+import { featureCompats } from "./features_compats.js"
+
+export const RUNTIME_COMPAT = {
   featureCompats,
 
-  add: (originalRuntimeSupport, feature) => {
+  add: (originalRuntimeCompat, feature) => {
     const featureCompat = getFeatureCompat(feature)
-    const runtimeSupport = {
-      ...originalRuntimeSupport,
+    const runtimeCompat = {
+      ...originalRuntimeCompat,
     }
     Object.keys(featureCompat).forEach((runtimeName) => {
-      const firstVersion = originalRuntimeSupport[runtimeName]
+      const firstVersion = originalRuntimeCompat[runtimeName]
       const secondVersion = featureCompat[runtimeName]
-      runtimeSupport[runtimeName] = firstVersion
+      runtimeCompat[runtimeName] = firstVersion
         ? findHighestVersion(firstVersion, secondVersion)
         : secondVersion
     })
-    return runtimeSupport
+    return runtimeCompat
   },
 
-  isSupported: (runtimeSupport, feature) => {
+  isSupported: (runtimeCompat, feature) => {
     const featureCompat = getFeatureCompat(feature)
-    const runtimeNames = Object.keys(runtimeSupport)
-    return runtimeNames.every((runtimeName) => {
-      const runtimeVersion = runtimeSupport[runtimeName]
+    const runtimeNames = Object.keys(runtimeCompat)
+    const runtimeWithoutCompat = runtimeNames.find((runtimeName) => {
+      const runtimeVersion = runtimeCompat[runtimeName]
       const runtimeVersionCompatible = featureCompat[runtimeName] || "Infinity"
       const highestVersion = findHighestVersion(
         runtimeVersion,
         runtimeVersionCompatible,
       )
-      if (highestVersion !== runtimeVersion) {
-        return false
-      }
-      return true
+      return highestVersion !== runtimeVersion
     })
+    return !runtimeWithoutCompat
   },
 }
 

package/src/omega/errors.js

@@ -1,13 +1,17 @@
-import { createDetailedMessage } from "@jsenv/logger"
+import { createDetailedMessage } from "@jsenv/log"
 
-export const createResolveError = ({ pluginController, reference, error }) => {
-  const createFailedToResolveError = ({
-    code = error.code || "RESOLVE_ERROR",
+export const createResolveUrlError = ({
+  pluginController,
+  reference,
+  error,
+}) => {
+  const createFailedToResolveUrlError = ({
+    code = error.code || "RESOLVE_URL_ERROR",
     reason,
     ...details
   }) => {
     const resolveError = new Error(
-      createDetailedMessage(`Failed to resolve specifier`, {
+      createDetailedMessage(`Failed to resolve url reference`, {
         reason,
         ...details,
         "specifier": `"${reference.specifier}"`,
@@ -15,35 +19,35 @@ export const createResolveError = ({ pluginController, reference, error }) => {
         ...detailsFromPluginController(pluginController),
       }),
     )
-    resolveError.name = "RESOLVE_ERROR"
+    resolveError.name = "RESOLVE_URL_ERROR"
     resolveError.code = code
     resolveError.reason = reason
     return resolveError
   }
   if (error.message === "NO_RESOLVE") {
-    return createFailedToResolveError({
-      reason: `no plugin has handled the specifier during "resolve" hook`,
+    return createFailedToResolveUrlError({
+      reason: `no plugin has handled the specifier during "resolveUrl" hook`,
     })
   }
-  return createFailedToResolveError({
+  return createFailedToResolveUrlError({
     reason: `An error occured during specifier resolution`,
     ...detailsFromValueThrown(error),
   })
 }
 
-export const createLoadError = ({
+export const createFetchUrlContentError = ({
   pluginController,
   reference,
   urlInfo,
   error,
 }) => {
-  const createFailedToLoadError = ({
-    code = error.code || "LOAD_ERROR",
+  const createFailedToFetchUrlContentError = ({
+    code = error.code || "FETCH_URL_CONTENT_ERROR",
     reason,
     ...details
   }) => {
-    const loadError = new Error(
-      createDetailedMessage(`Failed to load url`, {
+    const fetchContentError = new Error(
+      createDetailedMessage(`Failed to fetch url content`, {
         reason,
         ...details,
         "url": urlInfo.url,
@@ -51,98 +55,90 @@ export const createLoadError = ({
         ...detailsFromPluginController(pluginController),
       }),
     )
-    loadError.name = "LOAD_ERROR"
-    loadError.code = code
-    loadError.reason = reason
-    return loadError
+    fetchContentError.name = "FETCH_URL_CONTENT_ERROR"
+    fetchContentError.code = code
+    fetchContentError.reason = reason
+    return fetchContentError
   }
 
-  if (error.message === "NO_LOAD") {
-    return createFailedToLoadError({
-      code: "NOT_FOUND",
-      reason: `no plugin has handled the url during "load" hook`,
-    })
-  }
   if (error.code === "EPERM") {
-    return createFailedToLoadError({
+    return createFailedToFetchUrlContentError({
       code: "NOT_ALLOWED",
       reason: `not allowed to read entry on filesystem`,
     })
   }
-  if (error.code === "EISDIR") {
-    return createFailedToLoadError({
-      code: "EISDIR",
+  if (error.code === "DIRECTORY_REFERENCE_NOT_ALLOWED") {
+    return createFailedToFetchUrlContentError({
+      code: "DIRECTORY_REFERENCE_NOT_ALLOWED",
       reason: `found a directory on filesystem`,
     })
   }
   if (error.code === "ENOENT") {
-    return createFailedToLoadError({
+    return createFailedToFetchUrlContentError({
       code: "NOT_FOUND",
       reason: "no entry on filesystem",
     })
   }
-  return createFailedToLoadError({
-    reason: `An error occured during "load"`,
-    ...detailsFromValueThrown(error),
-  })
-}
-
-export const createParseError = ({ reference, urlInfo, error }) => {
-  const createFailedToParseError = ({
-    code = error.code || "PARSE_ERROR",
-    reason,
-    ...details
-  }) => {
-    const parseError = new Error(
-      createDetailedMessage(`Failed to parse ${urlInfo.type}`, {
-        reason,
-        ...details,
-        "url": urlInfo.url,
-        "url reference trace": reference.trace,
-      }),
-    )
-    parseError.name = "PARSE_ERROR"
-    parseError.code = code
-    parseError.reason = reason
-    return parseError
-  }
-  return createFailedToParseError({
-    reason: `An error occured while parsing content`,
+  return createFailedToFetchUrlContentError({
+    reason: `An error occured during "fetchUrlContent"`,
     ...detailsFromValueThrown(error),
   })
 }
 
-export const createTransformError = ({
+export const createTransformUrlContentError = ({
   pluginController,
   reference,
   urlInfo,
   error,
 }) => {
   const createFailedToTransformError = ({
-    code = error.code || "TRANSFORM_ERROR",
+    code = error.code || "TRANSFORM_URL_CONTENT_ERROR",
     reason,
     ...details
   }) => {
     const transformError = new Error(
-      createDetailedMessage(`Failed to transform ${urlInfo.type}`, {
-        reason,
-        ...details,
-        "url": urlInfo.url,
-        "url reference trace": reference.trace,
-        ...detailsFromPluginController(pluginController),
-      }),
+      createDetailedMessage(
+        `Failed to transform url content of "${urlInfo.type}"`,
+        {
+          reason,
+          ...details,
+          "url": urlInfo.url,
+          "url reference trace": reference.trace,
+          ...detailsFromPluginController(pluginController),
+        },
+      ),
     )
-    transformError.name = "TRANSFORM_ERROR"
+    transformError.name = "TRANSFORM_URL_CONTENT_ERROR"
     transformError.code = code
     transformError.reason = reason
     return transformError
   }
   return createFailedToTransformError({
-    reason: `An error occured during "transform"`,
+    reason: `An error occured during "transformUrlContent"`,
     ...detailsFromValueThrown(error),
   })
 }
 
+export const createFinalizeUrlContentError = ({
+  pluginController,
+  reference,
+  urlInfo,
+  error,
+}) => {
+  const finalizeError = new Error(
+    createDetailedMessage(`Failed to finalize ${urlInfo.type} url content`, {
+      "reason": `An error occured during "finalizeUrlContent"`,
+      ...detailsFromValueThrown(error),
+      "url": urlInfo.url,
+      "url reference trace": reference.trace,
+      ...detailsFromPluginController(pluginController),
+    }),
+  )
+  finalizeError.name = "FINALIZE_URL_CONTENT_ERROR"
+  finalizeError.reason = `An error occured during "finalizeUrlContent"`
+  return finalizeError
+}
+
 const detailsFromPluginController = (pluginController) => {
   const currentPlugin = pluginController.getCurrentPlugin()
   if (!currentPlugin) {

package/src/omega/fetched_content_compliance.js

@@ -0,0 +1,24 @@
+import { validateResponseIntegrity } from "@jsenv/integrity"
+
+export const assertFetchedContentCompliance = ({ reference, urlInfo }) => {
+  const { expectedContentType } = reference
+  if (expectedContentType && urlInfo.contentType !== expectedContentType) {
+    throw new Error(
+      `Unexpected content-type on url: got "${urlInfo.contentType}" instead of "${expectedContentType}"`,
+    )
+  }
+  const { expectedType } = reference
+  if (expectedType && urlInfo.type !== expectedType) {
+    throw new Error(
+      `Unexpected type on url: got "${urlInfo.type}" instead of "${expectedType}"`,
+    )
+  }
+  const { integrity } = reference
+  if (integrity) {
+    validateResponseIntegrity({
+      url: urlInfo.url,
+      type: "basic",
+      dataRepresentation: urlInfo.content,
+    })
+  }
+}

package/src/omega/file_url_converter.js

@@ -1,59 +1,17 @@
-import { fileSystemPathToUrl, urlToFileSystemPath } from "@jsenv/filesystem"
+import { fileSystemPathToUrl, urlToFileSystemPath } from "@jsenv/urls"
 
 export const fileUrlConverter = {
-  asUrlWithoutSpecialParams: (fileUrl) => {
-    const urlObject = new URL(fileUrl)
-    let { origin, pathname, searchParams, hash } = urlObject
-    // origin is "null" for "file://" urls with Node.js
-    if (origin === "null" && urlObject.href.startsWith("file:")) {
-      origin = "file://"
-    }
-    if (searchParams.has("json_module")) {
-      searchParams.delete("json_module")
-      return `${origin}${pathname}.json_module${stringifyQuery(
-        searchParams,
-      )}${hash}`
-    }
-    if (searchParams.has("css_module")) {
-      searchParams.delete("css_module")
-      return `${origin}${pathname}.css_module${stringifyQuery(
-        searchParams,
-      )}${hash}`
-    }
-    if (searchParams.has("text_module")) {
-      searchParams.delete("text_module")
-      return `${origin}${pathname}.text_module${stringifyQuery(
-        searchParams,
-      )}${hash}`
-    }
-    return fileUrl
-  },
   asFilePath: (fileUrl) => {
-    const fileUrlWithoutSpecialParam =
-      fileUrlConverter.asUrlWithoutSpecialParams(fileUrl)
-    const filePath = urlToFileSystemPath(fileUrlWithoutSpecialParam)
-    return filePath
+    const filePath = urlToFileSystemPath(fileUrl)
+    const urlObject = new URL(fileUrl)
+    const { searchParams } = urlObject
+    return `${filePath}${stringifyQuery(searchParams)}`
   },
   asFileUrl: (filePath) => {
-    if (filePath.endsWith(".json_module")) {
-      const jsonFileUrl = fileSystemPathToUrl(
-        filePath.slice(0, -".json_module".length),
-      )
-      return `${jsonFileUrl}?json_module`
-    }
-    if (filePath.endsWith(".css_module")) {
-      const cssFileUrl = fileSystemPathToUrl(
-        filePath.slice(0, -".css_module".length),
-      )
-      return `${cssFileUrl}?css_module`
-    }
-    if (filePath.endsWith(".text_module")) {
-      const textFileUrl = fileSystemPathToUrl(
-        filePath.slice(0, -".text_module".length),
-      )
-      return `${textFileUrl}?text_module`
-    }
-    return fileSystemPathToUrl(filePath)
+    return decodeURIComponent(fileSystemPathToUrl(filePath)).replace(
+      /[=](?=&|$)/g,
+      "",
+    )
   },
 }