@jsenv/core 35.0.3 → 35.0.5

package/src/build/build_urls_generator.js

@@ -1,21 +1,21 @@
-import { urlToFilename, urlToRelativeUrl } from "@jsenv/urls"
-import { memoizeByFirstArgument } from "@jsenv/utils/src/memoize/memoize_by_first_argument.js"
+import { urlToFilename, urlToRelativeUrl } from "@jsenv/urls";
+import { memoizeByFirstArgument } from "@jsenv/utils/src/memoize/memoize_by_first_argument.js";
 
 export const createBuildUrlsGenerator = ({
   buildDirectoryUrl,
   assetsDirectory,
 }) => {
-  const cache = {}
+  const cache = {};
 
   const getUrlName = (url, urlInfo) => {
     if (!urlInfo) {
-      return urlToFilename(url)
+      return urlToFilename(url);
     }
     if (urlInfo.filename) {
-      return urlInfo.filename
+      return urlInfo.filename;
     }
-    return urlToFilename(url)
-  }
+    return urlToFilename(url);
+  };
 
   const generate = memoizeByFirstArgument((url, { urlInfo, parentUrlInfo }) => {
     const directoryPath = determineDirectoryPath({
@@ -23,35 +23,35 @@ export const createBuildUrlsGenerator = ({
       assetsDirectory,
       urlInfo,
       parentUrlInfo,
-    })
-    let names = cache[directoryPath]
+    });
+    let names = cache[directoryPath];
     if (!names) {
-      names = []
-      cache[directoryPath] = names
+      names = [];
+      cache[directoryPath] = names;
     }
-    const urlObject = new URL(url)
-    let { search, hash } = urlObject
-    let name = getUrlName(url, urlInfo)
-    let [basename, extension] = splitFileExtension(name)
-    extension = extensionMappings[extension] || extension
-    let nameCandidate = `${basename}${extension}` // reconstruct name in case extension was normalized
-    let integer = 1
+    const urlObject = new URL(url);
+    let { search, hash } = urlObject;
+    let name = getUrlName(url, urlInfo);
+    let [basename, extension] = splitFileExtension(name);
+    extension = extensionMappings[extension] || extension;
+    let nameCandidate = `${basename}${extension}`; // reconstruct name in case extension was normalized
+    let integer = 1;
     // eslint-disable-next-line no-constant-condition
     while (true) {
       if (!names.includes(nameCandidate)) {
-        names.push(nameCandidate)
-        break
+        names.push(nameCandidate);
+        break;
       }
-      integer++
-      nameCandidate = `${basename}${integer}${extension}`
+      integer++;
+      nameCandidate = `${basename}${integer}${extension}`;
     }
-    return `${buildDirectoryUrl}${directoryPath}${nameCandidate}${search}${hash}`
-  })
+    return `${buildDirectoryUrl}${directoryPath}${nameCandidate}${search}${hash}`;
+  });
 
   return {
     generate,
-  }
-}
+  };
+};
 
 // It's best to generate files with an extension representing what is inside the file
 // and after build js files contains solely js (js or typescript is gone).
@@ -63,15 +63,15 @@ const extensionMappings = {
   ".jsx": ".js",
   ".ts": ".js",
   ".tsx": ".js",
-}
+};
 
 const splitFileExtension = (filename) => {
-  const dotLastIndex = filename.lastIndexOf(".")
+  const dotLastIndex = filename.lastIndexOf(".");
   if (dotLastIndex === -1) {
-    return [filename, ""]
+    return [filename, ""];
   }
-  return [filename.slice(0, dotLastIndex), filename.slice(dotLastIndex)]
-}
+  return [filename.slice(0, dotLastIndex), filename.slice(dotLastIndex)];
+};
 
 const determineDirectoryPath = ({
   buildDirectoryUrl,
@@ -80,40 +80,40 @@ const determineDirectoryPath = ({
   parentUrlInfo,
 }) => {
   if (urlInfo.type === "directory") {
-    return ""
+    return "";
   }
   if (parentUrlInfo && parentUrlInfo.type === "directory") {
     const parentDirectoryPath = urlToRelativeUrl(
       parentUrlInfo.url,
       buildDirectoryUrl,
-    )
-    return parentDirectoryPath
+    );
+    return parentDirectoryPath;
   }
   if (urlInfo.isInline) {
     const parentDirectoryPath = determineDirectoryPath({
       buildDirectoryUrl,
       assetsDirectory,
       urlInfo: parentUrlInfo,
-    })
-    return parentDirectoryPath
+    });
+    return parentDirectoryPath;
   }
   if (urlInfo.isEntryPoint) {
-    return ""
+    return "";
   }
   if (urlInfo.type === "importmap") {
-    return ""
+    return "";
   }
   if (urlInfo.type === "html") {
-    return `${assetsDirectory}html/`
+    return `${assetsDirectory}html/`;
   }
   if (urlInfo.type === "css") {
-    return `${assetsDirectory}css/`
+    return `${assetsDirectory}css/`;
   }
   if (urlInfo.type === "js_module" || urlInfo.type === "js_classic") {
-    return `${assetsDirectory}js/`
+    return `${assetsDirectory}js/`;
   }
   if (urlInfo.type === "json") {
-    return `${assetsDirectory}json/`
+    return `${assetsDirectory}json/`;
   }
