@jsenv/core 35.0.2 → 35.0.4

package/src/plugins/autoreload/client/autoreload.js

@@ -1,10 +1,10 @@
-import { urlHotMetas } from "../../import_meta_hot/client/import_meta_hot.js"
-import { compareTwoUrlPaths } from "./url_helpers.js"
+import { urlHotMetas } from "../../import_meta_hot/client/import_meta_hot.js";
+import { compareTwoUrlPaths } from "./url_helpers.js";
 import {
   reloadHtmlPage,
   reloadJsImport,
   getDOMNodesUsingUrl,
-} from "./reload.js"
+} from "./reload.js";
 
 const reloader = {
   urlHotMetas,
@@ -12,44 +12,44 @@ const reloader = {
     value: "idle",
     onchange: () => {},
     goTo: (value) => {
-      reloader.status.value = value
-      reloader.status.onchange()
+      reloader.status.value = value;
+      reloader.status.onchange();
     },
   },
   autoreload: {
     enabled: ["1", null].includes(window.localStorage.getItem("autoreload")),
     onchange: () => {},
     enable: () => {
-      reloader.autoreload.enabled = true
-      window.localStorage.setItem("autoreload", "1")
-      reloader.autoreload.onchange()
+      reloader.autoreload.enabled = true;
+      window.localStorage.setItem("autoreload", "1");
+      reloader.autoreload.onchange();
     },
     disable: () => {
-      reloader.autoreload.enabled = false
-      window.localStorage.setItem("autoreload", "0")
-      reloader.autoreload.onchange()
+      reloader.autoreload.enabled = false;
+      window.localStorage.setItem("autoreload", "0");
+      reloader.autoreload.onchange();
     },
   },
   changes: {
     value: [],
     onchange: () => {},
     add: (reloadMessage) => {
-      reloader.changes.value.push(reloadMessage)
-      reloader.changes.onchange()
+      reloader.changes.value.push(reloadMessage);
+      reloader.changes.onchange();
       if (reloader.autoreload.enabled) {
-        reloader.reload()
+        reloader.reload();
       } else {
-        reloader.status.goTo("can_reload")
+        reloader.status.goTo("can_reload");
       }
     },
     remove: (reloadMessage) => {
-      const index = reloader.changes.value.indexOf(reloadMessage)
+      const index = reloader.changes.value.indexOf(reloadMessage);
       if (index > -1) {
-        reloader.changes.value.splice(index, 1)
+        reloader.changes.value.splice(index, 1);
         if (reloader.changes.value.length === 0) {
-          reloader.status.goTo("idle")
+          reloader.status.goTo("idle");
         }
-        reloader.changes.onchange()
+        reloader.changes.onchange();
       }
     },
   },
@@ -57,169 +57,169 @@ const reloader = {
   reload: () => {
     const someEffectIsFullReload = reloader.changes.value.some(
       (reloadMessage) => reloadMessage.type === "full",
-    )
+    );
     if (someEffectIsFullReload) {
-      reloadHtmlPage()
-      return
+      reloadHtmlPage();
+      return;
     }
-    reloader.status.goTo("reloading")
+    reloader.status.goTo("reloading");
     const onApplied = (reloadMessage) => {
-      reloader.changes.remove(reloadMessage)
-    }
+      reloader.changes.remove(reloadMessage);
+    };
     const setReloadMessagePromise = (reloadMessage, promise) => {
       promise.then(
         () => {
-          onApplied(reloadMessage)
-          reloader.currentExecution = null
+          onApplied(reloadMessage);
+          reloader.currentExecution = null;
         },
         (e) => {
-          reloader.status.goTo("failed")
+          reloader.status.goTo("failed");
           if (typeof window.reportError === "function") {
-            window.reportError(e)
+            window.reportError(e);
           } else {
-            console.error(e)
+            console.error(e);
           }
           console.error(
             `[jsenv] Hot reload failed after ${reloadMessage.reason}.
 This could be due to syntax errors or importing non-existent modules (see errors in console)`,
-          )
-          reloader.currentExecution = null
+          );
+          reloader.currentExecution = null;
         },
-      )
-    }
+      );
+    };
     reloader.changes.value.forEach((reloadMessage) => {
       if (reloadMessage.type === "hot") {
         const promise = addToHotQueue(() => {
-          return applyHotReload(reloadMessage)
-        })
-        setReloadMessagePromise(reloadMessage, promise)
+          return applyHotReload(reloadMessage);
+        });
+        setReloadMessagePromise(reloadMessage, promise);
       } else {
-        setReloadMessagePromise(reloadMessage, Promise.resolve())
+        setReloadMessagePromise(reloadMessage, Promise.resolve());
       }
