@jsenv/core 35.0.2 → 35.0.4

package/src/helpers/worker_reload.js

@@ -1,27 +1,27 @@
-import { fileURLToPath } from "node:url"
-import { Worker, workerData } from "node:worker_threads"
+import { fileURLToPath } from "node:url";
+import { Worker, workerData } from "node:worker_threads";
 
 // https://nodejs.org/api/worker_threads.html
 export const createReloadableWorker = (workerFileUrl, options = {}) => {
-  const workerFilePath = fileURLToPath(workerFileUrl)
-  const isPrimary = !workerData || workerData.workerFilePath !== workerFilePath
-  let worker
+  const workerFilePath = fileURLToPath(workerFileUrl);
+  const isPrimary = !workerData || workerData.workerFilePath !== workerFilePath;
+  let worker;
 
   const terminate = async () => {
     if (worker) {
-      let _worker = worker
-      worker = null
+      let _worker = worker;
+      worker = null;
       const exitPromise = new Promise((resolve) => {
-        _worker.once("exit", resolve)
-      })
-      _worker.terminate()
-      await exitPromise
+        _worker.once("exit", resolve);
+      });
+      _worker.terminate();
+      await exitPromise;
     }
-  }
+  };
 
   const load = async () => {
     if (!isPrimary) {
-      throw new Error(`worker can be loaded from primary file only`)
+      throw new Error(`worker can be loaded from primary file only`);
     }
     worker = new Worker(workerFilePath, {
       ...options,
@@ -29,23 +29,23 @@ export const createReloadableWorker = (workerFileUrl, options = {}) => {
         ...options.workerData,
         workerFilePath,
       },
-    })
+    });
     worker.once("error", (error) => {
-      console.error(error)
-    })
+      console.error(error);
+    });
     worker.once("exit", () => {
-      worker = null
-    })
+      worker = null;
+    });
     await new Promise((resolve) => {
-      worker.once("online", resolve)
-    })
-    return worker
-  }
+      worker.once("online", resolve);
+    });
+    return worker;
+  };
 
   const reload = async () => {
-    await terminate()
-    await load()
-  }
+    await terminate();
+    await load();
+  };
 
   return {
     isPrimary,
@@ -53,5 +53,5 @@ export const createReloadableWorker = (workerFileUrl, options = {}) => {
     load,
     reload,
     terminate,
-  }
-}
+  };
+};

package/src/kitchen/compat/features_compatibility.js

@@ -217,4 +217,4 @@ export const featuresCompatMap = {
     samsung: "4",
     node: "0.12",
   },
-}
+};

package/src/kitchen/compat/runtime_compat.js

@@ -1,54 +1,56 @@
-import { findHighestVersion } from "@jsenv/utils/src/semantic_versioning/highest_version.js"
+import { findHighestVersion } from "@jsenv/utils/src/semantic_versioning/highest_version.js";
 
-import { featuresCompatMap } from "./features_compatibility.js"
+import { featuresCompatMap } from "./features_compatibility.js";
 
 export const RUNTIME_COMPAT = {
   featuresCompatMap,
 
   add: (originalRuntimeCompat, feature) => {
-    const featureCompat = getFeatureCompat(feature)
+    const featureCompat = getFeatureCompat(feature);
     const runtimeCompat = {
       ...originalRuntimeCompat,
-    }
+    };
     Object.keys(originalRuntimeCompat).forEach((runtimeName) => {
-      const secondVersion = featureCompat[runtimeName] // the version supported by the feature
+      const secondVersion = featureCompat[runtimeName]; // the version supported by the feature
       if (secondVersion) {
-        const firstVersion = originalRuntimeCompat[runtimeName]
+        const firstVersion = originalRuntimeCompat[runtimeName];
         runtimeCompat[runtimeName] = findHighestVersion(
           firstVersion,
           secondVersion,
-        )
+        );
       }
-    })
-    return runtimeCompat
+    });
+    return runtimeCompat;
   },
 
   isSupported: (runtimeCompat, feature) => {
-    const featureCompat = getFeatureCompat(feature)
-    const runtimeNames = Object.keys(runtimeCompat)
+    const featureCompat = getFeatureCompat(feature);
+    const runtimeNames = Object.keys(runtimeCompat);
     const runtimeWithoutCompat = runtimeNames.find((runtimeName) => {
-      const runtimeVersion = runtimeCompat[runtimeName]
-      const runtimeVersionCompatible = featureCompat[runtimeName] || "Infinity"
+      const runtimeVersion = runtimeCompat[runtimeName];
+      const runtimeVersionCompatible = featureCompat[runtimeName] || "Infinity";
       const highestVersion = findHighestVersion(
         runtimeVersion,
         runtimeVersionCompatible,
-      )
-      return highestVersion !== runtimeVersion
-    })
-    return !runtimeWithoutCompat
+      );
+      return highestVersion !== runtimeVersion;
+    });
+    return !runtimeWithoutCompat;
   },