-  return `${assetsDirectory}other/`
-}
+  return `${assetsDirectory}other/`;
+};

package/src/build/graph_utils.js

@@ -1,34 +1,34 @@
 export const GRAPH = {
   map: (graph, callback) => {
-    const array = []
+    const array = [];
     graph.urlInfoMap.forEach((urlInfo) => {
-      array.push(callback(urlInfo))
-    })
-    return array
+      array.push(callback(urlInfo));
+    });
+    return array;
   },
 
   forEach: (graph, callback) => {
-    graph.urlInfoMap.forEach(callback)
+    graph.urlInfoMap.forEach(callback);
   },
 
   filter: (graph, callback) => {
-    const urlInfos = []
+    const urlInfos = [];
     graph.urlInfoMap.forEach((urlInfo) => {
       if (callback(urlInfo)) {
-        urlInfos.push(urlInfo)
+        urlInfos.push(urlInfo);
       }
-    })
-    return urlInfos
+    });
+    return urlInfos;
   },
 
   find: (graph, callback) => {
-    let found = null
+    let found = null;
     for (const urlInfo of graph.urlInfoMap.values()) {
       if (callback(urlInfo)) {
-        found = urlInfo
-        break
+        found = urlInfo;
+        break;
       }
     }
-    return found
+    return found;
   },
-}
+};

package/src/build/jsenv_plugin_line_break_normalization.js

@@ -1,6 +1,6 @@
-import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
 
-import { ensureUnixLineBreaks } from "./line_break_unix.js"
+import { ensureUnixLineBreaks } from "./line_break_unix.js";
 
 export const jsenvPluginLineBreakNormalization = () => {
   return {
@@ -8,9 +8,9 @@ export const jsenvPluginLineBreakNormalization = () => {
     appliesDuring: "build",
     transformUrlContent: (urlInfo) => {
       if (CONTENT_TYPE.isTextual(urlInfo.contentType)) {
-        return ensureUnixLineBreaks(urlInfo.content)
+        return ensureUnixLineBreaks(urlInfo.content);
       }
-      return null
+      return null;
     },
-  }
-}
+  };
+};

package/src/build/line_break_unix.js

@@ -1,26 +1,26 @@
 export const ensureUnixLineBreaks = (stringOrBuffer) => {
   if (typeof stringOrBuffer === "string") {
-    const stringWithLinuxBreaks = stringOrBuffer.replace(/\r\n/g, "\n")
-    return stringWithLinuxBreaks
+    const stringWithLinuxBreaks = stringOrBuffer.replace(/\r\n/g, "\n");
+    return stringWithLinuxBreaks;
   }
-  return ensureUnixLineBreaksOnBuffer(stringOrBuffer)
-}
+  return ensureUnixLineBreaksOnBuffer(stringOrBuffer);
+};
 
 // https://github.com/nodejs/help/issues/1738#issuecomment-458460503
 const ensureUnixLineBreaksOnBuffer = (buffer) => {
-  const int32Array = new Int32Array(buffer, 0, buffer.length)
+  const int32Array = new Int32Array(buffer, 0, buffer.length);
   const int32ArrayWithLineBreaksNormalized = int32Array.filter(
     (element, index, typedArray) => {
       if (element === 0x0d) {
         if (typedArray[index + 1] === 0x0a) {
           // Windows -> Unix
-          return false
+          return false;
         }
         // Mac OS -> Unix
-        typedArray[index] = 0x0a
+        typedArray[index] = 0x0a;
       }
-      return true
+      return true;
     },
-  )
-  return Buffer.from(int32ArrayWithLineBreaksNormalized)
-}
+  );
+  return Buffer.from(int32ArrayWithLineBreaksNormalized);
+};

package/src/build/start_build_server.js

@@ -13,17 +13,17 @@
  * we want to be in the user shoes and we should not alter build files.
  */
 
