@jsenv/core 40.0.10 → 40.1.1

package/src/build/build_content_report.js

@@ -0,0 +1,377 @@
+import {
+  ANSI,
+  distributePercentages,
+  humanizeDuration,
+  humanizeFileSize,
+  humanizeMemory,
+  renderBigSection,
+  renderDetails,
+} from "@jsenv/humanize";
+import { renderTable } from "@jsenv/terminal-table";
+
+export const createBuildContentSummary = (
+  buildFileContents,
+  { indent, title } = {},
+) => {
+  const buildContentReport = createBuildContentReport(buildFileContents);
+  return `--- ${title} ---  
+${createRepartitionMessage(buildContentReport, { indent })}
+--------------------`;
+};
+
+const humanizeProcessCpuUsage = (ratio) => {
+  const percentageAsNumber = ratio * 100;
+  const percentageAsNumberRounded = Math.round(percentageAsNumber);
+  const percentage = `${percentageAsNumberRounded}%`;
+  return percentage;
+};
+const humanizeProcessMemoryUsage = (value) => {
+  return humanizeMemory(value, { short: true, decimals: 0 });
+};
+export const renderBuildDoneLog = ({
+  duration,
+  buildFileContents,
+  processCpuUsage,
+  processMemoryUsage,
+}) => {
+  const buildContentReport = createBuildContentReport(buildFileContents);
+
+  let title = "";
+  let content = "";
+  const lines = [];
+
+  const filesWrittenCount = buildContentReport.total.count;
+  if (filesWrittenCount === 1) {
+    title = `1 file written`;
+  } else {
+    title = `${filesWrittenCount} files written`;
+    const keys = Object.keys(buildContentReport);
+    const rows = [];
+    let y = 0;
+    let highestPercentage = 0;
+    let highestPercentageY = 0;
+    for (const key of keys) {
+      if (key === "sourcemaps") {
+        continue;
+      }
+      if (key === "total") {
+        continue;
+      }
+      const { count, size, percentage } = buildContentReport[key];
+      if (count === 0) {
+        continue;
+      }
+      const row = [
+        {
+          value: key,
+          borderTop: {},
+          borderBottom: {},
+        },
+        {
+          value: count,
+          borderTop: {},
+          borderBottom: {},
+        },
+        {
+          value: size,
+          format: "size",
+          borderTop: {},
+          borderBottom: {},
+        },
+        {
+          value: percentage,
+          format: "percentage",
+          unit: "%",
+          borderTop: {},
+          borderBottom: {},
+        },
+      ];
+      if (percentage > highestPercentage) {
+        highestPercentage = percentage;
+        highestPercentageY = y;
+      }
+      rows.push(row);
+      y++;
+    }
+    if (rows.length > 1) {
+      const rowWithHighestPercentage = rows[highestPercentageY];
+      for (const cell of rowWithHighestPercentage) {
+        cell.bold = true;
+      }
+      const table = renderTable(rows, {
+        borderCollapse: true,
+        ansi: true,
+      });
+      content += table;
+      content += "\n";
+    }
+  }
+
+  let sizeLine = `total size: `;
+  sizeLine += humanizeFileSize(buildContentReport.total.size);
+  lines.push(sizeLine);
+
+  let durationLine = `duration: `;
+  durationLine += humanizeDuration(duration, { short: true });
+  lines.push(durationLine);
+
+  // cpu usage
+  let cpuUsageLine = "cpu: ";
+  cpuUsageLine += `${humanizeProcessCpuUsage(processCpuUsage.end)}`;
+  cpuUsageLine += renderDetails({
+    med: humanizeProcessCpuUsage(processCpuUsage.median),
+    min: humanizeProcessCpuUsage(processCpuUsage.min),
+    max: humanizeProcessCpuUsage(processCpuUsage.max),
+  });
+  lines.push(cpuUsageLine);
+
+  // memory usage
+  let memoryUsageLine = "memory: ";
+  memoryUsageLine += `${humanizeProcessMemoryUsage(processMemoryUsage.end)}`;
+  memoryUsageLine += renderDetails({
+    med: humanizeProcessMemoryUsage(processMemoryUsage.median),
+    min: humanizeProcessMemoryUsage(processMemoryUsage.min),
+    max: humanizeProcessMemoryUsage(processMemoryUsage.max),
+  });
+  lines.push(memoryUsageLine);
+
+  content += lines.join("\n");
+  return `${renderBigSection({
+    title,
+    content,
+  })}`;
+};
+
+export const createBuildContentOneLineSummary = (
+  buildFileContents,
+  { indent },
+) => {
+  const buildContentReport = createBuildContentReport(buildFileContents);
+  const shortSummary = createBuildShortSummary(buildContentReport);
+  return `${indent}${shortSummary}`;
+};
+
+const createBuildContentReport = (buildFileContents) => {
+  const countGroups = {
+    sourcemaps: 0,
+    html: 0,
+    css: 0,
+    js: 0,
+    json: 0,
+    other: 0,
+    total: 0,
+  };
+  const sizeGroups = {
+    sourcemaps: 0,
+    html: 0,
+    css: 0,
+    js: 0,
+    json: 0,
+    other: 0,
+    total: 0,
+  };
+
+  for (const buildRelativeUrl of Object.keys(buildFileContents)) {
+    const content = buildFileContents[buildRelativeUrl];
+    const contentSize = Buffer.byteLength(content);
+    const category = determineCategory(buildRelativeUrl);
+    if (category === "sourcemap") {
+      countGroups.sourcemaps++;
+      sizeGroups.sourcemaps += contentSize;
+      continue;
+    }
+    countGroups.total++;
+    sizeGroups.total += contentSize;
+    if (category === "html") {
+      countGroups.html++;
+      sizeGroups.html += contentSize;
+      continue;
+    }
+    if (category === "css") {
+      countGroups.css++;
+      sizeGroups.css += contentSize;
+      continue;
+    }
+    if (category === "js") {
+      countGroups.js++;
+      sizeGroups.js += contentSize;
+      continue;
+    }
+    if (category === "json") {
+      countGroups.json++;
+      sizeGroups.json += contentSize;
+      continue;
+    }
+    countGroups.other++;
+    sizeGroups.other += contentSize;
+    continue;
+  }
+
+  const sizesToDistribute = {};
+  for (const groupName of Object.keys(sizeGroups)) {
+    if (groupName !== "sourcemaps" && groupName !== "total") {
+      sizesToDistribute[groupName] = sizeGroups[groupName];
+    }
+  }
+  const percentageGroups = distributePercentages(sizesToDistribute);
+
+  return {
+    // sourcemaps are special, there size are ignored
+    // so there is no "percentage" associated
+    sourcemaps: {
+      count: countGroups.sourcemaps,
+      size: sizeGroups.sourcemaps,
+      percentage: undefined,
+    },
+
+    html: {
+      count: countGroups.html,
+      size: sizeGroups.html,
+      percentage: percentageGroups.html,
+    },
+    css: {
+      count: countGroups.css,
+      size: sizeGroups.css,
+      percentage: percentageGroups.css,
+    },
+    js: {
+      count: countGroups.js,
+      size: sizeGroups.js,
+      percentage: percentageGroups.js,
+    },
+    json: {
+      count: countGroups.json,
+      size: sizeGroups.json,
+      percentage: percentageGroups.json,
+    },
+    other: {
+      count: countGroups.other,
+      size: sizeGroups.other,
+      percentage: percentageGroups.other,
+    },
+    total: {
+      count: countGroups.total,
+      size: sizeGroups.total,
+      percentage: 100,
+    },
+  };
+};
+
+const determineCategory = (buildRelativeUrl) => {
+  if (buildRelativeUrl.endsWith(".map")) {
+    return "sourcemap";
+  }
+  if (buildRelativeUrl.endsWith(".html")) {
+    return "html";
+  }
+  if (buildRelativeUrl.endsWith(".css")) {
+    return "css";
+  }
+  if (
+    buildRelativeUrl.endsWith(".js") ||
+    buildRelativeUrl.endsWith(".mjs") ||
+    buildRelativeUrl.endsWith(".cjs")
+  ) {
+    return "js";
+  }
+  if (buildRelativeUrl.endsWith(".json")) {
+    return "json";
+  }
+  return "other";
+};
+
+const createBuildShortSummary = ({ html, css, js, json, other, total }) => {
+  let shortSummary = "";
+
+  const tag =
+    html.count === total.count
+      ? "html"
+      : css.count === total.count
+        ? "css"
+        : js.count === total.count
+          ? "js"
+          : json.count === total.count
+            ? "json"
+            : "";
+
+  if (total.count === 1) {
+    if (tag) {
+      shortSummary += `1 ${tag} file`;
+    } else {
+      shortSummary += "1 file";
+    }
+  } else if (tag) {
+    shortSummary += `${total.count} ${tag} files`;
+  } else {
+    shortSummary += `${total.count} files`;
+  }
+
+  shortSummary += " (";
+  shortSummary += humanizeFileSize(total.size);
+  const repart = [];
+  if (html.count) {
+    repart.push(`html: ${html.percentage}%`);
+  }
+  if (css.count) {
+    repart.push(`css: ${css.percentage}%`);
+  }
+  if (js.count) {
+    repart.push(`js: ${js.percentage}%`);
+  }
+  if (json.count) {
+    repart.push(`json: ${js.percentage}%`);
+  }
+  if (other.count) {
+    repart.push(`other: ${js.percentage}%`);
+  }
+  if (repart.length > 1) {
+    shortSummary += ` / ${repart.join(" ")}`;
+  }
+  shortSummary += ")";
+  return shortSummary;
+};
+
+const createRepartitionMessage = (
+  { html, css, js, json, other, total },
+  { indent },
+) => {
+  const addPart = (name, { count, size, percentage }) => {
+    let part = "";
+    part += ANSI.color(`${name}:`, ANSI.GREY);
+    part += " ";
+    part += count;
+    part += " ";
+    part += ANSI.color(
+      `(${humanizeFileSize(size)} / ${percentage} %)`,
+      ANSI.GREY,
+    );
+    parts.push(part);
+  };
+
+  const parts = [];
+  // if (sourcemaps.count) {
+  //   parts.push(
+  //     `${ANSI.color(`sourcemaps:`, ANSI.GREY)} ${
+  //       sourcemaps.count
+  //     } (${humanizeFileSize(sourcemaps.size)})`,
+  //   )
+  // }
+  if (html.count) {
+    addPart("html ", html);
+  }
+  if (css.count) {
+    addPart("css  ", css);
+  }
+  if (js.count) {
+    addPart("js   ", js);
+  }
+  if (json.count) {
+    addPart("json ", json);
+  }
+  if (other.count) {
+    addPart("other", other);
+  }
+  addPart("total", total);
+  return `${indent}${ANSI.color("-", ANSI.GREY)} ${parts.join(`
+${indent}${ANSI.color("-", ANSI.GREY)} `)}`;
+};

