@jsenv/core 37.1.5 → 38.0.1

package/src/build/build_urls_generator.js

@@ -1,25 +1,48 @@
 import { urlToFilename, urlToRelativeUrl } from "@jsenv/urls";
-import { memoizeByFirstArgument } from "@jsenv/utils/src/memoize/memoize_by_first_argument.js";
+import { ANSI } from "@jsenv/log";
 
 export const createBuildUrlsGenerator = ({
+  logger,
+  sourceDirectoryUrl,
   buildDirectoryUrl,
   assetsDirectory,
 }) => {
   const cache = {};
-
   const getUrlName = (url, urlInfo) => {
     if (!urlInfo) {
       return urlToFilename(url);
     }
-    if (urlInfo.filename) {
-      return urlInfo.filename;
+    if (urlInfo.filenameHint) {
+      return urlInfo.filenameHint;
     }
     return urlToFilename(url);
   };
 
-  const generate = memoizeByFirstArgument((url, { urlInfo, ownerUrlInfo }) => {
+  const buildUrlCache = 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)}
+      `);
+  };
+
+  const generate = (url, { urlInfo, ownerUrlInfo }) => {
+    const buildUrlFromCache = buildUrlCache.get(url);
+    if (buildUrlFromCache) {
+      return buildUrlFromCache;
+    }
+    if (urlInfo.type === "directory") {
+      const directoryPath = urlToRelativeUrl(url, sourceDirectoryUrl);
+      const { search } = new URL(url);
+      const buildUrl = `${buildDirectoryUrl}${directoryPath}${search}`;
+      associateBuildUrl(url, buildUrl);
+      return buildUrl;
+    }
+
     const directoryPath = determineDirectoryPath({
-      buildDirectoryUrl,
+      sourceDirectoryUrl,
       assetsDirectory,
       urlInfo,
       ownerUrlInfo,
@@ -45,8 +68,11 @@ export const createBuildUrlsGenerator = ({
       integer++;
       nameCandidate = `${basename}${integer}${extension}`;
     }
-    return `${buildDirectoryUrl}${directoryPath}${nameCandidate}${search}${hash}`;
-  });
+    hash = "";
+    const buildUrl = `${buildDirectoryUrl}${directoryPath}${nameCandidate}${search}${hash}`;
+    associateBuildUrl(url, buildUrl);
+    return buildUrl;
+  };
 
   return {
     generate,
@@ -74,26 +100,22 @@ const splitFileExtension = (filename) => {
 };
 
 const determineDirectoryPath = ({
-  buildDirectoryUrl,
+  sourceDirectoryUrl,
   assetsDirectory,
   urlInfo,
   ownerUrlInfo,
 }) => {
+  if (urlInfo.dirnameHint) {
+    return urlInfo.dirnameHint;
+  }
   if (urlInfo.type === "directory") {
     return "";
   }
-  if (ownerUrlInfo && ownerUrlInfo.type === "directory") {
-    const ownerDirectoryPath = urlToRelativeUrl(
-      ownerUrlInfo.url,
-      buildDirectoryUrl,
-    );
-    return ownerDirectoryPath;
-  }
   if (urlInfo.isInline) {
     const parentDirectoryPath = determineDirectoryPath({
-      buildDirectoryUrl,
+      sourceDirectoryUrl,
       assetsDirectory,
-      urlInfo: ownerUrlInfo,
+      urlInfo: ownerUrlInfo || urlInfo.firstReference.ownerUrlInfo,
     });
     return parentDirectoryPath;
   }

package/src/build/version_mappings_injection.js

@@ -15,27 +15,25 @@ export const injectVersionMappingsAsGlobal = async (
   versionMappings,
 ) => {
   if (urlInfo.type === "html") {
-    await prependContent(urlInfo, {
-      type: "js_classic",
-      content: generateClientCodeForVersionMappings(versionMappings, {
-        globalName: "window",
-        minification: Boolean(
-          urlInfo.context.getPluginMeta("willMinifyJsClassic"),
-        ),
-      }),
+    const minification = Boolean(
+      urlInfo.context.getPluginMeta("willMinifyJsClassic"),
+    );
+    const content = generateClientCodeForVersionMappings(versionMappings, {
+      globalName: "window",
+      minification,
     });
+    await prependContent(urlInfo, { type: "js_classic", content });
     return;
   }
   if (urlInfo.type === "js_classic" || urlInfo.type === "js_module") {
-    await prependContent(urlInfo, {
-      type: "js_classic",
-      content: generateClientCodeForVersionMappings(versionMappings, {
-        globalName: isWebWorkerUrlInfo(urlInfo) ? "self" : "window",
-        minification: Boolean(
-          urlInfo.context.getPluginMeta("willMinifyJsClassic"),
-        ),
-      }),
+    const minification = Boolean(
+      urlInfo.context.getPluginMeta("willMinifyJsClassic"),
+    );
+    const content = generateClientCodeForVersionMappings(versionMappings, {
+      globalName: isWebWorkerUrlInfo(urlInfo) ? "self" : "window",
+      minification,
     });
+    await prependContent(urlInfo, { type: "js_classic", content });
     return;
   }
 };

package/src/dev/file_service.js

@@ -2,7 +2,6 @@ import { readFileSync } from "node:fs";
 import { serveDirectory, composeTwoResponses } from "@jsenv/server";
 import { bufferToEtag } from "@jsenv/filesystem";
 import { URL_META } from "@jsenv/url-meta";
-import { RUNTIME_COMPAT } from "@jsenv/runtime-compat";
 
 import { WEB_URL_CONVERTER } from "../helpers/web_url_converter.js";
 import { watchSourceFiles } from "../helpers/watch_source_files.js";
@@ -37,7 +36,6 @@ export const createFileService = ({
   cacheControl,
   ribbon,
   sourcemaps,
-  sourcemapsSourcesProtocol,
   sourcemapsSourcesContent,
   outDirectoryUrl,
 }) => {
@@ -103,13 +101,6 @@ export const createFileService = ({
       dev: true,
       runtimeCompat,
       clientRuntimeCompat,
-      systemJsTranspilation:
-        !RUNTIME_COMPAT.isSupported(
-          clientRuntimeCompat,
-          "script_type_module",
-        ) ||
-        !RUNTIME_COMPAT.isSupported(clientRuntimeCompat, "import_dynamic") ||
-        !RUNTIME_COMPAT.isSupported(clientRuntimeCompat, "import_meta"),
       plugins: [
         ...plugins,
         ...getCorePlugins({
@@ -131,7 +122,6 @@ export const createFileService = ({
       supervisor,
       minification: false,
       sourcemaps,
-      sourcemapsSourcesProtocol,
       sourcemapsSourcesContent,
       outDirectoryUrl: outDirectoryUrl
         ? new URL(`${runtimeName}@${runtimeVersion}/`, outDirectoryUrl)

package/src/dev/start_dev_server.js

@@ -62,7 +62,6 @@ export const startDevServer = async ({
   onKitchenCreated = () => {},
 
   sourcemaps = "inline",
-  sourcemapsSourcesProtocol,
   sourcemapsSourcesContent,
   outDirectoryUrl,
   ...rest
@@ -203,7 +202,6 @@ export const startDevServer = async ({
           cacheControl,
           ribbon,
           sourcemaps,
-          sourcemapsSourcesProtocol,
           sourcemapsSourcesContent,
           outDirectoryUrl,
         }),

package/src/kitchen/kitchen.js

@@ -39,7 +39,6 @@ export const createKitchen = ({
   supportedProtocols = ["file:", "data:", "virtual:", "http:", "https:"],
   dev = false,
   build = false,
-  shape = false,
   runtimeCompat,
   // during dev/test clientRuntimeCompat is a single runtime
   // during build clientRuntimeCompat is runtimeCompat
@@ -47,16 +46,18 @@ export const createKitchen = ({
   plugins,
   supervisor,
   sourcemaps = dev ? "inline" : "none", // "programmatic" and "file" also allowed
+  sourcemapsComment,
+  sourcemapsSources,
   sourcemapsSourcesProtocol,
   sourcemapsSourcesContent,
-  sourcemapsSourcesRelative,
   outDirectoryUrl,
-  baseContext = {},
+  initialContext = {},
+  initialPluginsMeta = {},
 }) => {
   const logger = createLogger({ logLevel });
   const kitchen = {
     context: {
-      ...baseContext,
+      ...initialContext,
       kitchen: null,
       signal,
       logger,
@@ -64,7 +65,6 @@ export const createKitchen = ({
       mainFilePath,
       dev,
       build,
-      shape,
       runtimeCompat,
       clientRuntimeCompat,
       inlineContentClientFileUrl,
@@ -88,11 +88,11 @@ export const createKitchen = ({
   });
   kitchen.graph = graph;
 
-  const pluginController = createPluginController(kitchenContext);
-  kitchen.pluginController = pluginController;
-  kitchenContext.getPluginMeta = memoizeGetPluginMeta(
-    pluginController.getPluginMeta,
+  const pluginController = createPluginController(
+    kitchenContext,
+    initialPluginsMeta,
   );
+  kitchen.pluginController = pluginController;
   plugins.forEach((pluginEntry) => {
     pluginController.pushPlugin(pluginEntry);
   });
@@ -100,9 +100,10 @@ export const createKitchen = ({
   const urlInfoTransformer = createUrlInfoTransformer({
     logger,
     sourcemaps,
+    sourcemapsComment,
+    sourcemapsSources,
     sourcemapsSourcesProtocol,
     sourcemapsSourcesContent,
-    sourcemapsSourcesRelative,
     outDirectoryUrl,
     supervisor,
   });
@@ -229,6 +230,7 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
         );
       }
       reference.generatedUrl = reference.url;
+      reference.generatedSearchParams = reference.searchParams;
       return reference;
     } catch (error) {
       throw createResolveUrlError({
@@ -255,19 +257,33 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
       // - convey information (?hot)
       // But do not represent an other resource, it is considered as
       // the same resource under the hood
+      const searchParamTransformationMap = new Map();
       pluginController.callHooks(
         "transformReferenceSearchParams",
         reference,
         (returnValue) => {
           Object.keys(returnValue).forEach((key) => {
-            reference.searchParams.set(key, returnValue[key]);
+            searchParamTransformationMap.set(key, returnValue[key]);
           });
-          const referencedUrlObject = new URL(reference.url);
-          const search = reference.searchParams.toString();
-          referencedUrlObject.search = search;
-          reference.generatedUrl = normalizeUrl(referencedUrlObject.href);
         },
       );
+      if (searchParamTransformationMap.size) {
+        const generatedSearchParams = new URLSearchParams(
+          reference.searchParams,
+        );
+        searchParamTransformationMap.forEach((value, key) => {
+          if (value === undefined) {
+            generatedSearchParams.delete(key);
+          } else {
+            generatedSearchParams.set(key, value);
+          }
+        });
+        const generatedUrlObject = new URL(reference.url);
+        const generatedSearch = generatedSearchParams.toString();
+        generatedUrlObject.search = generatedSearch;
+        reference.generatedUrl = normalizeUrl(generatedUrlObject.href);
+        reference.generatedSearchParams = generatedSearchParams;
+      }
     }
     format: {
       const returnValue = pluginController.callHooksUntil(
@@ -313,7 +329,6 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
         subtype,
         originalUrl,
         sourcemap,
-        filename,
 
         status = 200,
         headers = {},
@@ -348,9 +363,6 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
       if (typeof isEntryPoint === "boolean") {
         urlInfo.isEntryPoint = isEntryPoint;
       }
-      if (filename && !urlInfo.filename) {
-        urlInfo.filename = filename;
-      }
       assertFetchedContentCompliance({
         urlInfo,
         content,
@@ -468,16 +480,17 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
         if (e.code === "DIRECTORY_REFERENCE_NOT_ALLOWED") {
           throw e;
         }
-        if (urlInfo.isInline) {
+        if (urlInfo.isInline && errorOnInlineContentCanSkipThrow(urlInfo)) {
           // When something like <style> or <script> contains syntax error
           // the HTML in itself it still valid
           // keep the syntax error and continue with the HTML
           const errorInfo =
             e.code === "PARSE_ERROR"
               ? `${e.cause.reasonCode}\n${e.traceMessage}`
-              : `${e.traceMessage}`;
+              : e.stack;
           logger.error(
-            `Error while handling ${urlInfo.type} declared in ${urlInfo.firstReference.trace.message}: ${errorInfo}`,
+            `Error while handling ${urlInfo.type} declared in ${urlInfo.firstReference.trace.message}:
+${errorInfo}`,
           );
         } else {
           throw e;
@@ -571,6 +584,23 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
   return kitchen;
 };
 
+// if we are cooking the inline content internally it's better not to throw
+// because the main url info (html) is still valid
+// but if we are explicitely requesting inline content during dev
+// then we should throw
+const errorOnInlineContentCanSkipThrow = (urlInfo) => {
+  if (urlInfo.context.build) {
+    return true;
+  }
+  if (
+    urlInfo.context.reference &&
+    urlInfo.context.reference.url === urlInfo.url
+  ) {
+    return false;
+  }
+  return true;
+};
+
 const debounceCook = (cook) => {
   const pendingDishes = new Map();
   return async (urlInfo, context) => {
@@ -619,19 +649,6 @@ const memoizeCook = (cook) => {
   };
 };
 
-const memoizeGetPluginMeta = (getPluginMeta) => {
-  const cache = new Map();
-  return (id) => {
-    const fromCache = cache.get(id);
-    if (fromCache) {
-      return fromCache;
-    }
-    const value = getPluginMeta(id);
-    cache.set(id, value);
-    return value;
-  };
-};
-
 const memoizeIsSupported = (runtimeCompat) => {
   const cache = new Map();
   return (feature, featureCompat) => {
@@ -697,8 +714,8 @@ const determineFileUrlForOutDirectory = (urlInfo) => {
       fsRootUrl.length,
     )}`;
   }
-  if (urlInfo.filename) {
-    url = setUrlFilename(url, urlInfo.filename);
+  if (urlInfo.filenameHint) {
+    url = setUrlFilename(url, urlInfo.filenameHint);
   }
   return moveUrl({
     url,

package/src/kitchen/url_graph/references.js

@@ -1,14 +1,15 @@
 import {
   getCallerPosition,
   stringifyUrlSite,
-  generateInlineContentUrl,
   urlToBasename,
   urlToExtension,
 } from "@jsenv/urls";
+import { generateUrlForInlineContent } from "@jsenv/ast";
 
 import { isWebWorkerEntryPointReference } from "../web_workers.js";
 import { prependContent } from "../prepend_content.js";
-import { GRAPH_VISITOR } from "./url_graph_visitor.js";
+
+let referenceId = 0;
 
 export const createDependencies = (ownerUrlInfo) => {
   const { referenceToOthersSet } = ownerUrlInfo;
@@ -101,37 +102,10 @@ export const createDependencies = (ownerUrlInfo) => {
       specifier: sideEffectFileUrl,
       ...rest,
     });
-    const parentUrlInfo = ownerUrlInfo.findParentIfInline() || ownerUrlInfo;
-
-    const associateIfReferencedBy = (urlInfo) => {
-      for (const referenceToOther of urlInfo.referenceToOthersSet) {
-        if (referenceToOther === sideEffectFileReference) {
-          continue;
-        }
-        if (referenceToOther.url === sideEffectFileUrl) {
-          // consider this reference becomes the last reference
-          // this ensure this ref is properly detected as inlined by urlInfo.isUsed()
-          sideEffectFileReference.next =
-            referenceToOther.next || referenceToOther;
-          return true;
-        }
-        if (
-          referenceToOther.original &&
-          referenceToOther.original.url === sideEffectFileUrl
-        ) {
-          // consider this reference becomes the last reference
-          // this ensure this ref is properly detected as inlined by urlInfo.isUsed()
-          sideEffectFileReference.next =
-            referenceToOther.next || referenceToOther;
-          return true;
-        }
-      }
-      return false;
-    };
 
     const injectAsBannerCodeBeforeFinalize = (urlInfoReceiver) => {
       const basename = urlToBasename(sideEffectFileUrl);
-      const inlineUrl = generateInlineContentUrl({
+      const inlineUrl = generateUrlForInlineContent({
         url: urlInfoReceiver.url,
         basename,
         extension: urlToExtension(sideEffectFileUrl),
@@ -158,59 +132,69 @@ export const createDependencies = (ownerUrlInfo) => {
     // during dev cooking files is incremental
     // so HTML/JS is already executed by the browser
     // we can't late inject into entry point
-    if (ownerUrlInfo.context.dev) {
-      if (associateIfReferencedBy(ownerUrlInfo)) {
-        return;
-      }
-      const dependentReferencingThatFile = GRAPH_VISITOR.findDependent(
-        parentUrlInfo,
-        (ancestorUrlInfo) => {
-          if (ancestorUrlInfo.isRoot) {
-            return false;
-          }
-          return associateIfReferencedBy(ancestorUrlInfo);
-        },
-      );
-      if (dependentReferencingThatFile) {
-        return;
-      }
-      injectAsBannerCodeBeforeFinalize(parentUrlInfo);
-      return;
-    }
-
     // During build:
-    // during build, files are not executed so it's
-    // possible to inject reference when discovering a side effect file
-    if (associateIfReferencedBy(ownerUrlInfo)) {
-      return;
-    }
-    // The thing to do here is to inject side effect file into entry point
-    // only when:
-    // - entry point does not already has it
-    // - nothing between entry point and the file has it
-    const entryPoints = parentUrlInfo.graph.getEntryPoints();
-    for (const entryPointUrlInfo of entryPoints) {
-      if (associateIfReferencedBy(entryPointUrlInfo)) {
-        continue;
-      }
-      if (parentUrlInfo.isEntryPoint) {
-        injectAsBannerCodeBeforeFinalize(entryPointUrlInfo);
-        continue;
+    // files are not executed so it's possible to inject reference
+    // when discovering a side effect file
+    const visitedMap = new Map();
+    let foundOrInjectedOnce = false;
+    const visit = (urlInfo) => {
+      urlInfo = urlInfo.findParentIfInline() || urlInfo;
+      const value = visitedMap.get(urlInfo);
+      if (value !== undefined) {
+        return value;
       }
-      let found = false;
-      GRAPH_VISITOR.findDependency(entryPointUrlInfo, (dependencyUrlInfo) => {
-        if (associateIfReferencedBy(dependencyUrlInfo)) {
-          found = true;
+
+      // search if already referenced
+      for (const referenceToOther of urlInfo.referenceToOthersSet) {
+        if (referenceToOther === sideEffectFileReference) {
+          continue;
+        }
+        if (referenceToOther.url === sideEffectFileUrl) {
+          // consider this reference becomes the last reference
+          // this ensure this ref is properly detected as inlined by urlInfo.isUsed()
+          sideEffectFileReference.next =
+            referenceToOther.next || referenceToOther;
+          foundOrInjectedOnce = true;
+          visitedMap.set(urlInfo, true);
           return true;
         }
-        if (dependencyUrlInfo === parentUrlInfo) {
+        if (
+          referenceToOther.original &&
+          referenceToOther.original.url === sideEffectFileUrl
+        ) {
+          // consider this reference becomes the last reference
+          // this ensure this ref is properly detected as inlined by urlInfo.isUsed()
+          sideEffectFileReference.next =
+            referenceToOther.next || referenceToOther;
+          foundOrInjectedOnce = true;
+          visitedMap.set(urlInfo, true);
           return true;
         }
-        return false;
-      });
-      if (!found) {
-        injectAsBannerCodeBeforeFinalize(entryPointUrlInfo);
       }
+      // not referenced and we reach an entry point, stop there
+      if (urlInfo.isEntryPoint) {
+        foundOrInjectedOnce = true;
+        visitedMap.set(urlInfo, true);
+        injectAsBannerCodeBeforeFinalize(urlInfo);
+        return true;
+      }
+      visitedMap.set(urlInfo, false);
+      for (const referenceFromOther of urlInfo.referenceFromOthersSet) {
+        const urlInfoReferencingThisOne = referenceFromOther.ownerUrlInfo;
+        visit(urlInfoReferencingThisOne);
+        // during dev the first urlInfo where we inject the side effect file is enough
+        // during build we want to inject into every possible entry point
+        if (foundOrInjectedOnce && urlInfo.context.dev) {
+          break;
+        }
+      }
+      return false;
+    };
+    visit(ownerUrlInfo);
+    if (ownerUrlInfo.context.dev && !foundOrInjectedOnce) {
+      injectAsBannerCodeBeforeFinalize(
+        ownerUrlInfo.findParentIfInline() || ownerUrlInfo,
+      );
     }
   };
 
@@ -275,7 +259,7 @@ const createReference = ({
   expectedContentType,
   expectedType,
   expectedSubtype,
-  filename,
+  filenameHint,
   integrity,
   crossorigin,
   specifier,
@@ -326,6 +310,7 @@ const createReference = ({
     }
   }
   const reference = {
+    id: ++referenceId,
     ownerUrlInfo,
     original,
     prev,
@@ -342,7 +327,7 @@ const createReference = ({
     expectedContentType,
     expectedType,
     expectedSubtype,
-    filename,
+    filenameHint,
     integrity,
     crossorigin,
     specifier,
@@ -445,6 +430,7 @@ const createReference = ({
       original: reference.original || reference,
       prev: reference,
       trace,
+      injected: reference.injected,
       expectedType: reference.expectedType,
       ...props,
     });
@@ -625,6 +611,8 @@ const applyDependencyRemovalEffects = (reference) => {
     }
     return false;
   }
+  // referencedUrlInfo.firstReference = null;
+  // referencedUrlInfo.lastReference = null;
   referencedUrlInfo.onDereferenced(reference);
   return true;
 };
@@ -691,8 +679,23 @@ const getRedirectedReferenceProps = (reference, url) => {
 
 const applyReferenceEffectsOnUrlInfo = (reference) => {
   const referencedUrlInfo = reference.urlInfo;
+  referencedUrlInfo.lastReference = reference;
+  if (reference.isInline) {
+    referencedUrlInfo.isInline = true;
+    referencedUrlInfo.inlineUrlSite = {
+      url: reference.ownerUrlInfo.url,
+      content: reference.isOriginalPosition
+        ? reference.ownerUrlInfo.originalContent
+        : reference.ownerUrlInfo.content,
+      line: reference.specifierLine,
+      column: reference.specifierColumn,
+    };
+  }
 
-  if (referencedUrlInfo.firstReference) {
+  if (
+    referencedUrlInfo.firstReference &&
+    !referencedUrlInfo.firstReference.isWeak
+  ) {
     return;
   }
   referencedUrlInfo.firstReference = reference;
@@ -707,21 +710,9 @@ const applyReferenceEffectsOnUrlInfo = (reference) => {
   if (reference.injected) {
     referencedUrlInfo.injected = true;
   }
-  if (reference.filename && !referencedUrlInfo.filename) {
-    referencedUrlInfo.filename = reference.filename;
+  if (reference.filenameHint && !referencedUrlInfo.filenameHint) {
+    referencedUrlInfo.filenameHint = reference.filenameHint;
   }
-  if (reference.isInline) {
-    referencedUrlInfo.isInline = true;
-    referencedUrlInfo.inlineUrlSite = {
-      url: reference.ownerUrlInfo.url,
-      content: reference.isOriginalPosition
-        ? reference.ownerUrlInfo.originalContent
-        : reference.ownerUrlInfo.content,
-      line: reference.specifierLine,
-      column: reference.specifierColumn,
-    };
-  }
-
   if (reference.debug) {
     referencedUrlInfo.debug = true;
   }