@async/framework 0.11.1 → 0.11.2

package/browser.ts

@@ -186,6 +186,24 @@ const __asyncSignalModule = (() => {
         };
       },
 
+      _restore(snapshot = {}) {
+        if (!isAsyncSignalSnapshot(snapshot)) {
+          return state.set(snapshot);
+        }
+        if (activeAbort && !activeAbort.aborted) {
+          activeAbort.cancel(new Error(`Async signal "${registeredId}" restored from snapshot.`));
+        }
+        value = snapshot.value;
+        loading = Boolean(snapshot.loading);
+        error = snapshot.error ?? null;
+        status = typeof snapshot.status === "string" ? snapshot.status : inferStatus({ value, loading, error });
+        if (Number.isFinite(snapshot.version)) {
+          version = snapshot.version;
+        }
+        notify();
+        return state;
+      },
+
       _bindRegistry(nextRegistry, nextId) {
         registry = nextRegistry;
         registeredId = nextId;
@@ -271,6 +289,27 @@ const __asyncSignalModule = (() => {
     return Boolean(value?.[asyncSignalKind]);
   }
 
+  function isAsyncSignalSnapshot(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return false;
+    }
+    return Object.hasOwn(value, "value")
+      && (Object.hasOwn(value, "loading")
+        || Object.hasOwn(value, "error")
+        || Object.hasOwn(value, "status")
+        || Object.hasOwn(value, "version"));
+  }
+
+  function inferStatus({ value, loading, error }) {
+    if (loading) {
+      return "loading";
+    }
+    if (error) {
+      return "error";
+    }
+    return value === undefined ? "idle" : "ready";
+  }
+
   function attachCancel(signal, controller) {
     Object.defineProperty(signal, "cancel", {
       configurable: true,
@@ -1909,12 +1948,16 @@ const __componentModule = (() => {
     });
 
     const output = Component.call(context, props);
+    if (output && typeof output.then === "function") {
+      throw new TypeError(`Component "${componentName(Component)}" returned a Promise. Async components are not supported by synchronous renderComponent(). Use an async partial or handler instead.`);
+    }
     const html = renderScopedTemplate(output);
 
     return {
       html,
       attach(target) {
-        for (const hook of attachHooks) {
+        for (let index = 0; index < attachHooks.length; index += 1) {
+          const hook = attachHooks[index];
           runtime.scheduler?.enqueue("lifecycle", () => {
             const cleanup = hook(target);
             if (typeof cleanup === "function") {
@@ -1922,7 +1965,7 @@ const __componentModule = (() => {
             }
           }, {
             scope,
-            key: `attach:${attachHooks.indexOf(hook)}`
+            key: `attach:${index}`
           }) ?? runAttachHook(hook, target);
         }
       },
@@ -1930,8 +1973,12 @@ const __componentModule = (() => {
         this.attach(target);
       },
       visible(target, observeVisible) {
-        for (const hook of visibleHooks) {
-          const cleanup = observeVisible(target, () => {
+        if (visibleHooks.length === 0) {
+          return;
+        }
+        const cleanup = observeVisible(target, () => {
+          for (let index = 0; index < visibleHooks.length; index += 1) {
+            const hook = visibleHooks[index];
             runtime.scheduler?.enqueue("lifecycle", () => {
               const hookCleanup = hook(target);
               if (typeof hookCleanup === "function") {
@@ -1939,12 +1986,12 @@ const __componentModule = (() => {
               }
             }, {
               scope,
-              key: `visible:${visibleHooks.indexOf(hook)}`
+              key: `visible:${index}`
             }) ?? runVisibleHook(hook, target);
-          });
-          if (typeof cleanup === "function") {
-            cleanups.push(cleanup);
           }
+        });
+        if (typeof cleanup === "function") {
+          cleanups.push(cleanup);
         }
       },
       cleanup() {
@@ -2200,11 +2247,12 @@ const __serverModule = (() => {
         signal: context.abort
       });
 
+      assertTransportResponse(id, response);
       if (!response.ok) {
         throw new Error(`Server function "${id}" failed with ${response.status}.`);
       }
 
-      const result = await readServerResponse(response);
+      const result = await readServerResponse(id, response);
       await applyServerResult(result, runContext);
       return markAppliedServerValue(unwrapServerResult(result));
     }
@@ -2245,6 +2293,11 @@ const __serverModule = (() => {
       return result;
     }
 
+    if (result.error) {
+      markAppliedServerResult(result);
+      throw toError(result.error);
+    }
+
     if (result.signals && context.signals) {
       for (const [path, value] of Object.entries(result.signals)) {
         context.signals.set?.(path, value);
@@ -2263,15 +2316,7 @@ const __serverModule = (() => {
       await context.router?.navigate?.(result.redirect);
     }
 
-    if (result.error) {
-      throw toError(result.error);
-    }
-
-    Object.defineProperty(result, appliedServerResult, {
-      configurable: true,
-      enumerable: false,
-      value: true
-    });
+    markAppliedServerResult(result);
 
     return result;
   }
@@ -2290,6 +2335,15 @@ const __serverModule = (() => {
     return value;
   }
 
+  function markAppliedServerResult(result) {
+    Object.defineProperty(result, appliedServerResult, {
+      configurable: true,
+      enumerable: false,
+      value: true
+    });
+    return result;
+  }
+
   function defaultInput(context = {}) {
     const form = findForm(context);
     if (form) {
@@ -2367,10 +2421,37 @@ const __serverModule = (() => {
     return namespace([]);
   }
 
-  async function readServerResponse(response) {
+  function assertTransportResponse(id, response) {
+    if (!response || typeof response !== "object") {
+      throw new Error(`Server function "${id}" transport returned an invalid response: expected a fetch Response-like object.`);
+    }
+    if (typeof response.ok !== "boolean") {
+      throw new Error(`Server function "${id}" transport returned an invalid response: missing boolean ok.`);
+    }
+    if (!response.headers || typeof response.headers.get !== "function") {
+      throw new Error(`Server function "${id}" transport returned an invalid response: missing headers.get(name).`);
+    }
+  }
+
+  async function readServerResponse(id, response) {
+    if (response.status === 204) {
+      return { value: undefined };
+    }
     const type = response.headers.get("content-type") ?? "";
     if (type.includes("application/json")) {
-      return response.json();
+      if (typeof response.json !== "function") {
+        throw new Error(`Server function "${id}" transport returned an invalid response: missing json().`);
+      }
+      try {
+        return await response.json();
+      } catch (cause) {
+        throw new Error(`Server function "${id}" returned invalid JSON: ${errorMessage(cause)}`, {
+          cause
+        });
+      }
+    }
+    if (typeof response.text !== "function") {
+      throw new Error(`Server function "${id}" transport returned an invalid response: missing text().`);
     }
     return { value: await response.text() };
   }
@@ -2483,6 +2564,9 @@ const __serverModule = (() => {
     if (tag === "[object File]" || tag === "[object Blob]" || tag === "[object FormData]") {
       throw new Error("Server proxy JSON transport does not support File, Blob, or FormData values yet.");
     }
+    if (isUnsupportedJsonTransportObject(value, tag)) {
+      throw new Error("Server proxy JSON transport does not support URLSearchParams, Headers, Request, Response, ReadableStream, ArrayBuffer, or typed array values yet.");
+    }
     if (Array.isArray(value)) {
       for (const item of value) {
         assertJsonTransportable(item, stack);
@@ -2496,6 +2580,16 @@ const __serverModule = (() => {
     stack.delete(value);
   }
 
+  function isUnsupportedJsonTransportObject(value, tag = Object.prototype.toString.call(value)) {
+    return tag === "[object URLSearchParams]"
+      || tag === "[object Headers]"
+      || tag === "[object Request]"
+      || tag === "[object Response]"
+      || tag === "[object ReadableStream]"
+      || tag === "[object ArrayBuffer]"
+      || ArrayBuffer.isView(value);
+  }
+
   function joinEndpoint(endpoint, id) {
     return `${String(endpoint).replace(/\/$/, "")}/${encodeURIComponent(id)}`;
   }
@@ -2517,6 +2611,10 @@ const __serverModule = (() => {
     return new Error(String(value));
   }
 
+  function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+
   function assertServerId(id) {
     if (typeof id !== "string" || id.length === 0) {
       throw new TypeError("Server function id must be a non-empty string.");
@@ -2749,7 +2847,8 @@ const __schedulerModule = (() => {
     const phases = [...(options.phases ?? defaultPhases)];
     const queues = new Map(phases.map((phase) => [phase, []]));
     const keyedJobs = new Map();
-    const destroyedScopes = new Set();
+    const destroyedObjectScopes = new WeakSet();
+    const destroyedPrimitiveScopes = new Set();
     const objectScopeIds = new WeakMap();
     const onError = typeof options.onError === "function" ? options.onError : undefined;
     const maxDepth = options.maxDepth ?? 100;
@@ -2797,7 +2896,7 @@ const __schedulerModule = (() => {
           throw new TypeError("scheduler.enqueue(phase, fn) requires a function.");
         }
         const scope = options.scope;
-        if (scope !== undefined && destroyedScopes.has(scope)) {
+        if (isScopeDestroyed(scope)) {
           return noop;
         }
 
@@ -2901,14 +3000,29 @@ const __schedulerModule = (() => {
 
       markScopeDestroyed(scope) {
         if (scope !== undefined) {
-          destroyedScopes.add(scope);
+          if (isObjectScope(scope)) {
+            destroyedObjectScopes.add(scope);
+          } else {
+            destroyedPrimitiveScopes.add(scope);
+          }
           api.cancelScope(scope);
         }
         return api;
       },
 
+      reviveScope(scope) {
+        if (scope !== undefined) {
+          if (isObjectScope(scope)) {
+            destroyedObjectScopes.delete(scope);
+          } else {
+            destroyedPrimitiveScopes.delete(scope);
+          }
+        }
+        return api;
+      },
+
       isScopeDestroyed(scope) {
-        return scope !== undefined && destroyedScopes.has(scope);
+        return isScopeDestroyed(scope);
       },
 
       inspect() {
@@ -2920,7 +3034,7 @@ const __schedulerModule = (() => {
           strategy,
           phases: [...phases],
           pending: counts,
-          scopesDestroyed: destroyedScopes.size,
+          scopesDestroyed: destroyedPrimitiveScopes.size,
           flushing,
           scheduled
         };
@@ -2935,7 +3049,7 @@ const __schedulerModule = (() => {
           queue.length = 0;
         }
         keyedJobs.clear();
-        destroyedScopes.clear();
+        destroyedPrimitiveScopes.clear();
       }
     };
 
@@ -2975,7 +3089,7 @@ const __schedulerModule = (() => {
         if (job.key) {
           keyedJobs.delete(job.key);
         }
-        if (job.canceled || (job.scope !== undefined && destroyedScopes.has(job.scope))) {
+        if (job.canceled || isScopeDestroyed(job.scope)) {
           continue;
         }
         try {
@@ -3032,6 +3146,20 @@ const __schedulerModule = (() => {
       }
       return String(scope);
     }
+
+    function isScopeDestroyed(scope) {
+      if (scope === undefined) {
+        return false;
+      }
+      if (isObjectScope(scope)) {
+        return destroyedObjectScopes.has(scope);
+      }
+      return destroyedPrimitiveScopes.has(scope);
+    }
+  }
+
+  function isObjectScope(scope) {
+    return (typeof scope === "object" && scope !== null) || typeof scope === "function";
   }
 
   function scheduleMicrotask(fn) {
@@ -3092,6 +3220,7 @@ const __loaderModule = (() => {
 
       scan(rootOrFragment = rootNode) {
         assertActive();
+        reviveScopes(rootOrFragment);
         bindSignalAttributes(rootOrFragment);
         bindClassAttributes(rootOrFragment);
         bindEventAttributes(rootOrFragment);
@@ -3595,6 +3724,12 @@ const __loaderModule = (() => {
       }
     }
 
+    function reviveScopes(scope) {
+      for (const element of elementsIn(scope)) {
+        schedulerInstance.reviveScope?.(element);
+      }
+    }
+
     return api;
   }
 
@@ -4158,7 +4293,10 @@ const __routerModule = (() => {
         }
         const matched = api.match(url);
         if (matched?.route?.partial && partials?.resolve?.(matched.route.partial)) {
-          return partials.render(matched.route.partial, matched.params, contextFor(matched));
+          return partials.render(matched.route.partial, matched.params, {
+            ...contextFor(matched),
+            prefetch: true
+          });
         }
         return Promise.resolve(null);
       },
@@ -5194,6 +5332,13 @@ const __appModule = (() => {
   function setOrRegisterSignal(signals, path, value) {
     const id = String(path).split(".")[0];
     if (signals.has?.(id)) {
+      if (path === id) {
+        const entry = signals._entry?.(id);
+        if (typeof entry?._restore === "function" && isAsyncSignalSnapshot(value)) {
+          entry._restore(value);
+          return;
+        }
+      }
       signals.set(path, value);
       return;
     }
@@ -5203,6 +5348,17 @@ const __appModule = (() => {
     }
   }
 
+  function isAsyncSignalSnapshot(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return false;
+    }
+    return Object.hasOwn(value, "value")
+      && (Object.hasOwn(value, "loading")
+        || Object.hasOwn(value, "error")
+        || Object.hasOwn(value, "status")
+        || Object.hasOwn(value, "version"));
+  }
+
   function attachServerCache(server, cache) {
     try {
       server.cache = cache;