package/src/build/build_params.js

@@ -13,8 +13,5 @@ export const defaultRuntimeCompat = {
 };
 export const logsDefault = {
   level: "info",
-  disabled: false,
-  animation: true,
+  animated: true,
 };
-export const getDefaultBase = (runtimeCompat) =>
-  runtimeCompat.node ? "./" : "/";

package/src/build/build_specifier_manager.js

@@ -26,7 +26,6 @@ import { escapeRegexpSpecialChars } from "@jsenv/utils/src/string/escape_regexp_
 import { prependContent } from "../kitchen/prepend_content.js";
 import { GRAPH_VISITOR } from "../kitchen/url_graph/url_graph_visitor.js";
 import { isWebWorkerUrlInfo } from "../kitchen/web_workers.js";
-import { createBuildUrlsGenerator } from "./build_urls_generator.js";
 import {
   injectGlobalMappings,
   injectImportmapMappings,
@@ -38,8 +37,9 @@ export const createBuildSpecifierManager = ({
   logger,
   sourceDirectoryUrl,
   buildDirectoryUrl,
-  base,
   assetsDirectory,
+  buildUrlsGenerator,
+  base,
   length = 8,
 
   versioning,
@@ -47,12 +47,6 @@ export const createBuildSpecifierManager = ({
   versionLength,
   canUseImportmap,
 }) => {
-  const buildUrlsGenerator = createBuildUrlsGenerator({
-    logger,
-    sourceDirectoryUrl,
-    buildDirectoryUrl,
-    assetsDirectory,
-  });
   const placeholderAPI = createPlaceholderAPI({
     length,
   });
@@ -82,6 +76,7 @@ export const createBuildSpecifierManager = ({
       buildUrl = buildUrlsGenerator.generate(url, {
         urlInfo,
         ownerUrlInfo: reference.ownerUrlInfo,
+        assetsDirectory,
       });
     }
 
@@ -156,6 +151,12 @@ export const createBuildSpecifierManager = ({
     resolveReference: (reference) => {
       const { ownerUrlInfo } = reference;
       if (ownerUrlInfo.remapReference && !reference.isInline) {
+        if (reference.specifier.startsWith("file:")) {
+          const rawUrlInfo = rawKitchen.graph.getUrlInfo(reference.specifier);
+          if (rawUrlInfo && rawUrlInfo.type === "entry_build") {
+            return reference.specifier; // we want to ignore it
+          }
+        }
         const newSpecifier = ownerUrlInfo.remapReference(reference);
         reference.specifier = newSpecifier;
       }
@@ -188,6 +189,14 @@ export const createBuildSpecifierManager = ({
       return url;
     },
     redirectReference: (reference) => {
+      // don't think this is needed because we'll find the rawUrlInfo
+      // which contains the filenameHint
+      // const otherEntryBuildInfo = getOtherEntryBuildInfo(reference.url);
+      // if (otherEntryBuildInfo) {
+      //   reference.filenameHint = otherEntryBuildInfo.entryUrlInfo.filenameHint;
+      //   return null;
+      // }
+
       let referenceBeforeInlining = reference;
       if (
         referenceBeforeInlining.isInline &&
@@ -273,7 +282,6 @@ export const createBuildSpecifierManager = ({
         firstReference = firstReference.prev;
       }
       const rawUrl = firstReference.rawUrl || firstReference.url;
-      const rawUrlInfo = rawKitchen.graph.getUrlInfo(rawUrl);
       const bundleInfo = bundleInfoMap.get(rawUrl);
       if (bundleInfo) {
         finalUrlInfo.remapReference = bundleInfo.remapReference;
@@ -290,7 +298,21 @@ export const createBuildSpecifierManager = ({
           data: bundleInfo.data,
         };
       }
+      const rawUrlInfo = rawKitchen.graph.getUrlInfo(rawUrl);
       if (rawUrlInfo) {
+        if (rawUrlInfo.type === "entry_build") {
+          const otherEntryBuildInfo = rawUrlInfo.otherEntryBuildInfo;
+          if (
+            // we need to wait ONLY if we are versioning
+            // and only IF the reference can't be remapped globally or by importmap
+            // otherwise we can reference the file right away
+            versioning &&
+            getReferenceVersioningInfo(firstReference).type === "inline"
+          ) {
+            await otherEntryBuildInfo.promise;
+          }
+          finalUrlInfo.otherEntryBuildInfo = otherEntryBuildInfo;
+        }
         return rawUrlInfo;
       }
       // reference injected during "shape":
@@ -521,6 +543,15 @@ export const createBuildSpecifierManager = ({
           if (urlInfo.url.startsWith("ignore:")) {
             return;
           }
+          if (urlInfo.type === "entry_build") {
+            const otherEntryBuildInfo = urlInfo.otherEntryBuildInfo;
+            const entryUrlInfoVersion =
+              otherEntryBuildInfo.buildFileVersions[
+                otherEntryBuildInfo.buildRelativeUrl
+              ];
+            contentOnlyVersionMap.set(urlInfo, entryUrlInfoVersion);
+            return;
+          }
           let content = urlInfo.content;
           if (urlInfo.type === "html") {
             content = stringifyHtmlAst(
@@ -560,6 +591,9 @@ export const createBuildSpecifierManager = ({
       const getSetOfUrlInfoInfluencingVersion = (urlInfo) => {
         const placeholderInfluencingVersionSet = new Set();
         const visitContainedPlaceholders = (urlInfo) => {
+          if (urlInfo.type === "entry_build") {
+            return;
+          }
           const referencedContentVersion = contentOnlyVersionMap.get(urlInfo);
           if (!referencedContentVersion) {
             // ignored while traversing graph (not used anymore, inline, ...)
@@ -604,20 +638,24 @@ export const createBuildSpecifierManager = ({
         contentOnlyUrlInfo,
         contentOnlyVersion,
       ] of contentOnlyVersionMap) {
-        const setOfUrlInfoInfluencingVersion =
-          getSetOfUrlInfoInfluencingVersion(contentOnlyUrlInfo);
         const versionPartSet = new Set();
-        versionPartSet.add(contentOnlyVersion);
-        for (const urlInfoInfluencingVersion of setOfUrlInfoInfluencingVersion) {
-          const otherUrlInfoContentVersion = contentOnlyVersionMap.get(
-            urlInfoInfluencingVersion,
-          );
-          if (!otherUrlInfoContentVersion) {
-            throw new Error(
-              `cannot find content version for ${urlInfoInfluencingVersion.url} (used by ${contentOnlyUrlInfo.url})`,
+        if (contentOnlyUrlInfo.type === "entry_build") {
+          versionPartSet.add(contentOnlyVersion);
+        } else {
+          const setOfUrlInfoInfluencingVersion =
+            getSetOfUrlInfoInfluencingVersion(contentOnlyUrlInfo);
+          versionPartSet.add(contentOnlyVersion);
+          for (const urlInfoInfluencingVersion of setOfUrlInfoInfluencingVersion) {
+            const otherUrlInfoContentVersion = contentOnlyVersionMap.get(
+              urlInfoInfluencingVersion,
             );
+            if (!otherUrlInfoContentVersion) {
+              throw new Error(
+                `cannot find content version for ${urlInfoInfluencingVersion.url} (used by ${contentOnlyUrlInfo.url})`,
+              );
+            }
+            versionPartSet.add(otherUrlInfoContentVersion);
           }
-          versionPartSet.add(otherUrlInfoContentVersion);
         }
         const version = generateVersion(versionPartSet, versionLength);
         versionMap.set(contentOnlyUrlInfo, version);
@@ -1019,6 +1057,7 @@ export const createBuildSpecifierManager = ({
       const buildManifest = {};
       const buildContents = {};
       const buildInlineRelativeUrlSet = new Set();
+      const buildFileVersions = {};
       GRAPH_VISITOR.forEachUrlInfoStronglyReferenced(
         finalKitchen.graph.rootUrlInfo,
         (urlInfo) => {
@@ -1032,6 +1071,9 @@ export const createBuildSpecifierManager = ({
           ) {
             return;
           }
+          if (urlInfo.type === "entry_build") {
+            return;
+          }
           const buildSpecifier = buildUrlToBuildSpecifierMap.get(buildUrl);
           const buildSpecifierVersioned = versioning
             ? buildSpecifierToBuildSpecifierVersionedMap.get(buildSpecifier)
@@ -1040,6 +1082,8 @@ export const createBuildSpecifierManager = ({
             buildUrl,
             buildDirectoryUrl,
           );
+          buildFileVersions[buildRelativeUrl] = versionMap.get(urlInfo);
+
           let contentKey;
           // if to guard for html where versioned build specifier is not generated
           if (buildSpecifierVersioned) {
@@ -1078,7 +1122,12 @@ export const createBuildSpecifierManager = ({
           }
         });
 
-      return { buildFileContents, buildInlineContents, buildManifest };
+      return {
+        buildFileContents,
+        buildInlineContents,
+        buildManifest,
+        buildFileVersions,
+      };
     },
   };
 };

package/src/build/build_urls_generator.js

@@ -1,13 +1,11 @@
-import { ANSI } from "@jsenv/humanize";
+// import { ANSI } from "@jsenv/humanize";
 import { urlIsInsideOf, urlToFilename, urlToRelativeUrl } from "@jsenv/urls";
 
 export const createBuildUrlsGenerator = ({
-  logger,
+  // logger,
   sourceDirectoryUrl,
   buildDirectoryUrl,
-  assetsDirectory,
 }) => {
-  const cache = {};
   const getUrlName = (url, urlInfo) => {
     if (!urlInfo) {
       return urlToFilename(url);
@@ -18,25 +16,30 @@ export const createBuildUrlsGenerator = ({
     return urlToFilename(url);
   };
 
-  const buildUrlCache = new Map();
-
+  const buildUrlMap = new Map();
   const associateBuildUrl = (url, buildUrl) => {
-    buildUrlCache.set(url, buildUrl);
-    logger.debug(`associate a build url
-${ANSI.color(url, ANSI.GREY)} ->
-${ANSI.color(buildUrl, ANSI.MAGENTA)}
-      `);
+    buildUrlMap.set(url, buildUrl);
+    //     logger.debug(`associate a build url
+    // ${ANSI.color(url, ANSI.GREY)} ->
+    // ${ANSI.color(buildUrl, ANSI.MAGENTA)}
+    // `);
   };
 
-  const generate = (url, { urlInfo, ownerUrlInfo }) => {
-    const buildUrlFromCache = buildUrlCache.get(url);
-    if (buildUrlFromCache) {
-      return buildUrlFromCache;
+  const nameSetPerDirectoryMap = new Map();
+  const generate = (url, { urlInfo, ownerUrlInfo, assetsDirectory }) => {
+    const buildUrlFromMap = buildUrlMap.get(url);
+    if (buildUrlFromMap) {
+      return buildUrlFromMap;
     }
     if (urlIsInsideOf(url, buildDirectoryUrl)) {
-      buildUrlCache.set(url, url);
+      associateBuildUrl(url, url);
       return url;
     }
+    if (urlInfo.type === "entry_build") {
+      const buildUrl = new URL(urlInfo.filenameHint, buildDirectoryUrl).href;
+      associateBuildUrl(url, buildUrl);
+      return buildUrl;
+    }
     if (
       urlInfo.type === "directory" ||
       (urlInfo.type === undefined && urlInfo.typeHint === "directory")
@@ -61,27 +64,25 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
       urlInfo,
       ownerUrlInfo,
     });
-    let names = cache[directoryPath];
-    if (!names) {
-      names = [];
-      cache[directoryPath] = names;
+    let nameSet = nameSetPerDirectoryMap.get(directoryPath);
+    if (!nameSet) {
+      nameSet = new Set();
+      nameSetPerDirectoryMap.set(directoryPath, nameSet);
     }
     const urlObject = new URL(url);
     let { search, hash } = urlObject;
-    let name = getUrlName(url, urlInfo);
-    let [basename, extension] = splitFileExtension(name);
+    let urlName = getUrlName(url, urlInfo);
+    let [basename, extension] = splitFileExtension(urlName);
     extension = extensionMappings[extension] || extension;
     let nameCandidate = `${basename}${extension}`; // reconstruct name in case extension was normalized
     let integer = 1;
-    while (true) {
-      if (!names.includes(nameCandidate)) {
-        names.push(nameCandidate);
-        break;
-      }
+    while (nameSet.has(nameCandidate)) {
       integer++;
       nameCandidate = `${basename}${integer}${extension}`;
     }
-    const buildUrl = `${buildDirectoryUrl}${directoryPath}${nameCandidate}${search}${hash}`;
+    const name = nameCandidate;
+    nameSet.add(name);
+    const buildUrl = `${buildDirectoryUrl}${directoryPath}${name}${search}${hash}`;
     associateBuildUrl(url, buildUrl);
     return buildUrl;
   };

package/src/kitchen/fetched_content_compliance.js

@@ -12,8 +12,8 @@ export const assertFetchedContentCompliance = ({ urlInfo, content }) => {
   }
   const { expectedType } = urlInfo.firstReference;
   if (expectedType && urlInfo.type !== expectedType) {
-    if (urlInfo.type === "asset" && urlInfo.context.build) {
-      // asset is a valid type during build
+    if (urlInfo.type === "entry_build" && urlInfo.context.build) {
+      // entry_build is a valid type during build
     } else {
       throw new Error(
         `type must be "${expectedType}", got "${urlInfo.type}" on ${urlInfo.url}`,

package/src/kitchen/kitchen.js

@@ -74,7 +74,7 @@ export const createKitchen = ({
       sourcemaps,
       outDirectoryUrl,
     },
-    resolve: (specifier, importer) => {
+    resolve: (specifier, importer = rootDirectoryUrl) => {
       const { url, packageDirectoryUrl, packageJson } = applyNodeEsmResolution({
         conditions: packageConditions,
         parentUrl: importer,