@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/omega/errors.js

@@ -0,0 +1,168 @@
+import { createDetailedMessage } from "@jsenv/logger"
+
+export const createResolveError = ({ pluginController, reference, error }) => {
+  const createFailedToResolveError = ({
+    code = error.code || "RESOLVE_ERROR",
+    reason,
+    ...details
+  }) => {
+    const resolveError = new Error(
+      createDetailedMessage(`Failed to resolve specifier`, {
+        reason,
+        ...details,
+        "specifier": `"${reference.specifier}"`,
+        "specifier trace": reference.trace,
+        ...detailsFromPluginController(pluginController),
+      }),
+    )
+    resolveError.name = "RESOLVE_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 createFailedToResolveError({
+    reason: `An error occured during specifier resolution`,
+    ...detailsFromValueThrown(error),
+  })
+}
+
+export const createLoadError = ({
+  pluginController,
+  reference,
+  urlInfo,
+  error,
+}) => {
+  const createFailedToLoadError = ({
+    code = error.code || "LOAD_ERROR",
+    reason,
+    ...details
+  }) => {
+    const loadError = new Error(
+      createDetailedMessage(`Failed to load url`, {
+        reason,
+        ...details,
+        "url": urlInfo.url,
+        "url reference trace": reference.trace,
+        ...detailsFromPluginController(pluginController),
+      }),
+    )
+    loadError.name = "LOAD_ERROR"
+    loadError.code = code
+    loadError.reason = reason
+    return loadError
+  }
+
+  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({
+      code: "NOT_ALLOWED",
+      reason: `not allowed to read entry on filesystem`,
+    })
+  }
+  if (error.code === "EISDIR") {
+    return createFailedToLoadError({
+      code: "EISDIR",
+      reason: `found a directory on filesystem`,
+    })
+  }
+  if (error.code === "ENOENT") {
+    return createFailedToLoadError({
+      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`,
+    ...detailsFromValueThrown(error),
+  })
+}
+
+export const createTransformError = ({
+  pluginController,
+  reference,
+  urlInfo,
+  error,
+}) => {
+  const createFailedToTransformError = ({
+    code = error.code || "TRANSFORM_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),
+      }),
+    )
+    transformError.name = "TRANSFORM_ERROR"
+    transformError.code = code
+    transformError.reason = reason
+    return transformError
+  }
+  return createFailedToTransformError({
+    reason: `An error occured during "transform"`,
+    ...detailsFromValueThrown(error),
+  })
+}
+
+const detailsFromPluginController = (pluginController) => {
+  const currentPlugin = pluginController.getCurrentPlugin()
+  if (!currentPlugin) {
+    return null
+  }
+  return { "plugin name": `"${currentPlugin.name}"` }
+}
+
+const detailsFromValueThrown = (valueThrownByPlugin) => {
+  if (valueThrownByPlugin && valueThrownByPlugin instanceof Error) {
+    return {
+      "error stack": valueThrownByPlugin.stack,
+    }
+  }
+  if (valueThrownByPlugin === undefined) {
+    return {
+      error: "undefined",
+    }
+  }
+  return {
+    error: JSON.stringify(valueThrownByPlugin),
+  }
+}

package/src/omega/file_url_converter.js

@@ -0,0 +1,63 @@
+import { fileSystemPathToUrl, urlToFileSystemPath } from "@jsenv/filesystem"
+
+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
+  },
+  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)
+  },
+}
+
+const stringifyQuery = (searchParams) => {
+  const search = searchParams.toString()
+  return search ? `?${search}` : ""
+}