-}
+};
 
 const getFeatureCompat = (feature) => {
   if (typeof feature === "string") {
-    const compat = featuresCompatMap[feature]
+    const compat = featuresCompatMap[feature];
     if (!compat) {
-      throw new Error(`"${feature}" feature is unknown`)
+      throw new Error(`"${feature}" feature is unknown`);
     }
-    return compat
+    return compat;
   }
   if (typeof feature !== "object") {
-    throw new TypeError(`feature must be a string or an object, got ${feature}`)
+    throw new TypeError(
+      `feature must be a string or an object, got ${feature}`,
+    );
   }
-  return feature
-}
+  return feature;
+};

package/src/kitchen/errors.js

@@ -1,5 +1,5 @@
-import { createDetailedMessage } from "@jsenv/log"
-import { stringifyUrlSite } from "@jsenv/urls"
+import { createDetailedMessage } from "@jsenv/log";
+import { stringifyUrlSite } from "@jsenv/urls";
 
 export const createResolveUrlError = ({
   pluginController,
@@ -19,29 +19,29 @@ export const createResolveUrlError = ({
         "specifier trace": reference.trace.message,
         ...detailsFromPluginController(pluginController),
       }),
-    )
-    resolveError.name = "RESOLVE_URL_ERROR"
-    resolveError.code = code
-    resolveError.reason = reason
-    resolveError.asResponse = error.asResponse
-    return resolveError
-  }
+    );
+    resolveError.name = "RESOLVE_URL_ERROR";
+    resolveError.code = code;
+    resolveError.reason = reason;
+    resolveError.asResponse = error.asResponse;
+    return resolveError;
+  };
   if (error.message === "NO_RESOLVE") {
     return createFailedToResolveUrlError({
       reason: `no plugin has handled the specifier during "resolveUrl" hook`,
-    })
+    });
   }
   if (error.code === "DIRECTORY_REFERENCE_NOT_ALLOWED") {
     error.message = createDetailedMessage(error.message, {
       "reference trace": reference.trace.message,
-    })
-    return error
+    });
+    return error;
   }
   return createFailedToResolveUrlError({
     reason: `An error occured during specifier resolution`,
     ...detailsFromValueThrown(error),
-  })
-}
+  });
+};
 
 export const createFetchUrlContentError = ({
   pluginController,
@@ -62,43 +62,43 @@ export const createFetchUrlContentError = ({
         "url reference trace": reference.trace.message,
         ...detailsFromPluginController(pluginController),
       }),
-    )
-    fetchError.name = "FETCH_URL_CONTENT_ERROR"
-    fetchError.code = code
-    fetchError.reason = reason
-    fetchError.url = urlInfo.url
+    );
+    fetchError.name = "FETCH_URL_CONTENT_ERROR";
+    fetchError.code = code;
+    fetchError.reason = reason;
+    fetchError.url = urlInfo.url;
     if (code === "PARSE_ERROR") {
-      fetchError.traceUrl = error.traceUrl
-      fetchError.traceLine = error.traceLine
-      fetchError.traceColumn = error.traceColumn
-      fetchError.traceMessage = error.traceMessage
+      fetchError.traceUrl = error.traceUrl;
+      fetchError.traceLine = error.traceLine;
+      fetchError.traceColumn = error.traceColumn;
+      fetchError.traceMessage = error.traceMessage;
     } else {
-      fetchError.traceUrl = reference.trace.url
-      fetchError.traceLine = reference.trace.line
-      fetchError.traceColumn = reference.trace.column
-      fetchError.traceMessage = reference.trace.message
+      fetchError.traceUrl = reference.trace.url;
+      fetchError.traceLine = reference.trace.line;
+      fetchError.traceColumn = reference.trace.column;
+      fetchError.traceMessage = reference.trace.message;
     }
