@jsenv/core 36.3.1 → 37.0.1

package/src/plugins/server_events/jsenv_plugin_server_events_client_injection.js

@@ -3,45 +3,29 @@
  * to provide "serverEvents" used by other plugins
  */
 
-import {
-  parseHtmlString,
-  stringifyHtmlAst,
-  injectHtmlNodeAsEarlyAsPossible,
-  createHtmlNode,
-} from "@jsenv/ast";
-
 const serverEventsClientFileUrl = new URL(
   "./client/server_events_client.js",
   import.meta.url,
 ).href;
 
-export const jsenvPluginServerEventsClientInjection = () => {
+export const jsenvPluginServerEventsClientInjection = ({ logs = true }) => {
   return {
     name: "jsenv:server_events_client_injection",
     appliesDuring: "*",
     transformUrlContent: {
-      html: (htmlUrlInfo, context) => {
-        const htmlAst = parseHtmlString(htmlUrlInfo.content);
-        const [serverEventsClientFileReference] = context.referenceUtils.inject(
-          {
-            type: "script",
-            subtype: "js_module",
-            expectedType: "js_module",
-            specifier: serverEventsClientFileUrl,
-          },
-        );
-        injectHtmlNodeAsEarlyAsPossible(
-          htmlAst,
-          createHtmlNode({
-            tagName: "script",
-            type: "module",
-            src: serverEventsClientFileReference.generatedSpecifier,
-          }),
-          "jsenv:server_events",
-        );
-        const htmlModified = stringifyHtmlAst(htmlAst);
+      html: () => {
         return {
-          content: htmlModified,
+          scriptInjections: [
+            {
+              src: serverEventsClientFileUrl,
+              setup: {
+                name: "window.__server_events__.setup",
+                param: {
+                  logs,
+                },
+              },
+            },
+          ],
         };
       },
     },

package/src/plugins/version_search_param/jsenv_plugin_version_search_param.js

@@ -5,7 +5,7 @@ export const jsenvPluginVersionSearchParam = () => {
     redirectReference: (reference) => {
       // "v" search param goal is to enable long-term cache
       // for server response headers
-      // it is also used by hmr to bypass browser cache
+      // it is also used by hot to bypass browser cache
       // this goal is achieved when we reach this part of the code
       // We get rid of this params so that urlGraph and other parts of the code
       // recognize the url (it is not considered as a different url)

package/src/build/version_generator.js

@@ -1,19 +0,0 @@
-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");
-
-  return {
-    augmentWithContent: (content) => {
-      hash.update(content);
-    },
-    augment: (value) => {
-      hash.update(value);
-    },
-    generate: () => {
-      return hash.digest("hex").slice(0, 8);
-    },
-  };
-};

package/src/kitchen/url_graph/url_graph_loader.js

@@ -1,77 +0,0 @@
-export const createUrlGraphLoader = (context) => {
-  const promises = [];
-  const promiseMap = new Map();
-  const load = (
-    urlInfo,
-    dishContext,
-    { ignoreRessourceHint = true, ignoreDynamicImport = false } = {},
-  ) => {
-    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;
-  };
-
-  const loadReferencedUrlInfos = (
-    urlInfo,
-    { ignoreRessourceHint, ignoreDynamicImport },
-  ) => {
-    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;
-      }
-      if (ignoreDynamicImport && reference.subtype === "import_dynamic") {
-        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();
-      }
-      if (promises.length === 0) {
-        return;
-      }
-      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.js

@@ -1,322 +0,0 @@
-import { urlToRelativeUrl } from "@jsenv/urls";
-
-import { urlSpecifierEncoding } from "./url_specifier_encoding.js";
-
-export const createUrlGraph = ({ name = "anonymous" } = {}) => {
-  const createUrlInfoCallbackRef = { current: () => {} };
-  const prunedUrlInfosCallbackRef = { current: () => {} };
-
-  const urlInfoMap = new Map();
-  const getUrlInfo = (url) => urlInfoMap.get(url);
-  const deleteUrlInfo = (url) => {
-    const urlInfo = urlInfoMap.get(url);
-    if (urlInfo) {
-      urlInfoMap.delete(url);
-      urlInfo.dependencies.forEach((dependencyUrl) => {
-        getUrlInfo(dependencyUrl).dependents.delete(url);
-      });
-      if (urlInfo.sourcemapReference) {
-        deleteUrlInfo(urlInfo.sourcemapReference.url);
-      }
-    }
-  };
-  const reuseOrCreateUrlInfo = (url) => {
-    const existingUrlInfo = getUrlInfo(url);
-    if (existingUrlInfo) return existingUrlInfo;
-    const urlInfo = createUrlInfo(url);
-    urlInfoMap.set(url, urlInfo);
-    createUrlInfoCallbackRef.current(urlInfo);
-    return urlInfo;
-  };
-  const getParentIfInline = (urlInfo) => {
-    return urlInfo.isInline ? getUrlInfo(urlInfo.inlineUrlSite.url) : urlInfo;
-  };
-
-  const inferReference = (specifier, parentUrl) => {
-    const parentUrlInfo = getUrlInfo(parentUrl);
-    if (!parentUrlInfo) {
-      return null;
-    }
-    const seen = [];
-    const search = (urlInfo) => {
-      const firstReferenceFound = urlInfo.references.find((reference) => {
-        return urlSpecifierEncoding.decode(reference) === specifier;
-      });
-      if (firstReferenceFound) {
-        return firstReferenceFound;
-      }
-      for (const dependencyUrl of parentUrlInfo.dependencies) {
-        if (seen.includes(dependencyUrl)) {
-          continue;
-        }
-        seen.push(dependencyUrl);
-        const dependencyUrlInfo = getUrlInfo(dependencyUrl);
-        if (dependencyUrlInfo.isInline) {
-          const firstRef = search(dependencyUrlInfo);
-          if (firstRef) {
-            return firstRef;
-          }
-        }
-      }
-      return null;
-    };
-    return search(parentUrlInfo);
-  };
-
-  const updateReferences = (urlInfo, references) => {
-    const setOfDependencyUrls = new Set();
-    const setOfImplicitUrls = new Set();
-    references.forEach((reference) => {
-      if (reference.isResourceHint) {
-        // resource hint are a special kind of reference.
-        // They are a sort of weak reference to an url.
-        // We ignore them so that url referenced only by resource hints
-        // have url.dependents.size === 0 and can be considered as not used
-        // It means html won't consider url referenced solely
-        // by <link> as dependency and it's fine
-        return;
-      }
-      const dependencyUrl = reference.url;
-      setOfDependencyUrls.add(dependencyUrl);
-      // an implicit reference do not appear in the file but the non explicited file
-      // have an impact on it
-      // -> package.json on import resolution for instance
-      // in that case:
-      // - file depends on the implicit file (it must autoreload if package.json is modified)
-      // - cache validity for the file depends on the implicit file (it must be re-cooked if package.json is modified)
-      if (reference.isImplicit) {
-        setOfImplicitUrls.add(dependencyUrl);
-      }
-    });
-    setOfDependencyUrls.forEach((dependencyUrl) => {
-      urlInfo.dependencies.add(dependencyUrl);
-      const dependencyUrlInfo = reuseOrCreateUrlInfo(dependencyUrl);
-      dependencyUrlInfo.dependents.add(urlInfo.url);
-    });
-    setOfImplicitUrls.forEach((implicitUrl) => {
-      urlInfo.implicitUrls.add(implicitUrl);
-      if (urlInfo.isInline) {
-        const parentUrlInfo = getUrlInfo(urlInfo.inlineUrlSite.url);
-        parentUrlInfo.implicitUrls.add(implicitUrl);
-      }
-    });
-    const prunedUrlInfos = [];
-    const pruneDependency = (urlInfo, urlToClean) => {
-      urlInfo.dependencies.delete(urlToClean);
-      const dependencyUrlInfo = getUrlInfo(urlToClean);
-      if (!dependencyUrlInfo) {
-        return;
-      }
-      dependencyUrlInfo.dependents.delete(urlInfo.url);
-      if (dependencyUrlInfo.dependents.size === 0) {
-        dependencyUrlInfo.dependencies.forEach((dependencyUrl) => {
-          pruneDependency(dependencyUrlInfo, dependencyUrl);
-        });
-        prunedUrlInfos.push(dependencyUrlInfo);
-      }
-    };
-    urlInfo.dependencies.forEach((dependencyUrl) => {
-      if (!setOfDependencyUrls.has(dependencyUrl)) {
-        pruneDependency(urlInfo, dependencyUrl);
-      }
-    });
-    if (prunedUrlInfos.length) {
-      prunedUrlInfos.forEach((prunedUrlInfo) => {
-        prunedUrlInfo.modifiedTimestamp = Date.now();
-        if (prunedUrlInfo.isInline) {
-          // should we always delete?
-          deleteUrlInfo(prunedUrlInfo.url);
-        }
-      });
-      prunedUrlInfosCallbackRef.current(prunedUrlInfos, urlInfo);
-    }
-    urlInfo.implicitUrls.forEach((implicitUrl) => {
-      if (!setOfDependencyUrls.has(implicitUrl)) {
-        let implicitUrlComesFromInlineContent = false;
-        for (const dependencyUrl of urlInfo.dependencies) {
-          const dependencyUrlInfo = getUrlInfo(dependencyUrl);
-          if (
-            dependencyUrlInfo.isInline &&
-            dependencyUrlInfo.implicitUrls.has(implicitUrl)
-          ) {
-            implicitUrlComesFromInlineContent = true;
-            break;
-          }
-        }
-        if (!implicitUrlComesFromInlineContent) {
-          urlInfo.implicitUrls.delete(implicitUrl);
-        }
-        if (urlInfo.isInline) {
-          const parentUrlInfo = getUrlInfo(urlInfo.inlineUrlSite.url);
-          parentUrlInfo.implicitUrls.delete(implicitUrl);
-        }
-      }
-    });
-    urlInfo.references = references;
-    return urlInfo;
-  };
-
-  const considerModified = (urlInfo, modifiedTimestamp = Date.now()) => {
-    const seen = [];
-    const iterate = (urlInfo) => {
-      if (seen.includes(urlInfo.url)) {
-        return;
-      }
-      seen.push(urlInfo.url);
-      urlInfo.modifiedTimestamp = modifiedTimestamp;
-      urlInfo.originalContentEtag = undefined;
-      urlInfo.contentEtag = undefined;
-      urlInfo.dependents.forEach((dependentUrl) => {
-        const dependentUrlInfo = getUrlInfo(dependentUrl);
-        const { hotAcceptDependencies = [] } = dependentUrlInfo.data;
-        if (!hotAcceptDependencies.includes(urlInfo.url)) {
-          iterate(dependentUrlInfo);
-        }
-      });
-      urlInfo.dependencies.forEach((dependencyUrl) => {
-        const dependencyUrlInfo = getUrlInfo(dependencyUrl);
-        if (dependencyUrlInfo.isInline) {
-          iterate(dependencyUrlInfo);
-        }
-      });
-    };
-    iterate(urlInfo);
-  };
-
-  const getEntryPoints = () => {
-    const entryPoints = [];
-    urlInfoMap.forEach((urlInfo) => {
-      if (urlInfo.isEntryPoint) {
-        entryPoints.push(urlInfo);
-      }
-    });
-    return entryPoints;
-  };
-
-  const hasDependent = (urlInfo) => {
-    for (const dependentUrl of urlInfo.dependents) {
-      const dependentUrlInfo = getUrlInfo(dependentUrl);
-      for (const reference of dependentUrlInfo.references) {
-        if (reference.url === urlInfo.url) {
-          if (
-            !reference.isInline &&
-            reference.next &&
-            reference.next.isInline
-          ) {
-            // the url info was inlined, an other reference is required
-            // to consider the non-inlined urlInfo as used
-            continue;
-          }
-          return true;
-        }
-      }
-    }
-    return false;
-  };
-
-  const isUsed = (urlInfo) => {
-    // nothing uses this url anymore
-    // - versioning update inline content
-    // - file converted for import assertion or js_classic conversion
-    // - urlInfo for a file that is now inlined
-    if (urlInfo.isEntryPoint) {
-      return true;
-    }
-    // if (urlInfo.type === "sourcemap") {
-    //   return true;
-    // }
-    // check if there is a valid reference to this urlInfo
-    if (hasDependent(urlInfo)) {
-      return true;
-    }
-    return false;
-  };
-
-  return {
-    name,
-    createUrlInfoCallbackRef,
-    prunedUrlInfosCallbackRef,
-
-    urlInfoMap,
-    reuseOrCreateUrlInfo,
-    getUrlInfo,
-    deleteUrlInfo,
-    getParentIfInline,
-    getEntryPoints,
-    hasDependent,
-    isUsed,
-
-    inferReference,
-    updateReferences,
-    considerModified,
-
-    toObject: () => {
-      const data = {};
-      urlInfoMap.forEach((urlInfo) => {
-        data[urlInfo.url] = urlInfo;
-      });
-      return data;
-    },
-    toJSON: (rootDirectoryUrl) => {
-      const data = {};
-      urlInfoMap.forEach((urlInfo) => {
-        const dependencyUrls = Array.from(urlInfo.dependencies);
-        if (dependencyUrls.length) {
-          const relativeUrl = urlToRelativeUrl(urlInfo.url, rootDirectoryUrl);
-          data[relativeUrl] = dependencyUrls.map((dependencyUrl) =>
-            urlToRelativeUrl(dependencyUrl, rootDirectoryUrl),
-          );
-        }
-      });
-      return data;
-    },
-  };
-};
-
-const createUrlInfo = (url) => {
-  const urlInfo = {
-    error: null,
-    modifiedTimestamp: 0,
-    originalContentEtag: null,
-    contentEtag: null,
-    isWatched: false,
-    isValid: () => false,
-    data: {}, // plugins can put whatever they want here
-    references: [],
-    dependencies: new Set(),
-    dependents: new Set(),
-    implicitUrls: new Set(),
-    type: undefined, // "html", "css", "js_classic", "js_module", "importmap", "sourcemap", "json", "webmanifest", ...
-    subtype: undefined, // "worker", "service_worker", "shared_worker" for js, otherwise undefined
-    typeHint: undefined,
-    subtypeHint: undefined,
-    contentType: "", // "text/html", "text/css", "text/javascript", "application/json", ...
-    url,
-    originalUrl: undefined,
-    filename: "",
-    isEntryPoint: false,
-    originalContent: undefined,
-    originalContentAst: undefined,
-    content: undefined,
-    contentAst: undefined,
-    contentFinalized: false,
-
-    sourcemap: null,
-    sourcemapReference: null,
-    sourcemapIsWrong: false,
-
-    generatedUrl: null,
-    sourcemapGeneratedUrl: null,
-    injected: false,
-
-    isInline: false,
-    inlineUrlSite: null,
-    jsQuote: null, // maybe move to inlineUrlSite?
-
-    timing: {},
-    headers: {},
-    debug: false,
-  };
-  // Object.preventExtensions(urlInfo) // useful to ensure all properties are declared here
-  return urlInfo;
-};

package/src/plugins/autoreload/jsenv_plugin_hmr.js

@@ -1,42 +0,0 @@
-export const jsenvPluginHmr = () => {
-  return {
-    name: "jsenv:hmr",
-    appliesDuring: "dev",
-    redirectReference: (reference) => {
-      if (!reference.searchParams.has("hmr")) {
-        reference.data.hmr = false;
-        return null;
-      }
-      reference.data.hmr = true;
-      const urlObject = new URL(reference.url);
-      // "hmr" search param goal is to mark url as enabling hmr:
-      // this goal is achieved when we reach this part of the code
-      // We get rid of this params so that urlGraph and other parts of the code
-      // recognize the url (it is not considered as a different url)
-      urlObject.searchParams.delete("hmr");
-      urlObject.searchParams.delete("v");
-      return urlObject.href;
-    },
-    transformReferenceSearchParams: (reference, context) => {
-      if (reference.isImplicit) {
-        return null;
-      }
-      if (context.reference && !context.reference.data.hmr) {
-        // parent do not use hmr search param
-        return null;
-      }
-      if (!context.reference && !reference.data.hmr) {
-        // entry point do not use hmr search param
-        return null;
-      }
-      const urlInfo = context.urlGraph.getUrlInfo(reference.url);
-      if (!urlInfo.modifiedTimestamp) {
-        return null;
-      }
-      return {
-        hmr: "",
-        v: urlInfo.modifiedTimestamp,
-      };
-    },
-  };
-};

package/src/plugins/resolution_node_esm/url_type_from_reference.js

@@ -1,13 +0,0 @@
-export const urlTypeFromReference = (reference, context) => {
-  if (reference.type === "sourcemap_comment") {
-    return "sourcemap";
-  }
-  if (reference.injected) {
-    return reference.expectedType;
-  }
-  const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl);
-  if (parentUrlInfo) {
-    return parentUrlInfo.type;
-  }
-  return "entry_point";
-};