-    })
+    });
   },
-}
+};
 
-let pendingCallbacks = []
-let running = false
+let pendingCallbacks = [];
+let running = false;
 const addToHotQueue = async (callback) => {
-  pendingCallbacks.push(callback)
-  dequeue()
-}
+  pendingCallbacks.push(callback);
+  dequeue();
+};
 const dequeue = async () => {
   if (running) {
-    return
+    return;
   }
-  const callbacks = pendingCallbacks.slice()
-  pendingCallbacks = []
-  running = true
+  const callbacks = pendingCallbacks.slice();
+  pendingCallbacks = [];
+  running = true;
   try {
     await callbacks.reduce(async (previous, callback) => {
-      await previous
-      await callback()
-    }, Promise.resolve())
+      await previous;
+      await callback();
+    }, Promise.resolve());
   } finally {
-    running = false
+    running = false;
     if (pendingCallbacks.length) {
-      dequeue()
+      dequeue();
     }
   }
-}
+};
 
 const applyHotReload = async ({ hotInstructions }) => {
   await hotInstructions.reduce(
     async (previous, { type, boundary, acceptedBy }) => {
-      await previous
+      await previous;
 
-      const urlToFetch = new URL(boundary, `${window.location.origin}/`).href
-      const urlHotMeta = urlHotMetas[urlToFetch]
+      const urlToFetch = new URL(boundary, `${window.location.origin}/`).href;
+      const urlHotMeta = urlHotMetas[urlToFetch];
       // there is no url hot meta when:
       // - code was not executed (code splitting with dynamic import)
       // - import.meta.hot.accept() is not called (happens for HTML and CSS)
 
       if (type === "prune") {
         if (urlHotMeta) {
-          delete urlHotMetas[urlToFetch]
+          delete urlHotMetas[urlToFetch];
           if (urlHotMeta.disposeCallback) {
             console.groupCollapsed(
               `[jsenv] cleanup ${boundary} (previously used in ${acceptedBy})`,
-            )
-            console.log(`call dispose callback`)
-            await urlHotMeta.disposeCallback()
-            console.groupEnd()
+            );
+            console.log(`call dispose callback`);
+            await urlHotMeta.disposeCallback();
+            console.groupEnd();
           }
         }
-        return null
+        return null;
       }
 
       if (acceptedBy === boundary) {
-        console.groupCollapsed(`[jsenv] hot reloading ${boundary}`)
+        console.groupCollapsed(`[jsenv] hot reloading ${boundary}`);
       } else {
         console.groupCollapsed(
           `[jsenv] hot reloading ${acceptedBy} usage in ${boundary}`,
-        )
+        );
       }
       if (type === "js_module") {
         if (!urlHotMeta) {
           // code was not executed, no need to re-execute it
-          return null
+          return null;
         }
         if (urlHotMeta.disposeCallback) {
-          console.log(`call dispose callback`)
-          await urlHotMeta.disposeCallback()
+          console.log(`call dispose callback`);
+          await urlHotMeta.disposeCallback();
         }
-        console.log(`importing js module`)
+        console.log(`importing js module`);
         reloader.currentExecution = {
           type: "dynamic_import",
           url: urlToFetch,
-        }
-        const namespace = await reloadJsImport(urlToFetch)
+        };
+        const namespace = await reloadJsImport(urlToFetch);
         if (urlHotMeta.acceptCallback) {
-          await urlHotMeta.acceptCallback(namespace)
+          await urlHotMeta.acceptCallback(namespace);
         }
-        console.log(`js module import done`)
-        console.groupEnd()
-        return namespace
+        console.log(`js module import done`);
+        console.groupEnd();
+        return namespace;
       }
       if (type === "html") {
         const isRootHtmlFile =
           window.location.pathname === "/" &&
-          new URL(urlToFetch).pathname.slice(1).indexOf("/") === -1
+          new URL(urlToFetch).pathname.slice(1).indexOf("/") === -1;
         if (
           !isRootHtmlFile &&
           !compareTwoUrlPaths(urlToFetch, window.location.href)
         ) {
           // we are not in that HTML page
-          return null
+          return null;
         }
         const urlToReload = new URL(acceptedBy, `${window.location.origin}/`)
-          .href
-        const domNodesUsingUrl = getDOMNodesUsingUrl(urlToReload)
-        const domNodesCount = domNodesUsingUrl.length
+          .href;
+        const domNodesUsingUrl = getDOMNodesUsingUrl(urlToReload);
+        const domNodesCount = domNodesUsingUrl.length;
         if (domNodesCount === 0) {
-          console.log(`no dom node using ${acceptedBy}`)
+          console.log(`no dom node using ${acceptedBy}`);
         } else if (domNodesCount === 1) {
-          console.log(`reloading`, domNodesUsingUrl[0].node)
-          domNodesUsingUrl[0].reload()
+          console.log(`reloading`, domNodesUsingUrl[0].node);
+          domNodesUsingUrl[0].reload();
         } else {
-          console.log(`reloading ${domNodesCount} nodes using ${acceptedBy}`)
+          console.log(`reloading ${domNodesCount} nodes using ${acceptedBy}`);
           domNodesUsingUrl.forEach((domNodesUsingUrl) => {
-            domNodesUsingUrl.reload()
-          })
+            domNodesUsingUrl.reload();
+          });
         }
