@jsenv/core 37.0.4 → 37.1.0

package/src/dev/file_service.js

@@ -6,6 +6,7 @@ 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";
+import { createEventEmitter } from "../helpers/event_emitter.js";
 import { createKitchen } from "../kitchen/kitchen.js";
 import { getCorePlugins } from "../plugins/plugins.js";
 import { jsenvPluginServerEventsClientInjection } from "../plugins/server_events/jsenv_plugin_server_events_client_injection.js";
@@ -17,6 +18,7 @@ export const createFileService = ({
   serverStopCallbacks,
   serverEventsDispatcher,
   kitchenCache,
+  onKitchenCreated = () => {},
 
   sourceDirectoryUrl,
   sourceMainFilePath,
@@ -32,8 +34,6 @@ export const createFileService = ({
   supervisor,
   transpilation,
   clientAutoreload,
-  cooldownBetweenFileEvents,
-  clientServerEventsConfig,
   cacheControl,
   ribbon,
   sourcemaps,
@@ -41,19 +41,32 @@ export const createFileService = ({
   sourcemapsSourcesContent,
   outDirectoryUrl,
 }) => {
-  const clientFileChangeCallbackList = [];
-  const clientFilesPruneCallbackList = [];
+  if (clientAutoreload === true) {
+    clientAutoreload = {};
+  }
+  if (clientAutoreload === false) {
+    clientAutoreload = { enabled: false };
+  }
+  const clientFileChangeEventEmitter = createEventEmitter();
+  const clientFileDereferencedEventEmitter = createEventEmitter();
+
+  clientAutoreload = {
+    enabled: true,
+    clientServerEventsConfig: {},
+    clientFileChangeEventEmitter,
+    clientFileDereferencedEventEmitter,
+    ...clientAutoreload,
+  };
+
   const stopWatchingSourceFiles = watchSourceFiles(
     sourceDirectoryUrl,
     (fileInfo) => {
-      clientFileChangeCallbackList.forEach((callback) => {
-        callback(fileInfo);
-      });
+      clientFileChangeEventEmitter.emit(fileInfo);
     },
     {
       sourceFilesConfig,
       keepProcessAlive: false,
-      cooldownBetweenFileEvents,
+      cooldownBetweenFileEvents: clientAutoreload.cooldownBetweenFileEvents,
     },
   );
   serverStopCallbacks.push(stopWatchingSourceFiles);
@@ -72,10 +85,10 @@ export const createFileService = ({
       sourceDirectoryUrl,
     );
     let kitchen;
-    clientFileChangeCallbackList.push(({ url }) => {
+    clientFileChangeEventEmitter.on(({ url }) => {
       const urlInfo = kitchen.graph.getUrlInfo(url);
       if (urlInfo) {
-        urlInfo.considerModified();
+        urlInfo.onModified();
       }
     });
     const clientRuntimeCompat = { [runtimeName]: runtimeVersion };
@@ -111,8 +124,6 @@ export const createFileService = ({
           transpilation,
 
           clientAutoreload,
-          clientFileChangeCallbackList,
-          clientFilesPruneCallbackList,
           cacheControl,
           ribbon,
         }),
@@ -126,18 +137,18 @@ export const createFileService = ({
         ? new URL(`${runtimeName}@${runtimeVersion}/`, outDirectoryUrl)
         : undefined,
     });
-    kitchen.graph.createUrlInfoCallbackRef.current = (urlInfo) => {
+    kitchen.graph.urlInfoCreatedEventEmitter.on((urlInfoCreated) => {
       const { watch } = URL_META.applyAssociations({
-        url: urlInfo.url,
+        url: urlInfoCreated.url,
         associations: watchAssociations,
       });
-      urlInfo.isWatched = watch;
+      urlInfoCreated.isWatched = watch;
       // wehn an url depends on many others, we check all these (like package.json)
-      urlInfo.isValid = () => {
-        if (!urlInfo.url.startsWith("file:")) {
+      urlInfoCreated.isValid = () => {
+        if (!urlInfoCreated.url.startsWith("file:")) {
           return false;
         }
-        if (urlInfo.content === undefined) {
+        if (urlInfoCreated.content === undefined) {
           // urlInfo content is undefined when:
           // - url info content never fetched
           // - it is considered as modified because undelying file is watched and got saved
@@ -149,21 +160,20 @@ export const createFileService = ({
           // file is not watched, check the filesystem
           let fileContentAsBuffer;
           try {
-            fileContentAsBuffer = readFileSync(new URL(urlInfo.url));
+            fileContentAsBuffer = readFileSync(new URL(urlInfoCreated.url));
           } catch (e) {
             if (e.code === "ENOENT") {
-              urlInfo.considerModified();
-              urlInfo.deleteFromGraph();
+              urlInfoCreated.onModified();
               return false;
             }
             return false;
           }
           const fileContentEtag = bufferToEtag(fileContentAsBuffer);
-          if (fileContentEtag !== urlInfo.originalContentEtag) {
-            urlInfo.considerModified();
+          if (fileContentEtag !== urlInfoCreated.originalContentEtag) {
+            urlInfoCreated.onModified();
             // restore content to be able to compare it again later
-            urlInfo.kitchen.urlInfoTransformer.setContent(
-              urlInfo,
+            urlInfoCreated.kitchen.urlInfoTransformer.setContent(
+              urlInfoCreated,
               String(fileContentAsBuffer),
               {
                 contentEtag: fileContentEtag,
@@ -172,23 +182,24 @@ export const createFileService = ({
             return false;
           }
         }
-        for (const implicitUrl of urlInfo.implicitUrlSet) {
-          const implicitUrlInfo = kitchen.graph.getUrlInfo(implicitUrl);
+        for (const implicitUrl of urlInfoCreated.implicitUrlSet) {
+          const implicitUrlInfo = urlInfoCreated.graph.getUrlInfo(implicitUrl);
           if (implicitUrlInfo && !implicitUrlInfo.isValid()) {
             return false;
           }
         }
         return true;
       };
-    };
-    kitchen.graph.pruneUrlInfoCallbackRef.current = (
-      prunedUrlInfo,
-      lastReferenceFromOther,
-    ) => {
-      clientFilesPruneCallbackList.forEach((callback) => {
-        callback(prunedUrlInfo, lastReferenceFromOther);
-      });
-    };
+    });
+    kitchen.graph.urlInfoDereferencedEventEmitter.on(
+      (urlInfoDereferenced, lastReferenceFromOther) => {
+        clientFileDereferencedEventEmitter.emit(
+          urlInfoDereferenced,
+          lastReferenceFromOther,
+        );
+      },
+    );
+
     serverStopCallbacks.push(() => {
       kitchen.pluginController.callHooks("destroy", kitchen.context);
     });
@@ -221,12 +232,15 @@ export const createFileService = ({
         });
         // "pushPlugin" so that event source client connection can be put as early as possible in html
         kitchen.pluginController.pushPlugin(
-          jsenvPluginServerEventsClientInjection(clientServerEventsConfig),
+          jsenvPluginServerEventsClientInjection(
+            clientAutoreload.clientServerEventsConfig,
+          ),
         );
       }
     }
 
     kitchenCache.set(runtimeId, kitchen);
+    onKitchenCreated(kitchen);
     return kitchen;
   };
 
@@ -244,35 +258,28 @@ export const createFileService = ({
     if (responseFromPlugin) {
       return responseFromPlugin;
     }
-    let reference;
-    const parentUrl = inferParentFromRequest(
-      request,
-      sourceDirectoryUrl,
-      sourceMainFilePath,
-    );
-    if (parentUrl) {
-      reference = kitchen.graph.inferReference(request.resource, parentUrl);
-    }
+    const { referer } = request.headers;
+    const parentUrl = referer
+      ? WEB_URL_CONVERTER.asFileUrl(referer, {
+          origin: request.origin,
+          rootDirectoryUrl: sourceDirectoryUrl,
+        })
+      : sourceDirectoryUrl;
+    let reference = kitchen.graph.inferReference(request.resource, parentUrl);
     if (!reference) {
-      let parentUrlInfo;
-      if (parentUrl) {
-        parentUrlInfo = kitchen.graph.getUrlInfo(parentUrl);
-      }
-      if (!parentUrlInfo) {
-        parentUrlInfo = kitchen.graph.rootUrlInfo;
-      }
-      reference = parentUrlInfo.dependencies.createResolveAndFinalize({
-        trace: { message: parentUrl || sourceDirectoryUrl },
-        type: "http_request",
-        specifier: request.resource,
-      });
+      reference =
+        kitchen.graph.rootUrlInfo.dependencies.createResolveAndFinalize({
+          trace: { message: parentUrl },
+          type: "http_request",
+          specifier: request.resource,
+        });
     }
     const urlInfo = reference.urlInfo;
     const ifNoneMatch = request.headers["if-none-match"];
     const urlInfoTargetedByCache = urlInfo.findParentIfInline() || urlInfo;
 
     try {
-      if (ifNoneMatch) {
+      if (!urlInfo.error && ifNoneMatch) {
         const [clientOriginalContentEtag, clientContentEtag] =
           ifNoneMatch.split("_");
         if (
@@ -320,7 +327,7 @@ export const createFileService = ({
               }),
           ...urlInfo.headers,
           "content-type": urlInfo.contentType,
-          "content-length": Buffer.byteLength(urlInfo.content),
+          "content-length": urlInfo.contentLength,
         },
         body: urlInfo.content,
         timing: urlInfo.timing,
@@ -359,7 +366,7 @@ export const createFileService = ({
             statusMessage: originalError.message,
             headers: {
               "content-type": urlInfo.contentType,
-              "content-length": Buffer.byteLength(urlInfo.content),
+              "content-length": urlInfo.contentLength,
               "cache-control": "no-store",
             },
             body: urlInfo.content,
@@ -406,34 +413,6 @@ export const createFileService = ({
         statusText: e.reason,
         statusMessage: e.stack,
       };
-    } finally {
-      // remove http_request when there is other references keeping url info alive
-      if (
-        reference.type === "http_request" &&
-        reference.urlInfo.referenceFromOthersSet.size > 1
-      ) {
-        reference.remove();
-      }
     }
   };
 };
-
-const inferParentFromRequest = (
-  request,
-  sourceDirectoryUrl,
-  sourceMainFilePath,
-) => {
-  const { referer } = request.headers;
-  if (!referer) {
-    return null;
-  }
-  const refererUrlObject = new URL(referer);
-  const refererUrl =
-    refererUrlObject.pathname === `/`
-      ? new URL(sourceMainFilePath, request.origin).href
-      : referer;
-  return WEB_URL_CONVERTER.asFileUrl(refererUrl, {
-    origin: request.origin,
-    rootDirectoryUrl: sourceDirectoryUrl,
-  });
-};

package/src/dev/start_dev_server.js

@@ -44,8 +44,6 @@ export const startDevServer = async ({
 
   sourceFilesConfig,
   clientAutoreload = true,
-  cooldownBetweenFileEvents,
-  clientServerEventsConfig = {},
 
   // runtimeCompat is the runtimeCompat for the build
   // when specified, dev server use it to warn in case
@@ -61,6 +59,7 @@ export const startDevServer = async ({
   cacheControl = true,
   ribbon = true,
   // toolbar = false,
+  onKitchenCreated = () => {},
 
   sourcemaps = "inline",
   sourcemapsSourcesProtocol,
@@ -185,6 +184,7 @@ export const startDevServer = async ({
           serverStopCallbacks,
           serverEventsDispatcher,
           kitchenCache,
+          onKitchenCreated,
 
           sourceDirectoryUrl,
           sourceMainFilePath,
@@ -200,8 +200,6 @@ export const startDevServer = async ({
           supervisor,
           transpilation,
           clientAutoreload,
-          cooldownBetweenFileEvents,
-          clientServerEventsConfig,
           cacheControl,
           ribbon,
           sourcemaps,

package/src/helpers/event_emitter.js

@@ -0,0 +1,18 @@
+export const createEventEmitter = () => {
+  const callbackSet = new Set();
+  const on = (callback) => {
+    callbackSet.add(callback);
+    return () => {
+      callbackSet.delete(callback);
+    };
+  };
+  const off = (callback) => {
+    callbackSet.delete(callback);
+  };
+  const emit = (...args) => {
+    callbackSet.forEach((callback) => {
+      callback(...args);
+    });
+  };
+  return { on, off, emit };
+};

package/src/kitchen/kitchen.js

@@ -484,12 +484,10 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
     // "cooked" hook
     pluginController.callHooks("cooked", urlInfo, (cookedReturnValue) => {
       if (typeof cookedReturnValue === "function") {
-        const prevCallback = graph.pruneUrlInfoCallbackRef.current;
-        graph.pruneUrlInfoCallbackRef.current(
-          (prunedUrlInfo, lastReferenceFromOther) => {
-            prevCallback();
-            if (prunedUrlInfo === urlInfo.url) {
-              graph.pruneUrlInfoCallbackRef.current = prevCallback;
+        const removeCallback = urlInfo.graph.urlInfoDereferencedEventEmitter.on(
+          (urlInfoDereferenced, lastReferenceFromOther) => {
+            if (urlInfoDereferenced === urlInfo) {
+              removeCallback();
               cookedReturnValue(lastReferenceFromOther.urlInfo);
             }
           },

package/src/kitchen/url_graph/references.js

@@ -463,6 +463,10 @@ const createReference = ({
     return implicitReference;
   };
 
+  reference.gotInlined = () => {
+    return !reference.isInline && reference.next && reference.next.isInline;
+  };
+
   reference.remove = () => removeDependency(reference);
 
   // Object.preventExtensions(reference) // useful to ensure all properties are declared here
@@ -557,7 +561,6 @@ const canAddOrRemoveReference = (reference) => {
 const applyDependencyRemovalEffects = (reference) => {
   const { ownerUrlInfo } = reference;
   const { referenceToOthersSet } = ownerUrlInfo;
-
   if (reference.isImplicit && !reference.isInline) {
     let hasAnOtherImplicitRef = false;
     for (const referenceToOther of referenceToOthersSet) {
@@ -589,8 +592,29 @@ const applyDependencyRemovalEffects = (reference) => {
   const referencedUrlInfo = reference.urlInfo;
   referencedUrlInfo.referenceFromOthersSet.delete(reference);
 
-  const firstReferenceFromOther =
-    referencedUrlInfo.getFirstReferenceFromOther();
+  let firstReferenceFromOther;
+  for (const referenceFromOther of referencedUrlInfo.referenceFromOthersSet) {
+    if (referenceFromOther.urlInfo !== referencedUrlInfo) {
+      continue;
+    }
+    // Here we want to know if the file is referenced by an other file.
+    // So we want to ignore reference that are created by other means:
+    // - "http_request"
+    //   This type of reference is created when client request a file
+    //   that we don't know yet
+    //   1. reference(s) to this file are not yet discovered
+    //   2. there is no reference to this file
+    if (referenceFromOther.type === "http_request") {
+      continue;
+    }
+    if (referenceFromOther.gotInlined()) {
+      // the url info was inlined, an other reference is required
+      // to consider the non-inlined urlInfo as used
+      continue;
+    }
+    firstReferenceFromOther = referenceFromOther;
+    break;
+  }
   if (firstReferenceFromOther) {
     // either applying new ref should override old ref
     // or we should first remove effects before adding new ones
@@ -601,11 +625,8 @@ const applyDependencyRemovalEffects = (reference) => {
     }
     return false;
   }
-  if (reference.type !== "http_request") {
-    referencedUrlInfo.deleteFromGraph(reference);
-    return true;
-  }
-  return false;
+  referencedUrlInfo.onDereferenced(reference);
+  return true;
 };
 
 const traceFromUrlSite = (urlSite) => {

package/src/kitchen/url_graph/url_content.js

@@ -25,6 +25,15 @@ export const defineGettersOnPropertiesDerivedFromOriginalContent = (
 };
 
 export const defineGettersOnPropertiesDerivedFromContent = (urlInfo) => {
+  const contentLengthDescriptor = Object.getOwnPropertyDescriptor(
+    urlInfo,
+    "contentLength",
+  );
+  if (contentLengthDescriptor.value === undefined) {
+    defineVolatileGetter(urlInfo, "contentLength", () => {
+      return Buffer.byteLength(urlInfo.content);
+    });
+  }
   const contentAstDescriptor = Object.getOwnPropertyDescriptor(
     urlInfo,
     "contentAst",

package/src/kitchen/url_graph/url_graph.js

@@ -4,6 +4,7 @@ import {
   injectQueryParamsIntoSpecifier,
 } from "@jsenv/urls";
 
+import { createEventEmitter } from "../../helpers/event_emitter.js";
 import { urlSpecifierEncoding } from "./url_specifier_encoding.js";
 import { createDependencies } from "./references.js";
 
@@ -13,8 +14,8 @@ export const createUrlGraph = ({
   name = "anonymous",
 }) => {
   const urlGraph = {};
-  const createUrlInfoCallbackRef = { current: () => {} };
-  const pruneUrlInfoCallbackRef = { current: () => {} };
+  const urlInfoCreatedEventEmitter = createEventEmitter();
+  const urlInfoDereferencedEventEmitter = createEventEmitter();
 
   const urlInfoMap = new Map();
   const hasUrlInfo = (key) => {
@@ -35,27 +36,7 @@ export const createUrlGraph = ({
     }
     return null;
   };
-  const deleteUrlInfo = (url, lastReferenceFromOther) => {
-    const urlInfo = urlInfoMap.get(url);
-    if (urlInfo) {
-      urlInfo.kitchen.urlInfoTransformer.resetContent(urlInfo);
-      urlInfoMap.delete(url);
-      urlInfo.modifiedTimestamp = Date.now();
-      if (lastReferenceFromOther && !urlInfo.isInline) {
-        pruneUrlInfoCallbackRef.current(urlInfo, lastReferenceFromOther);
-      }
-      urlInfo.referenceToOthersSet.forEach((referenceToOther) => {
-        referenceToOther.remove();
-      });
-      if (urlInfo.searchParams.size > 0) {
-        const urlWithoutSearch = asUrlWithoutSearch(urlInfo.url);
-        const urlInfoWithoutSearch = getUrlInfo(urlWithoutSearch);
-        if (urlInfoWithoutSearch) {
-          urlInfoWithoutSearch.searchParamVariantSet.delete(urlInfo);
-        }
-      }
-    }
-  };
+
   const addUrlInfo = (urlInfo) => {
     urlInfo.graph = urlGraph;
     urlInfo.kitchen = kitchen;
@@ -65,14 +46,15 @@ export const createUrlGraph = ({
     const referencedUrl = useGeneratedUrl
       ? reference.generatedUrl
       : reference.url;
-    const existingUrlInfo = getUrlInfo(referencedUrl);
-    if (existingUrlInfo) return existingUrlInfo;
-    const ownerUrlInfo = reference.ownerUrlInfo;
-    const ownerContext = ownerUrlInfo.context;
-    const context = Object.create(ownerContext);
-    const referencedUrlInfo = createUrlInfo(referencedUrl, context);
-    addUrlInfo(referencedUrlInfo);
-    createUrlInfoCallbackRef.current(referencedUrlInfo);
+    let referencedUrlInfo = getUrlInfo(referencedUrl);
+    if (!referencedUrlInfo) {
+      const ownerUrlInfo = reference.ownerUrlInfo;
+      const ownerContext = ownerUrlInfo.context;
+      const context = Object.create(ownerContext);
+      referencedUrlInfo = createUrlInfo(referencedUrl, context);
+      addUrlInfo(referencedUrlInfo);
+      urlInfoCreatedEventEmitter.emit(referencedUrlInfo);
+    }
     if (referencedUrlInfo.searchParams.size > 0 && !kitchen.context.shape) {
       // A resource is represented by a url.
       // Variations of a resource are represented by url search params
@@ -148,17 +130,16 @@ export const createUrlGraph = ({
   Object.assign(urlGraph, {
     name,
     rootUrlInfo,
-    createUrlInfoCallbackRef,
-    pruneUrlInfoCallbackRef,
 
     urlInfoMap,
     reuseOrCreateUrlInfo,
     hasUrlInfo,
     getUrlInfo,
-    deleteUrlInfo,
     getEntryPoints,
 
     inferReference,
+    urlInfoCreatedEventEmitter,
+    urlInfoDereferencedEventEmitter,
 
     toObject: () => {
       const data = {};
@@ -196,6 +177,7 @@ const createUrlInfo = (url, context) => {
     context,
     error: null,
     modifiedTimestamp: 0,
+    dereferencedTimestamp: 0,
     originalContentEtag: null,
     contentEtag: null,
     isWatched: false,
@@ -220,6 +202,7 @@ const createUrlInfo = (url, context) => {
     originalContentAst: undefined,
     content: undefined,
     contentAst: undefined,
+    contentLength: undefined,
     contentFinalized: false,
 
     sourcemap: null,
@@ -246,37 +229,24 @@ const createUrlInfo = (url, context) => {
   urlInfo.searchParams = new URL(url).searchParams;
 
   urlInfo.dependencies = createDependencies(urlInfo);
-  urlInfo.getFirstReferenceFromOther = ({ ignoreWeak } = {}) => {
-    for (const referenceFromOther of urlInfo.referenceFromOthersSet) {
-      if (referenceFromOther.url === urlInfo.url) {
-        if (
-          !referenceFromOther.isInline &&
-          referenceFromOther.next &&
-          referenceFromOther.next.isInline
-        ) {
-          // the url info was inlined, an other reference is required
-          // to consider the non-inlined urlInfo as used
-          continue;
-        }
-        if (ignoreWeak && referenceFromOther.isWeak) {
-          // weak reference don't count as using the url
-          continue;
-        }
-        return referenceFromOther;
-      }
-    }
-    return null;
-  };
   urlInfo.isUsed = () => {
     if (urlInfo.isRoot) {
       return true;
     }
-    // if (urlInfo.type === "sourcemap") {
-    //   return true;
-    // }
-    // check if there is a strong reference to this urlInfo
-    if (urlInfo.getFirstReferenceFromOther({ ignoreWeak: true })) {
-      return true;
+    for (const referenceFromOther of urlInfo.referenceFromOthersSet) {
+      if (referenceFromOther.urlInfo !== urlInfo) {
+        continue;
+      }
+      if (referenceFromOther.isWeak) {
+        // weak reference don't count as using the url
+        continue;
+      }
+      if (referenceFromOther.gotInlined()) {
+        // the url info was inlined, an other reference is required
+        // to consider the non-inlined urlInfo as used
+        continue;
+      }
+      return referenceFromOther.ownerUrlInfo.isUsed();
     }
     // nothing uses this url anymore
     // - versioning update inline content
@@ -366,7 +336,7 @@ const createUrlInfo = (url, context) => {
     reference.next = referenceWithoutSearchParam;
     return referenceWithoutSearchParam.urlInfo;
   };
-  urlInfo.considerModified = ({ modifiedTimestamp = Date.now() } = {}) => {
+  urlInfo.onModified = ({ modifiedTimestamp = Date.now() } = {}) => {
     const visitedSet = new Set();
     const iterate = (urlInfo) => {
       if (visitedSet.has(urlInfo)) {
@@ -387,9 +357,29 @@ const createUrlInfo = (url, context) => {
     };
     iterate(urlInfo);
   };
-  urlInfo.deleteFromGraph = (reference) => {
-    urlInfo.graph.deleteUrlInfo(urlInfo.url, reference);
+  urlInfo.onDereferenced = (lastReferenceFromOther) => {
+    urlInfo.dereferencedTimestamp = Date.now();
+    urlInfo.graph.urlInfoDereferencedEventEmitter.emit(
+      urlInfo,
+      lastReferenceFromOther,
+    );
   };
+
+  // not used for now
+  // urlInfo.deleteFromGraph = () => {
+  //   urlInfo.kitchen.urlInfoTransformer.resetContent(urlInfo);
+  //   urlInfo.graph.urlInfoMap.delete(url);
+  //   urlInfo.referenceToOthersSet.forEach((referenceToOther) => {
+  //     referenceToOther.remove();
+  //   });
+  //   if (urlInfo.searchParams.size > 0) {
+  //     const urlWithoutSearch = asUrlWithoutSearch(urlInfo.url);
+  //     const urlInfoWithoutSearch = urlInfo.graph.getUrlInfo(urlWithoutSearch);
+  //     if (urlInfoWithoutSearch) {
+  //       urlInfoWithoutSearch.searchParamVariantSet.delete(urlInfo);
+  //     }
+  //   }
+  // };
   urlInfo.cook = (customContext) => {
     return urlInfo.context.cook(urlInfo, customContext);
   };