@jsenv/core 35.0.3 → 35.0.4

package/src/kitchen/url_graph/sort_by_dependencies.js

@@ -1,28 +1,28 @@
 export const sortByDependencies = (nodes) => {
-  const visited = []
-  const sorted = []
-  const circular = []
+  const visited = [];
+  const sorted = [];
+  const circular = [];
   const visit = (url) => {
-    const isSorted = sorted.includes(url)
+    const isSorted = sorted.includes(url);
     if (isSorted) {
-      return
+      return;
     }
-    const isVisited = visited.includes(url)
+    const isVisited = visited.includes(url);
     if (isVisited) {
       if (!circular.includes(url)) {
-        circular.push(url)
+        circular.push(url);
       }
     } else {
-      visited.push(url)
+      visited.push(url);
       nodes[url].dependencies.forEach((dependencyUrl) => {
-        visit(dependencyUrl, url)
-      })
-      sorted.push(url)
+        visit(dependencyUrl, url);
+      });
+      sorted.push(url);
     }
-  }
+  };
   Object.keys(nodes).forEach((url) => {
-    visit(url)
-  })
-  sorted.circular = circular
-  return sorted
-}
+    visit(url);
+  });
+  sorted.circular = circular;
+  return sorted;
+};

package/src/kitchen/url_graph/url_graph_loader.js

@@ -1,77 +1,77 @@
 export const createUrlGraphLoader = (context) => {
-  const promises = []
-  const promiseMap = new Map()
+  const promises = [];
+  const promiseMap = new Map();
   const load = (
     urlInfo,
     dishContext,
     { ignoreRessourceHint = true, ignoreDynamicImport = false } = {},
   ) => {
-    const promiseFromData = promiseMap.get(urlInfo)
-    if (promiseFromData) return promiseFromData
+    const promiseFromData = promiseMap.get(urlInfo);
+    if (promiseFromData) return promiseFromData;
     const promise = (async () => {
       await context.cook(urlInfo, {
         cookDuringCook: load,
         ...dishContext,
-      })
+      });
       loadReferencedUrlInfos(urlInfo, {
         ignoreRessourceHint,
         ignoreDynamicImport,
-      })
-    })()
-    promises.push(promise)
-    promiseMap.set(urlInfo, promise)
-    return promise
-  }
+      });
+    })();
+    promises.push(promise);
+    promiseMap.set(urlInfo, promise);
+    return promise;
+  };
 
   const loadReferencedUrlInfos = (
     urlInfo,
     { ignoreRessourceHint, ignoreDynamicImport },
   ) => {
-    const { references } = urlInfo
+    const { references } = urlInfo;
     references.forEach((reference) => {
       // we don't cook resource hints
       // because they might refer to resource that will be modified during build
       // It also means something else have to reference that url in order to cook it
       // so that the preload is deleted by "resync_resource_hints.js" otherwise
       if (ignoreRessourceHint && reference.isResourceHint) {
-        return
+        return;
       }
       if (ignoreDynamicImport && reference.subtype === "import_dynamic") {
-        return
+        return;
       }
       // we use reference.generatedUrl to mimic what a browser would do:
       // do a fetch to the specifier as found in the file
       const referencedUrlInfo = context.urlGraph.reuseOrCreateUrlInfo(
         reference.generatedUrl,
-      )
+      );
       load(referencedUrlInfo, {
         reference,
         ignoreRessourceHint,
         ignoreDynamicImport,
-      })
-    })
-  }
+      });
+    });
+  };
 
   const getAllLoadDonePromise = async (operation) => {
     const waitAll = async () => {
       if (operation) {
-        operation.throwIfAborted()
+        operation.throwIfAborted();
       }
       if (promises.length === 0) {
-        return
+        return;
       }
-      const promisesToWait = promises.slice()
-      promises.length = 0
-      await Promise.all(promisesToWait)
-      await waitAll()
-    }
-    await waitAll()
-    promiseMap.clear()
-  }
+      const promisesToWait = promises.slice();
+      promises.length = 0;
+      await Promise.all(promisesToWait);
+      await waitAll();
+    };
+    await waitAll();
+    promiseMap.clear();
+  };
 
   return {
     load,
     loadReferencedUrlInfos,
     getAllLoadDonePromise,
-  }
-}
+  };
+};