-        console.groupEnd()
-        return null
+        console.groupEnd();
+        return null;
       }
-      console.warn(`unknown update type: "${type}"`)
-      return null
+      console.warn(`unknown update type: "${type}"`);
+      return null;
     },
     Promise.resolve(),
-  )
-}
+  );
+};
 
-window.__reloader__ = reloader
+window.__reloader__ = reloader;
 window.__server_events__.listenEvents({
   reload: (reloadServerEvent) => {
-    reloader.changes.add(reloadServerEvent.data)
+    reloader.changes.add(reloadServerEvent.data);
   },
-})
+});

package/src/plugins/autoreload/client/reload.js

@@ -1,83 +1,83 @@
 import {
   parseSrcSet,
   stringifySrcSet,
-} from "@jsenv/ast/src/html/html_src_set.js"
+} from "@jsenv/ast/src/html/html_src_set.js";
 
-import { injectQuery, compareTwoUrlPaths } from "./url_helpers.js"
+import { injectQuery, compareTwoUrlPaths } from "./url_helpers.js";
 
 export const reloadHtmlPage = () => {
-  window.location.reload(true)
-}
+  window.location.reload(true);
+};
 
 // This function can consider everything as hot reloadable:
 // - no need to check [hot-accept]and [hot-decline] attributes for instance
 // This is because if something should full reload, we receive "full_reload"
 // from server and this function is not called
 export const getDOMNodesUsingUrl = (urlToReload) => {
-  const nodes = []
+  const nodes = [];
   const shouldReloadUrl = (urlCandidate) => {
-    return compareTwoUrlPaths(urlCandidate, urlToReload)
-  }
+    return compareTwoUrlPaths(urlCandidate, urlToReload);
+  };
   const visitNodeAttributeAsUrl = (node, attributeName) => {
-    let attribute = node[attributeName]
+    let attribute = node[attributeName];
     if (!attribute) {
-      return
+      return;
     }
     if (SVGAnimatedString && attribute instanceof SVGAnimatedString) {
-      attribute = attribute.animVal
+      attribute = attribute.animVal;
     }
     if (!shouldReloadUrl(attribute)) {
-      return
+      return;
     }
     nodes.push({
       node,
       reload: () => {
         if (node.nodeName === "SCRIPT") {
-          const copy = document.createElement("script")
+          const copy = document.createElement("script");
           Array.from(node.attributes).forEach((attribute) => {
-            copy.setAttribute(attribute.nodeName, attribute.nodeValue)
-          })
-          copy.src = injectQuery(node.src, { hmr: Date.now() })
+            copy.setAttribute(attribute.nodeName, attribute.nodeValue);
+          });
+          copy.src = injectQuery(node.src, { hmr: Date.now() });
           if (node.parentNode) {
-            node.parentNode.replaceChild(copy, node)
+            node.parentNode.replaceChild(copy, node);
           } else {
-            document.body.appendChild(copy)
+            document.body.appendChild(copy);
           }
         } else {
-          node[attributeName] = injectQuery(attribute, { hmr: Date.now() })
+          node[attributeName] = injectQuery(attribute, { hmr: Date.now() });
         }
       },
-    })
-  }
+    });
+  };
   Array.from(document.querySelectorAll(`link[rel="stylesheet"]`)).forEach(
     (link) => {
-      visitNodeAttributeAsUrl(link, "href")
+      visitNodeAttributeAsUrl(link, "href");
     },
-  )
+  );
   Array.from(document.querySelectorAll(`link[rel="icon"]`)).forEach((link) => {
-    visitNodeAttributeAsUrl(link, "href")
-  })
+    visitNodeAttributeAsUrl(link, "href");
+  });
   Array.from(document.querySelectorAll("script")).forEach((script) => {
-    visitNodeAttributeAsUrl(script, "src")
-    const inlinedFromSrc = script.getAttribute("inlined-from-src")
+    visitNodeAttributeAsUrl(script, "src");
+    const inlinedFromSrc = script.getAttribute("inlined-from-src");
     if (inlinedFromSrc) {
       const inlinedFromUrl = new URL(inlinedFromSrc, window.location.origin)
-        .href
+        .href;
       if (shouldReloadUrl(inlinedFromUrl)) {
         nodes.push({
           node: script,
           reload: () =>
             window.__supervisor__.reloadSupervisedScript(inlinedFromSrc),
-        })
+        });
       }
     }