-import { existsSync } from "node:fs"
+import { existsSync } from "node:fs";
 import {
   jsenvAccessControlAllowedHeaders,
   startServer,
   fetchFileSystem,
   jsenvServiceCORS,
   jsenvServiceErrorHandler,
-} from "@jsenv/server"
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
-import { createLogger, createTaskLog } from "@jsenv/log"
+} from "@jsenv/server";
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+import { Abort, raceProcessTeardownEvents } from "@jsenv/abort";
+import { createLogger, createTaskLog } from "@jsenv/log";
 
 /**
  * Start a server for build files.
@@ -51,44 +51,44 @@ export const startBuildServer = async ({
 }) => {
   // params validation
   {
-    const unexpectedParamNames = Object.keys(rest)
+    const unexpectedParamNames = Object.keys(rest);
     if (unexpectedParamNames.length > 0) {
       throw new TypeError(
         `${unexpectedParamNames.join(",")}: there is no such param`,
-      )
+      );
     }
     buildDirectoryUrl = assertAndNormalizeDirectoryUrl(
       buildDirectoryUrl,
       "buildDirectoryUrl",
-    )
+    );
 
     if (buildMainFilePath) {
       if (typeof buildMainFilePath !== "string") {
         throw new TypeError(
           `buildMainFilePath must be a string, got ${buildMainFilePath}`,
-        )
+        );
       }
       if (buildMainFilePath[0] === "/") {
-        buildMainFilePath = buildMainFilePath.slice(1)
+        buildMainFilePath = buildMainFilePath.slice(1);
       } else {
         const buildMainFileUrl = new URL(buildMainFilePath, buildDirectoryUrl)
-          .href
+          .href;
         if (!buildMainFileUrl.startsWith(buildDirectoryUrl)) {
           throw new Error(
             `buildMainFilePath must be relative, got ${buildMainFilePath}`,
-          )
+          );
         }
-        buildMainFilePath = buildMainFileUrl.slice(buildDirectoryUrl.length)
+        buildMainFilePath = buildMainFileUrl.slice(buildDirectoryUrl.length);
       }
       if (!existsSync(new URL(buildMainFilePath, buildDirectoryUrl))) {
-        buildMainFilePath = null
+        buildMainFilePath = null;
       }
     }
   }
 
-  const logger = createLogger({ logLevel })
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
+  const logger = createLogger({ logLevel });
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
   if (handleSIGINT) {
     operation.addAbortSource((abort) => {
       return raceProcessTeardownEvents(
@@ -96,13 +96,13 @@ export const startBuildServer = async ({
           SIGINT: true,
         },
         abort,
-      )
-    })
+      );
+    });
   }
 
   const startBuildServerTask = createTaskLog("start build server", {
     disabled: !logger.levels.info,
-  })
+  });
   const server = await startServer({
     signal,
     stopOnExit: false,
@@ -142,33 +142,33 @@ export const startBuildServer = async ({
         sendErrorDetails: true,
       }),
     ],
-  })
-  startBuildServerTask.done()
+  });
+  startBuildServerTask.done();
   if (hostname) {
-    delete server.origins.localip
-    delete server.origins.externalip
+    delete server.origins.localip;
+    delete server.origins.externalip;
   }
-  logger.info(``)
+  logger.info(``);
   Object.keys(server.origins).forEach((key) => {
-    logger.info(`- ${server.origins[key]}`)
-  })
-  logger.info(``)
+    logger.info(`- ${server.origins[key]}`);
+  });
+  logger.info(``);
   return {
     origin: server.origin,
     stop: () => {
-      server.stop()
+      server.stop();
     },
-  }
-}
+  };
+};
 
 const createBuildFilesService = ({ buildDirectoryUrl, buildMainFilePath }) => {
   return (request) => {
-    const urlIsVersioned = new URL(request.url).searchParams.has("v")
+    const urlIsVersioned = new URL(request.url).searchParams.has("v");
     if (buildMainFilePath && request.resource === "/") {
       request = {
         ...request,
         resource: `/${buildMainFilePath}`,
-      }
+      };
     }
     return fetchFileSystem(
       new URL(request.resource.slice(1), buildDirectoryUrl),
@@ -182,8 +182,8 @@ const createBuildFilesService = ({ buildDirectoryUrl, buildMainFilePath }) => {
         rootDirectoryUrl: buildDirectoryUrl,
         canReadDirectory: true,
       },
-    )
-  }
-}
+    );
+  };
+};
 
-const SECONDS_IN_30_DAYS = 60 * 60 * 24 * 30
+const SECONDS_IN_30_DAYS = 60 * 60 * 24 * 30;

package/src/build/version_generator.js

@@ -1,19 +1,19 @@
-import { createHash } from "node:crypto"
+import { createHash } from "node:crypto";
 
 // https://github.com/rollup/rollup/blob/19e50af3099c2f627451a45a84e2fa90d20246d5/src/utils/FileEmitter.ts#L47
 // https://github.com/rollup/rollup/blob/5a5391971d695c808eed0c5d7d2c6ccb594fc689/src/Chunk.ts#L870
 export const createVersionGenerator = () => {
-  const hash = createHash("sha256")
+  const hash = createHash("sha256");
 
   return {
     augmentWithContent: (content) => {
-      hash.update(content)
+      hash.update(content);
     },
     augment: (value) => {
-      hash.update(value)
+      hash.update(value);
     },
     generate: () => {
-      return hash.digest("hex").slice(0, 8)
+      return hash.digest("hex").slice(0, 8);
     },
-  }
-}
+  };
+};

package/src/build/version_mappings_injection.js

@@ -1,37 +1,37 @@
 // https://bundlers.tooling.report/hashing/avoid-cascade/
 
-import { createMagicSource } from "@jsenv/sourcemap"
+import { createMagicSource } from "@jsenv/sourcemap";
 import {
   parseHtmlString,
   injectHtmlNodeAsEarlyAsPossible,
   createHtmlNode,
   stringifyHtmlAst,
-} from "@jsenv/ast"
+} from "@jsenv/ast";
 
-import { isWebWorkerUrlInfo } from "@jsenv/core/src/kitchen/web_workers.js"
+import { isWebWorkerUrlInfo } from "@jsenv/core/src/kitchen/web_workers.js";
 
 export const injectVersionMappingsAsGlobal = async ({
   urlInfo,
   kitchen,
   versionMappings,
 }) => {
-  const injector = injectors[urlInfo.type]
+  const injector = injectors[urlInfo.type];
   if (injector) {
     const { content, sourcemap } = await injector(urlInfo, {
       versionMappings,
       minification: kitchen.kitchenContext.minification,
-    })
+    });
     kitchen.urlInfoTransformer.applyFinalTransformations(urlInfo, {
       content,
       sourcemap,
-    })
+    });
   }
-}
+};
 const injectors = {
   html: (urlInfo, { versionMappings, minification }) => {
     const htmlAst = parseHtmlString(urlInfo.content, {
       storeOriginalPositions: false,
-    })
+    });
     injectHtmlNodeAsEarlyAsPossible(
       htmlAst,
       createHtmlNode({
@@ -42,23 +42,23 @@ const injectors = {
         }),
       }),
       "jsenv:versioning",
-    )
+    );
     return {
       content: stringifyHtmlAst(htmlAst),
-    }
+    };
   },
   js_classic: (...args) => jsInjector(...args),
   js_module: (...args) => jsInjector(...args),
-}
+};
 const jsInjector = (urlInfo, { versionMappings, minification }) => {
-  const magicSource = createMagicSource(urlInfo.content)
+  const magicSource = createMagicSource(urlInfo.content);
   const code = generateClientCodeForVersionMappings(versionMappings, {
     globalName: isWebWorkerUrlInfo(urlInfo) ? "self" : "window",
     minification,
-  })
-  magicSource.prepend(`${code}\n\n`)
-  return magicSource.toContentAndSourcemap()
-}
+  });
+  magicSource.prepend(`${code}\n\n`);
+  return magicSource.toContentAndSourcemap();
+};
 const generateClientCodeForVersionMappings = (
   versionMappings,
   { globalName, minification },
@@ -66,15 +66,15 @@ const generateClientCodeForVersionMappings = (
   if (minification) {
     return `;(function(){var m = ${JSON.stringify(
       versionMappings,
-    )}; ${globalName}.__v__ = function (s) { return m[s] || s }; })();`
+    )}; ${globalName}.__v__ = function (s) { return m[s] || s }; })();`;
   }
   return `;(function() {
   var __versionMappings__ = ${JSON.stringify(versionMappings, null, "  ")};
   ${globalName}.__v__ = function (specifier) {
     return __versionMappings__[specifier] || specifier
   };
-})();`
-}
+})();`;
+};
 
 export const injectVersionMappingsAsImportmap = async ({
   urlInfo,
@@ -83,7 +83,7 @@ export const injectVersionMappingsAsImportmap = async ({
 }) => {
   const htmlAst = parseHtmlString(urlInfo.content, {
     storeOriginalPositions: false,
-  })
+  });
   // jsenv_plugin_importmap.js is removing importmap during build
   // it means at this point we know HTML has no importmap in it
   // we can safely inject one
@@ -97,8 +97,8 @@ export const injectVersionMappingsAsImportmap = async ({
         : JSON.stringify({ imports: versionMappings }, null, "  "),
     }),
     "jsenv:versioning",
-  )
+  );
   kitchen.urlInfoTransformer.applyFinalTransformations(urlInfo, {
     content: stringifyHtmlAst(htmlAst),
-  })
-}
+  });
+};