package/src/kitchen/url_graph/url_graph_report.js

@@ -1,14 +1,14 @@
-import { ANSI, byteAsFileSize, distributePercentages } from "@jsenv/log"
+import { ANSI, byteAsFileSize, distributePercentages } from "@jsenv/log";
 
 export const createUrlGraphSummary = (
   urlGraph,
   { title = "graph summary" } = {},
 ) => {
-  const graphReport = createUrlGraphReport(urlGraph)
+  const graphReport = createUrlGraphReport(urlGraph);
   return `--- ${title} ---  
 ${createRepartitionMessage(graphReport)}
---------------------`
-}
+--------------------`;
+};
 
 const createUrlGraphReport = (urlGraph) => {
   const countGroups = {
@@ -19,7 +19,7 @@ const createUrlGraphReport = (urlGraph) => {
     json: 0,
     other: 0,
     total: 0,
-  }
+  };
   const sizeGroups = {
     sourcemaps: 0,
     html: 0,
@@ -28,70 +28,70 @@ const createUrlGraphReport = (urlGraph) => {
     json: 0,
     other: 0,
     total: 0,
-  }
+  };
   urlGraph.urlInfoMap.forEach((urlInfo) => {
     if (urlInfo.url.startsWith("data:")) {
-      return
+      return;
     }
     // ignore:
     // - inline files: they are already taken into account in the file where they appear
     // - ignored files: we don't know their content
     if (urlInfo.isInline || !urlInfo.shouldHandle) {
-      return
+      return;
     }
     // file loaded via import assertion are already inside the graph
     // their js module equivalent are ignored to avoid counting it twice
     // in the build graph the file targeted by import assertion will likely be gone
     // and only the js module remain (likely bundled)
-    const urlObject = new URL(urlInfo.url)
+    const urlObject = new URL(urlInfo.url);
     if (
       urlObject.searchParams.has("as_json_module") ||
       urlObject.searchParams.has("as_css_module") ||
       urlObject.searchParams.has("as_text_module")
     ) {
-      return
+      return;
     }
-    const urlContentSize = Buffer.byteLength(urlInfo.content)
-    const category = determineCategory(urlInfo)
+    const urlContentSize = Buffer.byteLength(urlInfo.content);
+    const category = determineCategory(urlInfo);
     if (category === "sourcemap") {
-      countGroups.sourcemaps++
-      sizeGroups.sourcemaps += urlContentSize
-      return
+      countGroups.sourcemaps++;
+      sizeGroups.sourcemaps += urlContentSize;
+      return;
     }
-    countGroups.total++
-    sizeGroups.total += urlContentSize
+    countGroups.total++;
+    sizeGroups.total += urlContentSize;
     if (category === "html") {
-      countGroups.html++
-      sizeGroups.html += urlContentSize
-      return
+      countGroups.html++;
+      sizeGroups.html += urlContentSize;
+      return;
     }
     if (category === "css") {
-      countGroups.css++
-      sizeGroups.css += urlContentSize
-      return
+      countGroups.css++;
+      sizeGroups.css += urlContentSize;
+      return;
     }
     if (category === "js") {
-      countGroups.js++
-      sizeGroups.js += urlContentSize
-      return
+      countGroups.js++;
+      sizeGroups.js += urlContentSize;
+      return;
     }
     if (category === "json") {
-      countGroups.json++
-      sizeGroups.json += urlContentSize
-      return
+      countGroups.json++;
+      sizeGroups.json += urlContentSize;
+      return;
     }
-    countGroups.other++
-    sizeGroups.other += urlContentSize
-    return
-  })
+    countGroups.other++;
+    sizeGroups.other += urlContentSize;
+    return;
+  });
 
-  const sizesToDistribute = {}
+  const sizesToDistribute = {};
   Object.keys(sizeGroups).forEach((groupName) => {
     if (groupName !== "sourcemaps" && groupName !== "total") {
-      sizesToDistribute[groupName] = sizeGroups[groupName]
+      sizesToDistribute[groupName] = sizeGroups[groupName];
     }
-  })
-  const percentageGroups = distributePercentages(sizesToDistribute)
+  });
+  const percentageGroups = distributePercentages(sizesToDistribute);
 
   return {
     // sourcemaps are special, there size are ignored
@@ -132,27 +132,27 @@ const createUrlGraphReport = (urlGraph) => {
       size: sizeGroups.total,
       percentage: 100,
     },
-  }
-}
+  };
+};
 
 const determineCategory = (urlInfo) => {
   if (urlInfo.type === "sourcemap") {
-    return "sourcemap"
+    return "sourcemap";
   }
   if (urlInfo.type === "html") {
-    return "html"
+    return "html";
   }
   if (urlInfo.type === "css") {
-    return "css"
+    return "css";
   }
   if (urlInfo.type === "js_module" || urlInfo.type === "js_classic") {
-    return "js"
+    return "js";
   }
   if (urlInfo.type === "json") {
-    return "json"
+    return "json";
   }
-  return "other"
-}
+  return "other";
+};
 
 const createRepartitionMessage = ({ html, css, js, json, other, total }) => {
   const addPart = (name, { count, size, percentage }) => {
@@ -160,10 +160,10 @@ const createRepartitionMessage = ({ html, css, js, json, other, total }) => {
       `${ANSI.color(`${name}:`, ANSI.GREY)} ${count} (${byteAsFileSize(
         size,
       )} / ${percentage} %)`,
-    )
-  }
+    );
+  };
 
-  const parts = []
+  const parts = [];
   // if (sourcemaps.count) {
   //   parts.push(
   //     `${ANSI.color(`sourcemaps:`, ANSI.GREY)} ${
@@ -172,21 +172,21 @@ const createRepartitionMessage = ({ html, css, js, json, other, total }) => {
   //   )
   // }
   if (html.count) {
-    addPart("html ", html)
+    addPart("html ", html);
   }
   if (css.count) {
-    addPart("css  ", css)
+    addPart("css  ", css);
   }
   if (js.count) {
-    addPart("js   ", js)
+    addPart("js   ", js);
   }
   if (json.count) {
-    addPart("json ", json)
+    addPart("json ", json);
   }
   if (other.count) {
-    addPart("other", other)
+    addPart("other", other);
   }
-  addPart("total", total)
+  addPart("total", total);
   return `- ${parts.join(`
-- `)}`
-}
+- `)}`;
+};