-  })
+  });
   // There is no real need to update a.href because the resource will be fetched when clicked.
   // But in a scenario where the resource was already visited and is in browser cache, adding
   // the dynamic query param ensure the cache is invalidated
   Array.from(document.querySelectorAll("a")).forEach((a) => {
-    visitNodeAttributeAsUrl(a, "href")
-  })
+    visitNodeAttributeAsUrl(a, "href");
+  });
   // About iframes:
   // - By default iframe itself and everything inside trigger a parent page full-reload
   // - Adding [hot-accept] on the iframe means parent page won't reload when iframe full/hot reload
@@ -85,49 +85,49 @@ export const getDOMNodesUsingUrl = (urlToReload) => {
   //   you must put import.meta.hot.decline() for code involved in communication.
   //   (both in parent and iframe)
   Array.from(document.querySelectorAll("img")).forEach((img) => {
-    visitNodeAttributeAsUrl(img, "src")
-    const srcset = img.srcset
+    visitNodeAttributeAsUrl(img, "src");
+    const srcset = img.srcset;
     if (srcset) {
-      const srcCandidates = parseSrcSet(srcset)
+      const srcCandidates = parseSrcSet(srcset);
       srcCandidates.forEach((srcCandidate) => {
-        const url = new URL(srcCandidate.specifier, `${window.location.href}`)
+        const url = new URL(srcCandidate.specifier, `${window.location.href}`);
         if (shouldReloadUrl(url)) {
-          srcCandidate.specifier = injectQuery(url, { hmr: Date.now() })
+          srcCandidate.specifier = injectQuery(url, { hmr: Date.now() });
         }
-      })
+      });
       nodes.push({
         node: img,
         reload: () => {
-          img.srcset = stringifySrcSet(srcCandidates)
+          img.srcset = stringifySrcSet(srcCandidates);
         },
-      })
+      });
     }
-  })
+  });
   Array.from(document.querySelectorAll("source")).forEach((source) => {
-    visitNodeAttributeAsUrl(source, "src")
-  })
+    visitNodeAttributeAsUrl(source, "src");
+  });
   // svg image tag
   Array.from(document.querySelectorAll("image")).forEach((image) => {
-    visitNodeAttributeAsUrl(image, "href")
-  })
+    visitNodeAttributeAsUrl(image, "href");
+  });
   // svg use
   Array.from(document.querySelectorAll("use")).forEach((use) => {
-    visitNodeAttributeAsUrl(use, "href")
-  })
-  return nodes
-}
+    visitNodeAttributeAsUrl(use, "href");
+  });
+  return nodes;
+};
 
 export const reloadJsImport = async (url) => {
-  const urlWithHmr = injectQuery(url, { hmr: Date.now() })
-  const namespace = await import(urlWithHmr)
-  return namespace
-}
+  const urlWithHmr = injectQuery(url, { hmr: Date.now() });
+  const namespace = await import(urlWithHmr);
+  return namespace;
+};
 
 export const reloadAllCss = () => {
-  const links = Array.from(document.getElementsByTagName("link"))
+  const links = Array.from(document.getElementsByTagName("link"));
   links.forEach((link) => {
     if (link.rel === "stylesheet") {
-      link.href = injectQuery(link.href, { hmr: Date.now() })
+      link.href = injectQuery(link.href, { hmr: Date.now() });
     }
-  })
-}
+  });
+};

