@async/framework 0.10.0 → 0.10.2

package/src/cache.js

@@ -47,15 +47,7 @@ export function createCacheRegistry(initialMap = {}, { now = () => Date.now(), r
 
     get(key) {
       assertKey(key);
-      const entry = entries.get(key);
-      if (!entry) {
-        return undefined;
-      }
-      if (entry.expiresAt !== undefined && entry.expiresAt <= now()) {
-        entries.delete(key);
-        return undefined;
-      }
-      return entry.value;
+      return readEntry(key).value;
     },
 
     set(key, value, options = {}) {
@@ -73,9 +65,9 @@ export function createCacheRegistry(initialMap = {}, { now = () => Date.now(), r
       if (typeof fn !== "function") {
         throw new TypeError("cache.getOrSet(key, fn) requires a function.");
       }
-      const cached = registryApi.get(key);
-      if (cached !== undefined) {
-        return cached;
+      const cached = readEntry(key);
+      if (cached.found) {
+        return cached.value;
       }
       if (pending.has(key)) {
         return pending.get(key);
@@ -126,8 +118,8 @@ export function createCacheRegistry(initialMap = {}, { now = () => Date.now(), r
     snapshot() {
       const snapshot = {};
       for (const [key] of entries) {
-        const value = registryApi.get(key);
-        if (value !== undefined) {
+        const { found, value } = readEntry(key);
+        if (found && value !== undefined) {
           snapshot[key] = value;
         }
       }
@@ -167,6 +159,18 @@ export function createCacheRegistry(initialMap = {}, { now = () => Date.now(), r
     const prefix = key.split(":")[0];
     return definitions.get(prefix);
   }
+
+  function readEntry(key) {
+    const entry = entries.get(key);
+    if (!entry) {
+      return { found: false, value: undefined };
+    }
+    if (entry.expiresAt !== undefined && entry.expiresAt <= now()) {
+      entries.delete(key);
+      return { found: false, value: undefined };
+    }
+    return { found: true, value: entry.value };
+  }
 }
 
 function normalizeDefinition(definition) {

package/src/lazy-registry.js

@@ -33,10 +33,20 @@ export function createLazyRegistry(options = {}) {
       const resolved = resolveDescriptorUrl(type, id, descriptor, registryAssets);
       let modulePromise = moduleCache.get(resolved.moduleUrl);
       if (!modulePromise) {
-        modulePromise = Promise.resolve(importModule(resolved.moduleUrl));
+        modulePromise = Promise.resolve().then(() => importModule(resolved.moduleUrl));
         moduleCache.set(resolved.moduleUrl, modulePromise);
       }
-      const module = await modulePromise;
+      let module;
+      try {
+        module = await modulePromise;
+      } catch (cause) {
+        if (moduleCache.get(resolved.moduleUrl) === modulePromise) {
+          moduleCache.delete(resolved.moduleUrl);
+        }
+        throw new Error(`Lazy ${type} "${id}" failed to import ${resolved.moduleUrl}: ${errorMessage(cause)}`, {
+          cause
+        });
+      }
       const value = resolveExport(module, resolved.exportNames, type, id);
       exportCache.set(cacheKey, value);
       return value;
@@ -196,6 +206,10 @@ function isAbsoluteUrl(value) {
   return /^[A-Za-z][A-Za-z\d+.-]*:/.test(value);
 }
 
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 function stableStringify(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return JSON.stringify(value);

package/src/loader.js

@@ -90,6 +90,7 @@ export function Loader({ root, signals, handlers, server, router, cache, attribu
         return;
       }
       destroyed = true;
+      markDestroyedScopes(rootNode);
       for (const cleanup of [...cleanups]) {
         runCleanup(cleanup);
       }
@@ -540,6 +541,12 @@ export function Loader({ root, signals, handlers, server, router, cache, attribu
     });
   }
 
+  function markDestroyedScopes(scope) {
+    for (const element of elementsIn(scope)) {
+      schedulerInstance.markScopeDestroyed(element);
+    }
+  }
+
   return api;
 }
 

package/src/router.js

@@ -61,7 +61,7 @@ export function createRouteRegistry(initialMap = {}, options = {}) {
         }
         const params = {};
         candidate.keys.forEach((key, index) => {
-          params[key] = decodeURIComponent(match[index + 1] ?? "");
+          params[key] = safeDecodeURIComponent(match[index + 1] ?? "");
         });
         return {
           pattern: candidate.pattern,
@@ -176,11 +176,11 @@ export function createRouter({
       }
       bindNavigation();
       if (mode === "csr") {
-        void api.navigate(currentUrl(), {
+        handleNavigation(api.navigate(currentUrl(), {
           replace: true,
           initial: true,
           source: "client"
-        }).catch(() => {});
+        }));
         return api;
       }
       updateStateFromLocation();
@@ -245,7 +245,7 @@ export function createRouter({
         return;
       }
       event.preventDefault();
-      api.navigate(anchor.href);
+      handleNavigation(api.navigate(anchor.href));
     };
     const submit = (event) => {
       const form = closest(event.target, "form");
@@ -253,9 +253,9 @@ export function createRouter({
         return;
       }
       event.preventDefault();
-      api.navigate(formActionUrl(form));
+      handleNavigation(api.navigate(formActionUrl(form)));
     };
-    const popstate = () => api.navigate(currentUrl(), { history: false });
+    const popstate = () => handleNavigation(api.navigate(currentUrl(), { history: false }));
 
     rootNode.addEventListener?.("click", click);
     rootNode.addEventListener?.("submit", submit);
@@ -448,6 +448,19 @@ export function createRouter({
     }
   }
 
+  function handleNavigation(promise) {
+    void promise.catch((error) => {
+      if (destroyed) {
+        return;
+      }
+      setRouterState({
+        pending: false,
+        error
+      });
+      dispatchAsyncError(rootNode, error);
+    });
+  }
+
   function currentUrl() {
     return resolveUrl(documentRef.defaultView?.location?.href ?? "http://localhost/");
   }
@@ -464,6 +477,33 @@ export function createRouter({
       throw new Error("Router has been destroyed.");
     }
   }
+
+  function shouldIgnoreLink(event, anchor) {
+    if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
+      return true;
+    }
+    if (anchor.target || anchor.hasAttribute("download")) {
+      return true;
+    }
+    const target = resolveUrl(anchor.href);
+    const current = currentUrl();
+    if (target.origin !== current.origin) {
+      return true;
+    }
+    return isHashOnlyNavigation(target, current, anchor);
+  }
+
+  function shouldIgnoreForm(form) {
+    const method = String(form.method || "get").toLowerCase();
+    return method !== "get" || resolveUrl(form.action).origin !== currentUrl().origin;
+  }
+
+  function formActionUrl(form) {
+    const url = resolveUrl(form.action || form.ownerDocument.defaultView.location.href);
+    const formData = new form.ownerDocument.defaultView.FormData(form);
+    url.search = new URLSearchParams(formData).toString();
+    return url.href;
+  }
 }
 
 function normalizeRoute(pattern, definition) {
@@ -501,28 +541,6 @@ function compilePattern(pattern) {
   return { regex: new RegExp(`^${source}$`), keys };
 }
 
-function shouldIgnoreLink(event, anchor) {
-  if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
-    return true;
-  }
-  if (anchor.target || anchor.hasAttribute("download")) {
-    return true;
-  }
-  return toUrl(anchor.href).origin !== toUrl(anchor.ownerDocument.defaultView.location.href).origin;
-}
-
-function shouldIgnoreForm(form) {
-  const method = String(form.method || "get").toLowerCase();
-  return method !== "get" || toUrl(form.action).origin !== toUrl(form.ownerDocument.defaultView.location.href).origin;
-}
-
-function formActionUrl(form) {
-  const url = toUrl(form.action || form.ownerDocument.defaultView.location.href);
-  const formData = new form.ownerDocument.defaultView.FormData(form);
-  url.search = new URLSearchParams(formData).toString();
-  return url.href;
-}
-
 function closest(target, selector) {
   return target?.closest?.(selector);
 }
@@ -538,6 +556,34 @@ function queryObject(url) {
   return Object.fromEntries(url.searchParams.entries());
 }
 
+function safeDecodeURIComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function isHashOnlyNavigation(target, current, anchor) {
+  if (target.origin !== current.origin || target.pathname !== current.pathname || target.search !== current.search) {
+    return false;
+  }
+  return target.hash !== current.hash || anchor.getAttribute?.("href")?.startsWith("#") === true;
+}
+
+function dispatchAsyncError(element, error) {
+  const EventCtor = element.ownerDocument?.defaultView?.CustomEvent ?? globalThis.CustomEvent;
+  if (typeof EventCtor !== "function") {
+    return;
+  }
+  element.dispatchEvent?.(
+    new EventCtor("async:error", {
+      bubbles: true,
+      detail: { error }
+    })
+  );
+}
+
 function escapeRegExp(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }

package/src/server.js

@@ -305,14 +305,17 @@ function formDataToObject(formData) {
   return output;
 }
 
-function assertJsonTransportable(value, seen = new Set()) {
+function assertJsonTransportable(value, stack = new Set()) {
+  if (typeof value === "bigint") {
+    throw new Error("Server proxy JSON transport does not support BigInt values.");
+  }
   if (value == null || typeof value !== "object") {
     return;
   }
-  if (seen.has(value)) {
-    return;
+  if (stack.has(value)) {
+    throw new Error("Server proxy JSON transport does not support circular values.");
   }
-  seen.add(value);
+  stack.add(value);
 
   const tag = Object.prototype.toString.call(value);
   if (tag === "[object File]" || tag === "[object Blob]" || tag === "[object FormData]") {
@@ -320,13 +323,15 @@ function assertJsonTransportable(value, seen = new Set()) {
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      assertJsonTransportable(item, seen);
+      assertJsonTransportable(item, stack);
     }
+    stack.delete(value);
     return;
   }
   for (const item of Object.values(value)) {
-    assertJsonTransportable(item, seen);
+    assertJsonTransportable(item, stack);
   }
+  stack.delete(value);
 }
 
 function joinEndpoint(endpoint, id) {