package/src/kitchen/url_graph/url_info_transformations.js

@@ -1,12 +1,12 @@
-import { pathToFileURL } from "node:url"
-import { bufferToEtag } from "@jsenv/filesystem"
-import { urlToRelativeUrl, isFileSystemPath } from "@jsenv/urls"
+import { pathToFileURL } from "node:url";
+import { bufferToEtag } from "@jsenv/filesystem";
+import { urlToRelativeUrl, isFileSystemPath } from "@jsenv/urls";
 import {
   composeTwoSourcemaps,
   SOURCEMAP,
   generateSourcemapFileUrl,
   generateSourcemapDataUrl,
-} from "@jsenv/sourcemap"
+} from "@jsenv/sourcemap";
 
 export const createUrlInfoTransformer = ({
   logger,
@@ -19,26 +19,26 @@ export const createUrlInfoTransformer = ({
   foundSourcemap,
 }) => {
   if (sourcemapsSourcesProtocol === undefined) {
-    sourcemapsSourcesProtocol = "file:///"
+    sourcemapsSourcesProtocol = "file:///";
   }
   if (sourcemapsSourcesContent === undefined) {
-    sourcemapsSourcesContent = true
+    sourcemapsSourcesContent = true;
   }
 
   const sourcemapsEnabled =
     sourcemaps === "inline" ||
     sourcemaps === "file" ||
-    sourcemaps === "programmatic"
+    sourcemaps === "programmatic";
 
   const normalizeSourcemap = (urlInfo, sourcemap) => {
-    let { sources } = sourcemap
+    let { sources } = sourcemap;
     if (sources) {
       sources = sources.map((source) => {
         if (source && isFileSystemPath(source)) {
-          return String(pathToFileURL(source))
+          return String(pathToFileURL(source));
         }
-        return source
-      })
+        return source;
+      });
     }
     const wantSourcesContent =
       // for inline content (<script> insdide html)
@@ -47,36 +47,36 @@ export const createUrlInfoTransformer = ({
       sourcemapsSourcesContent ||
       urlInfo.isInline ||
       (sources &&
-        sources.some((source) => !source || !source.startsWith("file:")))
+        sources.some((source) => !source || !source.startsWith("file:")));
     if (sources && sources.length > 1) {
       sourcemap.sources = sources.map(
         (source) => new URL(source, urlInfo.originalUrl).href,
-      )
+      );
       if (!wantSourcesContent) {
-        sourcemap.sourcesContent = undefined
+        sourcemap.sourcesContent = undefined;
       }
-      return sourcemap
+      return sourcemap;
     }
-    sourcemap.sources = [urlInfo.originalUrl]
-    sourcemap.sourcesContent = [urlInfo.originalContent]
+    sourcemap.sources = [urlInfo.originalUrl];
+    sourcemap.sourcesContent = [urlInfo.originalContent];
     if (!wantSourcesContent) {
-      sourcemap.sourcesContent = undefined
+      sourcemap.sourcesContent = undefined;
     }
-    return sourcemap
-  }
+    return sourcemap;
+  };
 
   const initTransformations = async (urlInfo, context) => {
     urlInfo.originalContentEtag =
       urlInfo.originalContentEtag ||
-      bufferToEtag(Buffer.from(urlInfo.originalContent))
+      bufferToEtag(Buffer.from(urlInfo.originalContent));
     if (!sourcemapsEnabled) {
-      return
+      return;
     }
     if (!SOURCEMAP.enabledOnContentType(urlInfo.contentType)) {
-      return
+      return;
     }
     if (urlInfo.generatedUrl.startsWith("data:")) {
-      return
+      return;
     }
     // sourcemap is a special kind of reference:
     // It's a reference to a content generated dynamically the content itself.
@@ -86,12 +86,12 @@ export const createUrlInfoTransformer = ({
     // when jsenv is done cooking the file
     //   during build it's urlInfo.url to be inside the build
     //   but otherwise it's generatedUrl to be inside .jsenv/ directory
-    const generatedUrlObject = new URL(urlInfo.generatedUrl)
-    generatedUrlObject.searchParams.delete("js_module_fallback")
-    generatedUrlObject.searchParams.delete("as_js_module")
-    generatedUrlObject.searchParams.delete("as_js_classic")
-    const urlForSourcemap = generatedUrlObject.href
-    urlInfo.sourcemapGeneratedUrl = generateSourcemapFileUrl(urlForSourcemap)
+    const generatedUrlObject = new URL(urlInfo.generatedUrl);
+    generatedUrlObject.searchParams.delete("js_module_fallback");
+    generatedUrlObject.searchParams.delete("as_js_module");
+    generatedUrlObject.searchParams.delete("as_js_classic");
+    const urlForSourcemap = generatedUrlObject.href;
+    urlInfo.sourcemapGeneratedUrl = generateSourcemapFileUrl(urlForSourcemap);
 
     // already loaded during "load" hook (happens during build)
     if (urlInfo.sourcemap) {
@@ -100,71 +100,71 @@ export const createUrlInfoTransformer = ({
           urlInfo,
           specifier: urlInfo.sourcemapGeneratedUrl,
         },
-      )
-      sourcemapUrlInfo.isInline = sourcemaps === "inline"
-      urlInfo.sourcemapReference = sourcemapReference
-      urlInfo.sourcemap = normalizeSourcemap(urlInfo, urlInfo.sourcemap)
-      return
+      );
+      sourcemapUrlInfo.isInline = sourcemaps === "inline";
+      urlInfo.sourcemapReference = sourcemapReference;
+      urlInfo.sourcemap = normalizeSourcemap(urlInfo, urlInfo.sourcemap);
+      return;
     }
 
     // check for existing sourcemap for this content
     const sourcemapFound = SOURCEMAP.readComment({
       contentType: urlInfo.contentType,
       content: urlInfo.content,
-    })
+    });
     if (sourcemapFound) {
-      const { type, line, column, specifier } = sourcemapFound
+      const { type, line, column, specifier } = sourcemapFound;
       const [sourcemapReference, sourcemapUrlInfo] = foundSourcemap({
         urlInfo,
         type,
         specifier,
         specifierLine: line,
         specifierColumn: column,
-      })
+      });
       try {
-        await context.cook(sourcemapUrlInfo, { reference: sourcemapReference })
-        const sourcemapRaw = JSON.parse(sourcemapUrlInfo.content)
-        const sourcemap = normalizeSourcemap(urlInfo, sourcemapRaw)
-        urlInfo.sourcemap = sourcemap
+        await context.cook(sourcemapUrlInfo, { reference: sourcemapReference });
+        const sourcemapRaw = JSON.parse(sourcemapUrlInfo.content);
+        const sourcemap = normalizeSourcemap(urlInfo, sourcemapRaw);
+        urlInfo.sourcemap = sourcemap;
       } catch (e) {
-        logger.error(`Error while handling existing sourcemap: ${e.message}`)
-        return
+        logger.error(`Error while handling existing sourcemap: ${e.message}`);
+        return;
       }
     } else {
       const [, sourcemapUrlInfo] = injectSourcemapPlaceholder({
         urlInfo,
         specifier: urlInfo.sourcemapGeneratedUrl,
-      })
-      sourcemapUrlInfo.isInline = sourcemaps === "inline"
+      });
+      sourcemapUrlInfo.isInline = sourcemaps === "inline";
     }