-    fetchError.asResponse = error.asResponse
-    return fetchError
-  }
+    fetchError.asResponse = error.asResponse;
+    return fetchError;
+  };
 
   if (error.code === "EPERM") {
     return createFailedToFetchUrlContentError({
       code: "NOT_ALLOWED",
       reason: `not allowed to read entry on filesystem`,
-    })
+    });
   }
   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 createFailedToFetchUrlContentError({
       code: "NOT_FOUND",
       reason: "no entry on filesystem",
-    })
+    });
   }
   if (error.code === "PARSE_ERROR") {
     return createFailedToFetchUrlContentError({
@@ -106,13 +106,13 @@ export const createFetchUrlContentError = ({
       "reason": error.reason,
       "parse error message": error.cause.message,
       "parse error trace": error.traceMessage,
-    })
+    });
   }
   return createFailedToFetchUrlContentError({
     reason: `An error occured during "fetchUrlContent"`,
     ...detailsFromValueThrown(error),
-  })
-}
+  });
+};
 
 export const createTransformUrlContentError = ({
   pluginController,
@@ -121,7 +121,7 @@ export const createTransformUrlContentError = ({
   error,
 }) => {
   if (error.code === "DIRECTORY_REFERENCE_NOT_ALLOWED") {
-    return error
+    return error;
   }
   const createFailedToTransformError = ({
     code = error.code || "TRANSFORM_URL_CONTENT_ERROR",
@@ -139,47 +139,47 @@ export const createTransformUrlContentError = ({
           ...detailsFromPluginController(pluginController),
         },
       ),
-    )
-    transformError.name = "TRANSFORM_URL_CONTENT_ERROR"
-    transformError.code = code
-    transformError.reason = reason
-    transformError.stack = error.stack
-    transformError.url = urlInfo.url
-    transformError.traceUrl = reference.trace.url
-    transformError.traceLine = reference.trace.line
-    transformError.traceColumn = reference.trace.column
-    transformError.traceMessage = reference.trace.message
+    );
+    transformError.name = "TRANSFORM_URL_CONTENT_ERROR";
+    transformError.code = code;
+    transformError.reason = reason;
+    transformError.stack = error.stack;
+    transformError.url = urlInfo.url;
+    transformError.traceUrl = reference.trace.url;
+    transformError.traceLine = reference.trace.line;
+    transformError.traceColumn = reference.trace.column;
+    transformError.traceMessage = reference.trace.message;
     if (code === "PARSE_ERROR") {
-      transformError.reason = `parse error on ${urlInfo.type}`
-      transformError.cause = error
+      transformError.reason = `parse error on ${urlInfo.type}`;
+      transformError.cause = error;
       if (urlInfo.isInline) {
-        transformError.traceLine = reference.trace.line + error.line - 1
-        transformError.traceColumn = reference.trace.column + error.column
+        transformError.traceLine = reference.trace.line + error.line - 1;
+        transformError.traceColumn = reference.trace.column + error.column;
         transformError.traceMessage = stringifyUrlSite({
           url: urlInfo.inlineUrlSite.url,
           line: transformError.traceLine,
           column: transformError.traceColumn,
           content: urlInfo.inlineUrlSite.content,
-        })
+        });
       } else {
-        transformError.traceLine = error.line
-        transformError.traceColumn = error.column
+        transformError.traceLine = error.line;
+        transformError.traceColumn = error.column;
         transformError.traceMessage = stringifyUrlSite({
           url: urlInfo.url,
           line: error.line - 1,
           column: error.column,
           content: urlInfo.content,
-        })
+        });
       }
     }
-    transformError.asResponse = error.asResponse
-    return transformError
-  }
+    transformError.asResponse = error.asResponse;
+    return transformError;
+  };
   return createFailedToTransformError({
     reason: `"transformUrlContent" error on "${urlInfo.type}"`,
     ...detailsFromValueThrown(error),
-  })
-}
+  });
+};
 
 export const createFinalizeUrlContentError = ({
   pluginController,
@@ -194,36 +194,36 @@ export const createFinalizeUrlContentError = ({
       "url reference trace": reference.trace.message,
       ...detailsFromPluginController(pluginController),
     }),
-  )
+  );
   if (error && error instanceof Error) {
-    finalizeError.cause = error
+    finalizeError.cause = error;
   }
-  finalizeError.name = "FINALIZE_URL_CONTENT_ERROR"
-  finalizeError.reason = `"finalizeUrlContent" error on "${urlInfo.type}"`
-  finalizeError.asResponse = error.asResponse
-  return finalizeError
-}
+  finalizeError.name = "FINALIZE_URL_CONTENT_ERROR";
+  finalizeError.reason = `"finalizeUrlContent" error on "${urlInfo.type}"`;
+  finalizeError.asResponse = error.asResponse;
+  return finalizeError;
+};
 
 const detailsFromPluginController = (pluginController) => {
-  const currentPlugin = pluginController.getCurrentPlugin()
+  const currentPlugin = pluginController.getCurrentPlugin();
   if (!currentPlugin) {
-    return null
+    return null;
   }
-  return { "plugin name": `"${currentPlugin.name}"` }
-}
+  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/kitchen/fetched_content_compliance.js

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