package/src/plugins/autoreload/client/url_helpers.js

@@ -1,23 +1,23 @@
 export const compareTwoUrlPaths = (url, otherUrl) => {
   if (url === otherUrl) {
-    return true
+    return true;
   }
-  const urlObject = new URL(url)
-  const otherUrlObject = new URL(otherUrl)
+  const urlObject = new URL(url);
+  const otherUrlObject = new URL(otherUrl);
   if (urlObject.origin !== otherUrlObject.origin) {
-    return false
+    return false;
   }
   if (urlObject.pathname !== otherUrlObject.pathname) {
-    return false
+    return false;
   }
-  return true
-}
+  return true;
+};
 
 export const injectQuery = (url, query) => {
-  const urlObject = new URL(url)
-  const { searchParams } = urlObject
+  const urlObject = new URL(url);
+  const { searchParams } = urlObject;
   Object.keys(query).forEach((key) => {
-    searchParams.set(key, query[key])
-  })
-  return String(urlObject)
-}
+    searchParams.set(key, query[key]);
+  });
+  return String(urlObject);
+};

package/src/plugins/autoreload/jsenv_plugin_autoreload.js

@@ -1,6 +1,6 @@
-import { jsenvPluginHmr } from "./jsenv_plugin_hmr.js"
-import { jsenvPluginAutoreloadClient } from "./jsenv_plugin_autoreload_client.js"
-import { jsenvPluginAutoreloadServer } from "./jsenv_plugin_autoreload_server.js"
+import { jsenvPluginHmr } from "./jsenv_plugin_hmr.js";
+import { jsenvPluginAutoreloadClient } from "./jsenv_plugin_autoreload_client.js";
+import { jsenvPluginAutoreloadServer } from "./jsenv_plugin_autoreload_server.js";
 
 export const jsenvPluginAutoreload = ({
   clientFileChangeCallbackList,
@@ -13,5 +13,5 @@ export const jsenvPluginAutoreload = ({
       clientFileChangeCallbackList,
       clientFilesPruneCallbackList,
     }),
-  ]
-}
+  ];
+};

package/src/plugins/autoreload/jsenv_plugin_autoreload_client.js

@@ -3,26 +3,26 @@ import {
   stringifyHtmlAst,
   injectHtmlNodeAsEarlyAsPossible,
   createHtmlNode,
-} from "@jsenv/ast"
+} from "@jsenv/ast";
 
 export const jsenvPluginAutoreloadClient = () => {
   const autoreloadClientFileUrl = new URL(
     "./client/autoreload.js",
     import.meta.url,
-  ).href
+  ).href;
 
   return {
     name: "jsenv:autoreload_client",
     appliesDuring: "dev",
     transformUrlContent: {
       html: (htmlUrlInfo, context) => {
-        const htmlAst = parseHtmlString(htmlUrlInfo.content)
+        const htmlAst = parseHtmlString(htmlUrlInfo.content);
         const [autoreloadClientReference] = context.referenceUtils.inject({
           type: "script",
           subtype: "js_module",
           expectedType: "js_module",
           specifier: autoreloadClientFileUrl,
-        })
+        });
         injectHtmlNodeAsEarlyAsPossible(
           htmlAst,
           createHtmlNode({
@@ -31,12 +31,12 @@ export const jsenvPluginAutoreloadClient = () => {
             src: autoreloadClientReference.generatedSpecifier,
           }),
           "jsenv:autoreload_client",
-        )
-        const htmlModified = stringifyHtmlAst(htmlAst)
+        );
+        const htmlModified = stringifyHtmlAst(htmlAst);
         return {
           content: htmlModified,
-        }
+        };
       },
     },
-  }
-}
+  };
+};