-  }
+  };
 
   const applyIntermediateTransformations = (urlInfo, transformations) => {
     if (!transformations) {
-      return
+      return;
     }
     const { type, contentType, content, sourcemap, sourcemapIsWrong } =
-      transformations
+      transformations;
     if (type) {
-      urlInfo.type = type
+      urlInfo.type = type;
     }
     if (contentType) {
-      urlInfo.contentType = contentType
+      urlInfo.contentType = contentType;
     }
     if (content) {
-      urlInfo.content = content
+      urlInfo.content = content;
     }
     if (sourcemapsEnabled && sourcemap) {
-      const sourcemapNormalized = normalizeSourcemap(urlInfo, sourcemap)
+      const sourcemapNormalized = normalizeSourcemap(urlInfo, sourcemap);
       const finalSourcemap = composeTwoSourcemaps(
         urlInfo.sourcemap,
         sourcemapNormalized,
-      )
+      );
       const finalSourcemapNormalized = normalizeSourcemap(
         urlInfo,
         finalSourcemap,
-      )
-      urlInfo.sourcemap = finalSourcemapNormalized
+      );
+      urlInfo.sourcemap = finalSourcemapNormalized;
       // A plugin is allowed to modify url content
       // without returning a sourcemap
       // This is the case for preact and react plugins.
