@jsenv/core 37.0.5 → 37.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "37.0.5",
+  "version": "37.1.1",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -69,7 +69,7 @@
     "@jsenv/node-esm-resolution": "1.0.1",
     "@jsenv/js-module-fallback": "1.2.0",
     "@jsenv/runtime-compat": "1.1.0",
-    "@jsenv/server": "15.0.4",
+    "@jsenv/server": "15.1.0",
     "@jsenv/sourcemap": "1.1.0",
     "@jsenv/plugin-transpilation": "1.2.1",
     "@jsenv/plugin-supervisor": "1.2.0",

package/src/build/build.js

@@ -347,7 +347,7 @@ build ${entryPointKeys.length} entry points`);
       sourcemaps,
       sourcemapsSourcesContent,
       outDirectoryUrl: outDirectoryUrl
-        ? new URL("build/", outDirectoryUrl)
+        ? new URL("prebuild/", outDirectoryUrl)
         : undefined,
     });
 
@@ -602,13 +602,6 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
                   rawUrlInfo.url,
                   "raw file",
                 );
-                if (buildUrl.includes("?")) {
-                  associateBuildUrlAndRawUrl(
-                    asUrlWithoutSearch(buildUrl),
-                    rawUrlInfo.url,
-                    "raw file",
-                  );
-                }
                 return buildUrl;
               }
               if (reference.type === "sourcemap_comment") {
@@ -822,84 +815,86 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
             bundler.urlInfoMap.set(rawUrlInfo.url, rawUrlInfo);
           }
         };
-        GRAPH_VISITOR.forEach(rawKitchen.graph, (rawUrlInfo) => {
-          // ignore unused urls (avoid bundling things that are not actually used)
-          // happens for:
-          // - js import assertions
-          // - conversion to js classic using ?as_js_classic or ?js_module_fallback
-          if (!rawUrlInfo.isUsed()) {
-            return;
-          }
-          if (rawUrlInfo.isEntryPoint) {
-            addToBundlerIfAny(rawUrlInfo);
-          }
-          if (rawUrlInfo.type === "html") {
-            rawUrlInfo.referenceToOthersSet.forEach((referenceToOther) => {
-              if (referenceToOther.isWeak) {
-                return;
-              }
-              const referencedUrlInfo = referenceToOther.urlInfo;
-              if (referencedUrlInfo.isInline) {
-                if (referencedUrlInfo.type === "js_module") {
-                  // bundle inline script type module deps
-                  referencedUrlInfo.referenceToOthersSet.forEach(
-                    (jsModuleReferenceToOther) => {
-                      if (jsModuleReferenceToOther.type === "js_import") {
-                        const inlineUrlInfo = jsModuleReferenceToOther.urlInfo;
-                        addToBundlerIfAny(inlineUrlInfo);
-                      }
-                    },
-                  );
+        // ignore unused urls thanks to "forEachUrlInfoStronglyReferenced"
+        // it avoid bundling things that are not actually used
+        // happens for:
+        // - js import assertions
+        // - conversion to js classic using ?as_js_classic or ?js_module_fallback
+        GRAPH_VISITOR.forEachUrlInfoStronglyReferenced(
+          rawKitchen.graph.rootUrlInfo,
+          (rawUrlInfo) => {
+            if (rawUrlInfo.isEntryPoint) {
+              addToBundlerIfAny(rawUrlInfo);
+            }
+            if (rawUrlInfo.type === "html") {
+              rawUrlInfo.referenceToOthersSet.forEach((referenceToOther) => {
+                if (referenceToOther.isWeak) {
+                  return;
                 }
-                // inline content cannot be bundled
-                return;
-              }
-              addToBundlerIfAny(referencedUrlInfo);
-            });
-            rawUrlInfo.referenceToOthersSet.forEach((referenceToOther) => {
-              if (
-                referenceToOther.isResourceHint &&
-                referenceToOther.expectedType === "js_module"
-              ) {
                 const referencedUrlInfo = referenceToOther.urlInfo;
+                if (referencedUrlInfo.isInline) {
+                  if (referencedUrlInfo.type === "js_module") {
+                    // bundle inline script type module deps
+                    referencedUrlInfo.referenceToOthersSet.forEach(
+                      (jsModuleReferenceToOther) => {
+                        if (jsModuleReferenceToOther.type === "js_import") {
+                          const inlineUrlInfo =
+                            jsModuleReferenceToOther.urlInfo;
+                          addToBundlerIfAny(inlineUrlInfo);
+                        }
+                      },
+                    );
+                  }
+                  // inline content cannot be bundled
+                  return;
+                }
+                addToBundlerIfAny(referencedUrlInfo);
+              });
+              rawUrlInfo.referenceToOthersSet.forEach((referenceToOther) => {
                 if (
-                  referencedUrlInfo &&
-                  // something else than the resource hint is using this url
-                  referencedUrlInfo.referenceFromOthersSet.size > 0
+                  referenceToOther.isResourceHint &&
+                  referenceToOther.expectedType === "js_module"
                 ) {
-                  addToBundlerIfAny(referencedUrlInfo);
+                  const referencedUrlInfo = referenceToOther.urlInfo;
+                  if (
+                    referencedUrlInfo &&
+                    // something else than the resource hint is using this url
+                    referencedUrlInfo.referenceFromOthersSet.size > 0
+                  ) {
+                    addToBundlerIfAny(referencedUrlInfo);
+                  }
                 }
-              }
-            });
-            return;
-          }
-          // File referenced with new URL('./file.js', import.meta.url)
-          // are entry points that should be bundled
-          // For instance we will bundle service worker/workers detected like this
-          if (rawUrlInfo.type === "js_module") {
-            rawUrlInfo.referenceToOthersSet.forEach((referenceToOther) => {
-              if (referenceToOther.type === "js_url") {
-                const referencedUrlInfo = referenceToOther.urlInfo;
-                for (const referenceFromOther of referencedUrlInfo.referenceFromOthersSet) {
-                  if (referenceFromOther.url === referencedUrlInfo.url) {
-                    if (
-                      referenceFromOther.subtype === "import_dynamic" ||
-                      referenceFromOther.type === "script"
-                    ) {
-                      // will already be bundled
-                      return;
+              });
+              return;
+            }
+            // File referenced with new URL('./file.js', import.meta.url)
+            // are entry points that should be bundled
+            // For instance we will bundle service worker/workers detected like this
+            if (rawUrlInfo.type === "js_module") {
+              rawUrlInfo.referenceToOthersSet.forEach((referenceToOther) => {
+                if (referenceToOther.type === "js_url") {
+                  const referencedUrlInfo = referenceToOther.urlInfo;
+                  for (const referenceFromOther of referencedUrlInfo.referenceFromOthersSet) {
+                    if (referenceFromOther.url === referencedUrlInfo.url) {
+                      if (
+                        referenceFromOther.subtype === "import_dynamic" ||
+                        referenceFromOther.type === "script"
+                      ) {
+                        // will already be bundled
+                        return;
+                      }
                     }
                   }
+                  addToBundlerIfAny(referencedUrlInfo);
+                  return;
                 }
-                addToBundlerIfAny(referencedUrlInfo);
-                return;
-              }
-              if (referenceToOther.type === "js_inline_content") {
-                // we should bundle it too right?
-              }
-            });
-          }
-        });
+                if (referenceToOther.type === "js_inline_content") {
+                  // we should bundle it too right?
+                }
+              });
+            }
+          },
+        );
         await Object.keys(bundlers).reduce(async (previous, type) => {
           await previous;
           const bundler = bundlers[type];
@@ -1209,24 +1204,14 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
           resyncTask.done();
         }
       }
-      delete_unused_urls: {
-        const actions = [];
-        GRAPH_VISITOR.forEach(finalKitchen.graph, (urlInfo) => {
-          if (!urlInfo.isUsed()) {
-            actions.push(() => {
-              urlInfo.deleteFromGraph();
-            });
-          }
-        });
-        actions.forEach((action) => action());
-      }
       inject_urls_in_service_workers: {
         const serviceWorkerEntryUrlInfos = GRAPH_VISITOR.filter(
           finalKitchen.graph,
           (finalUrlInfo) => {
             return (
               finalUrlInfo.subtype === "service_worker" &&
-              finalUrlInfo.isEntryPoint
+              finalUrlInfo.isEntryPoint &&
+              finalUrlInfo.isUsed()
             );
           },
         );
@@ -1235,34 +1220,34 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
             "inject urls in service worker",
           );
           const serviceWorkerResources = {};
-          GRAPH_VISITOR.forEach(finalKitchen.graph, (urlInfo) => {
-            if (urlInfo.isRoot) {
-              return;
-            }
-            if (!urlInfo.url.startsWith("file:")) {
-              return;
-            }
-            if (urlInfo.isInline) {
-              return;
-            }
-            if (!canUseVersionedUrl(urlInfo)) {
-              // when url is not versioned we compute a "version" for that url anyway
-              // so that service worker source still changes and navigator
-              // detect there is a change
+          GRAPH_VISITOR.forEachUrlInfoStronglyReferenced(
+            finalKitchen.graph.rootUrlInfo,
+            (urlInfo) => {
+              if (!urlInfo.url.startsWith("file:")) {
+                return;
+              }
+              if (urlInfo.isInline) {
+                return;
+              }
+              if (!canUseVersionedUrl(urlInfo)) {
+                // when url is not versioned we compute a "version" for that url anyway
+                // so that service worker source still changes and navigator
+                // detect there is a change
+                const buildSpecifier = findKey(buildSpecifierMap, urlInfo.url);
+                serviceWorkerResources[buildSpecifier] = {
+                  version: buildVersionsManager.getVersion(urlInfo),
+                };
+                return;
+              }
               const buildSpecifier = findKey(buildSpecifierMap, urlInfo.url);
+              const buildSpecifierVersioned =
+                buildVersionsManager.getBuildSpecifierVersioned(buildSpecifier);
               serviceWorkerResources[buildSpecifier] = {
                 version: buildVersionsManager.getVersion(urlInfo),
+                versionedUrl: buildSpecifierVersioned,
               };
-              return;
-            }
-            const buildSpecifier = findKey(buildSpecifierMap, urlInfo.url);
-            const buildSpecifierVersioned =
-              buildVersionsManager.getBuildSpecifierVersioned(buildSpecifier);
-            serviceWorkerResources[buildSpecifier] = {
-              version: buildVersionsManager.getVersion(urlInfo),
-              versionedUrl: buildSpecifierVersioned,
-            };
-          });
+            },
+          );
           for (const serviceWorkerEntryUrlInfo of serviceWorkerEntryUrlInfos) {
             const serviceWorkerResourcesWithoutSwScriptItSelf = {
               ...serviceWorkerResources,
@@ -1302,48 +1287,48 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
       const buildRelativeUrl = urlToRelativeUrl(url, buildDirectoryUrl);
       return buildRelativeUrl;
     };
-    GRAPH_VISITOR.forEach(finalKitchen.graph, (urlInfo) => {
-      if (urlInfo.isRoot) {
-        return;
-      }
-      if (!urlInfo.url.startsWith("file:")) {
-        return;
-      }
-      if (urlInfo.type === "directory") {
-        return;
-      }
-      if (urlInfo.isInline) {
-        const buildRelativeUrl = getBuildRelativeUrl(urlInfo.url);
-        buildContents[buildRelativeUrl] = urlInfo.content;
-        buildInlineRelativeUrls.push(buildRelativeUrl);
-      } else {
-        const buildRelativeUrl = getBuildRelativeUrl(urlInfo.url);
-        if (
-          buildVersionsManager.getVersion(urlInfo) &&
-          canUseVersionedUrl(urlInfo)
-        ) {
-          const buildSpecifier = findKey(buildSpecifierMap, urlInfo.url);
-          const buildSpecifierVersioned =
-            buildVersionsManager.getBuildSpecifierVersioned(buildSpecifier);
-          const buildUrlVersioned = asBuildUrlVersioned({
-            buildSpecifierVersioned,
-            buildDirectoryUrl,
-          });
-          const buildRelativeUrlVersioned = urlToRelativeUrl(
-            buildUrlVersioned,
-            buildDirectoryUrl,
-          );
-          if (versioningMethod === "search_param") {
-            buildContents[buildRelativeUrl] = urlInfo.content;
+    GRAPH_VISITOR.forEachUrlInfoStronglyReferenced(
+      finalKitchen.graph.rootUrlInfo,
+      (urlInfo) => {
+        if (!urlInfo.url.startsWith("file:")) {
+          return;
+        }
+        if (urlInfo.type === "directory") {
+          return;
+        }
+        if (urlInfo.isInline) {
+          const buildRelativeUrl = getBuildRelativeUrl(urlInfo.url);
+          buildContents[buildRelativeUrl] = urlInfo.content;
+          buildInlineRelativeUrls.push(buildRelativeUrl);
+        } else {
+          const buildRelativeUrl = getBuildRelativeUrl(urlInfo.url);
+          if (
+            buildVersionsManager.getVersion(urlInfo) &&
+            canUseVersionedUrl(urlInfo)
+          ) {
+            const buildSpecifier = findKey(buildSpecifierMap, urlInfo.url);
+            const buildSpecifierVersioned =
+              buildVersionsManager.getBuildSpecifierVersioned(buildSpecifier);
+            const buildUrlVersioned = asBuildUrlVersioned({
+              buildSpecifierVersioned,
+              buildDirectoryUrl,
+            });
+            const buildRelativeUrlVersioned = urlToRelativeUrl(
+              buildUrlVersioned,
+              buildDirectoryUrl,
+            );
+            if (versioningMethod === "search_param") {
+              buildContents[buildRelativeUrl] = urlInfo.content;
+            } else {
+              buildContents[buildRelativeUrlVersioned] = urlInfo.content;
+            }
+            buildManifest[buildRelativeUrl] = buildRelativeUrlVersioned;
           } else {
-            buildContents[buildRelativeUrlVersioned] = urlInfo.content;
+            buildContents[buildRelativeUrl] = urlInfo.content;
           }
-          buildManifest[buildRelativeUrl] = buildRelativeUrlVersioned;
-        } else {
-          buildContents[buildRelativeUrl] = urlInfo.content;
         }
-      }
-    });
+      },
+    );
     const buildFileContents = {};
     const buildInlineContents = {};
     Object.keys(buildContents)
@@ -1378,7 +1363,9 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
       writingFiles.done();
     }
     logger.info(
-      createUrlGraphSummary(finalKitchen.graph, { title: "build files" }),
+      createUrlGraphSummary(finalKitchen.graph, {
+        title: "build files",
+      }),
     );
     return {
       buildFileContents,

package/src/build/build_versions_manager.js

@@ -213,63 +213,60 @@ export const createBuildVersionsManager = ({
 
       const contentOnlyVersionMap = new Map();
       generate_content_only_versions: {
-        GRAPH_VISITOR.forEach(finalKitchen.graph, (urlInfo) => {
-          // ignore:
-          // - inline files and data files:
-          //   they are already taken into account in the file where they appear
-          // - ignored files:
-          //   we don't know their content
-          // - unused files without reference
-          //   File updated such as style.css -> style.css.js or file.js->file.nomodule.js
-          //   Are used at some point just to be discarded later because they need to be converted
-          //   There is no need to version them and we could not because the file have been ignored
-          //   so their content is unknown
-          if (urlInfo.isRoot) {
-            return;
-          }
-          if (urlInfo.type === "sourcemap") {
-            return;
-          }
-          if (urlInfo.isInline) {
-            return;
-          }
-          if (urlInfo.url.startsWith("data:")) {
-            // urlInfo became inline and is not referenced by something else
-            return;
-          }
-          if (urlInfo.url.startsWith("ignore:")) {
-            return;
-          }
-          if (!urlInfo.isUsed()) {
-            return;
-          }
-          let content = urlInfo.content;
-          if (urlInfo.type === "html") {
-            content = stringifyHtmlAst(
-              parseHtmlString(urlInfo.content, {
-                storeOriginalPositions: false,
-              }),
-              {
-                cleanupJsenvAttributes: true,
-                cleanupPositionAttributes: true,
-              },
-            );
-          }
-          if (
-            CONTENT_TYPE.isTextual(urlInfo.contentType) &&
-            urlInfo.referenceToOthersSet.size > 0
-          ) {
-            const containedPlaceholders = new Set();
-            const contentWithPredictibleVersionPlaceholders =
-              replaceWithDefaultAndPopulateContainedPlaceholders(
-                content,
-                containedPlaceholders,
+        GRAPH_VISITOR.forEachUrlInfoStronglyReferenced(
+          finalKitchen.graph.rootUrlInfo,
+          (urlInfo) => {
+            // ignore:
+            // - inline files and data files:
+            //   they are already taken into account in the file where they appear
+            // - ignored files:
+            //   we don't know their content
+            // - unused files without reference
+            //   File updated such as style.css -> style.css.js or file.js->file.nomodule.js
+            //   Are used at some point just to be discarded later because they need to be converted
+            //   There is no need to version them and we could not because the file have been ignored
+            //   so their content is unknown
+            if (urlInfo.type === "sourcemap") {
+              return;
+            }
+            if (urlInfo.isInline) {
+              return;
+            }
+            if (urlInfo.url.startsWith("data:")) {
+              // urlInfo became inline and is not referenced by something else
+              return;
+            }
+            if (urlInfo.url.startsWith("ignore:")) {
+              return;
+            }
+            let content = urlInfo.content;
+            if (urlInfo.type === "html") {
+              content = stringifyHtmlAst(
+                parseHtmlString(urlInfo.content, {
+                  storeOriginalPositions: false,
+                }),
+                {
+                  cleanupJsenvAttributes: true,
+                  cleanupPositionAttributes: true,
+                },
               );
-            content = contentWithPredictibleVersionPlaceholders;
-          }
-          const contentVersion = generateVersion([content], versionLength);
-          contentOnlyVersionMap.set(urlInfo, contentVersion);
-        });
+            }
+            if (
+              CONTENT_TYPE.isTextual(urlInfo.contentType) &&
+              urlInfo.referenceToOthersSet.size > 0
+            ) {
+              const containedPlaceholders = new Set();
+              const contentWithPredictibleVersionPlaceholders =
+                replaceWithDefaultAndPopulateContainedPlaceholders(
+                  content,
+                  containedPlaceholders,
+                );
+              content = contentWithPredictibleVersionPlaceholders;
+            }
+            const contentVersion = generateVersion([content], versionLength);
+            contentOnlyVersionMap.set(urlInfo, contentVersion);
+          },
+        );
       }
 
       generate_versions: {