@@ -174,13 +174,13 @@ export const createUrlInfoTransformer = ({
       // is a nightmare no-one could solve in years so
       // jsenv won't emit a warning and use the following strategy:
       // "no sourcemap is better than wrong sourcemap"
-      urlInfo.sourcemapIsWrong = urlInfo.sourcemapIsWrong || sourcemapIsWrong
+      urlInfo.sourcemapIsWrong = urlInfo.sourcemapIsWrong || sourcemapIsWrong;
     }
-  }
+  };
 
   const applyFinalTransformations = (urlInfo, transformations) => {
     if (transformations) {
-      applyIntermediateTransformations(urlInfo, transformations)
+      applyIntermediateTransformations(urlInfo, transformations);
     }
     if (urlInfo.sourcemapReference) {
       if (
@@ -193,31 +193,31 @@ export const createUrlInfoTransformer = ({
         // - to inject versioning into the entry point content
         // in this scenarion we don't want to call injectSourcemap
         // just update the content and the
-        const sourcemapReference = urlInfo.sourcemapReference
-        const sourcemapUrlInfo = urlGraph.getUrlInfo(sourcemapReference.url)
-        sourcemapUrlInfo.contentType = "application/json"
-        const sourcemap = urlInfo.sourcemap
+        const sourcemapReference = urlInfo.sourcemapReference;
+        const sourcemapUrlInfo = urlGraph.getUrlInfo(sourcemapReference.url);
+        sourcemapUrlInfo.contentType = "application/json";
+        const sourcemap = urlInfo.sourcemap;
         if (sourcemapsSourcesRelative) {
           sourcemap.sources = sourcemap.sources.map((source) => {
-            const sourceRelative = urlToRelativeUrl(source, urlInfo.url)
-            return sourceRelative || "."
-          })
+            const sourceRelative = urlToRelativeUrl(source, urlInfo.url);
+            return sourceRelative || ".";
+          });
         }
         if (sourcemapsSourcesProtocol !== "file:///") {
           sourcemap.sources = sourcemap.sources.map((source) => {
             if (source.startsWith("file:///")) {
               return `${sourcemapsSourcesProtocol}${source.slice(
                 "file:///".length,
-              )}`
+              )}`;
             }
-            return source
-          })
+            return source;
+          });
         }
-        sourcemapUrlInfo.content = JSON.stringify(sourcemap, null, "  ")
+        sourcemapUrlInfo.content = JSON.stringify(sourcemap, null, "  ");
         if (!urlInfo.sourcemapIsWrong) {
           if (sourcemaps === "inline") {
             sourcemapReference.generatedSpecifier =
-              generateSourcemapDataUrl(sourcemap)
+              generateSourcemapDataUrl(sourcemap);
           }
           if (sourcemaps === "file" || sourcemaps === "inline") {
             urlInfo.content = SOURCEMAP.writeComment({
@@ -227,24 +227,24 @@ export const createUrlInfoTransformer = ({
                 sourcemaps === "file" && sourcemapsSourcesRelative
                   ? urlToRelativeUrl(sourcemapReference.url, urlInfo.url)
                   : sourcemapReference.generatedSpecifier,
-            })
+            });
           }
         }
       } else {
         // in the end we don't use the sourcemap placeholder
-        urlGraph.deleteUrlInfo(urlInfo.sourcemapReference.url)
+        urlGraph.deleteUrlInfo(urlInfo.sourcemapReference.url);
       }
     }
 
     urlInfo.contentEtag =
       urlInfo.content === urlInfo.originalContent
         ? urlInfo.originalContentEtag
-        : bufferToEtag(Buffer.from(urlInfo.content))
-  }
+        : bufferToEtag(Buffer.from(urlInfo.content));
+  };
 
   return {
     initTransformations,
     applyIntermediateTransformations,
     applyFinalTransformations,
-  }
-}
+  };
+};