@async/framework 0.11.1 → 0.11.3

package/browser.umd.js

@@ -196,6 +196,28 @@
           };
         },
 
+        _cloneSignalDeclaration() {
+          return asyncSignal(id, fn);
+        },
+
+        _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;
@@ -281,6 +303,27 @@
       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,
@@ -928,7 +971,12 @@
           return registryStore.entries(`${type}.entries`);
         },
 
-        _adoptMany() {
+        _adoptMany(map = {}) {
+          for (const [id, definition] of Object.entries(map ?? {})) {
+            if (!definitions.has(id)) {
+              registryApi.register(id, definition);
+            }
+          }
           return registryApi;
         }
       }, registryStore, type);
@@ -1086,6 +1134,10 @@
 
         snapshot() {
           return value;
+        },
+
+        _cloneSignalDeclaration() {
+          return createSignal(value);
         }
       };
 
@@ -1128,6 +1180,10 @@
           return backing.snapshot();
         },
 
+        _cloneSignalDeclaration() {
+          return computed(fn);
+        },
+
         _bindRegistry(registry, id) {
           return registry.effect(() => {
             backing.set(fn.call({
@@ -1152,6 +1208,9 @@
         [effectKind]: true,
         kind: "effect",
         fn,
+        _cloneSignalDeclaration() {
+          return effect(fn);
+        },
         _bindRegistry(registry) {
           return registry.effect(fn);
         }
@@ -1370,10 +1429,14 @@
         },
 
         _adoptMany(map = {}) {
-          for (const id of Object.keys(map ?? {})) {
-            if (entries.has(id)) {
-              bindEntry(id, entries.get(id));
+          for (const [id, signalLike] of Object.entries(map ?? {})) {
+            if (!entries.has(id)) {
+              const entry = cloneSignalDeclaration(signalLike);
+              entries.set(id, entry);
+              bindEntry(id, entry);
+              continue;
             }
+            bindEntry(id, entries.get(id));
           }
           return registry;
         }
@@ -1451,6 +1514,16 @@
       return createSignal(signalLike);
     }
 
+    function cloneSignalDeclaration(signalLike) {
+      if (typeof signalLike?._cloneSignalDeclaration === "function") {
+        return signalLike._cloneSignalDeclaration();
+      }
+      if (isSignalLike(signalLike)) {
+        return createSignal(typeof signalLike.snapshot === "function" ? signalLike.snapshot() : signalLike.value);
+      }
+      return createSignal(signalLike);
+    }
+
     function isSignalLike(value) {
       return Boolean(value && typeof value === "object" && typeof value.subscribe === "function");
     }
@@ -1629,7 +1702,7 @@
         frame.add(path);
       }
     }
-    return { createSignal, computed, effect, createSignalRegistry, isSignalRef, signal };
+    return { createSignal, computed, effect, createSignalRegistry, cloneSignalDeclaration, isSignalRef, signal };
   })();
 
   const __htmlModule = (() => {
@@ -1871,7 +1944,12 @@
           return lazyComponents.get(id);
         },
 
-        _adoptMany() {
+        _adoptMany(map = {}) {
+          for (const [id, Component] of Object.entries(map ?? {})) {
+            if (!entries.has(id)) {
+              registry.register(id, Component);
+            }
+          }
           return registry;
         }
       }, registryStore, type);
@@ -1919,12 +1997,16 @@
       });
 
       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") {
@@ -1932,7 +2014,7 @@
               }
             }, {
               scope,
-              key: `attach:${attachHooks.indexOf(hook)}`
+              key: `attach:${index}`
             }) ?? runAttachHook(hook, target);
           }
         },
@@ -1940,8 +2022,12 @@
           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") {
@@ -1949,12 +2035,12 @@
                 }
               }, {
                 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() {
@@ -2210,11 +2296,12 @@
           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));
       }
@@ -2255,6 +2342,11 @@
         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);
@@ -2273,15 +2365,7 @@
         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;
     }
@@ -2300,6 +2384,15 @@
       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) {
@@ -2377,10 +2470,37 @@
       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() };
     }
@@ -2493,6 +2613,9 @@
       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);
@@ -2506,6 +2629,16 @@
       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)}`;
     }
@@ -2527,6 +2660,10 @@
       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.");
@@ -2652,7 +2789,12 @@
           return results;
         },
 
-        _adoptMany() {
+        _adoptMany(map = {}) {
+          for (const [id, fn] of Object.entries(map ?? {})) {
+            if (!handlers.has(id)) {
+              registry.register(id, fn);
+            }
+          }
           return registry;
         }
       }, registryStore, type);
@@ -2759,7 +2901,8 @@
       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;
@@ -2807,7 +2950,7 @@
             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;
           }
 
@@ -2911,14 +3054,29 @@
 
         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() {
@@ -2930,7 +3088,7 @@
             strategy,
             phases: [...phases],
             pending: counts,
-            scopesDestroyed: destroyedScopes.size,
+            scopesDestroyed: destroyedPrimitiveScopes.size,
             flushing,
             scheduled
           };
@@ -2945,7 +3103,7 @@
             queue.length = 0;
           }
           keyedJobs.clear();
-          destroyedScopes.clear();
+          destroyedPrimitiveScopes.clear();
         }
       };
 
@@ -2985,7 +3143,7 @@
           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 {
@@ -3042,6 +3200,20 @@
         }
         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) {
@@ -3102,6 +3274,7 @@
 
         scan(rootOrFragment = rootNode) {
           assertActive();
+          reviveScopes(rootOrFragment);
           bindSignalAttributes(rootOrFragment);
           bindClassAttributes(rootOrFragment);
           bindEventAttributes(rootOrFragment);
@@ -3605,6 +3778,12 @@
         }
       }
 
+      function reviveScopes(scope) {
+        for (const element of elementsIn(scope)) {
+          schedulerInstance.reviveScope?.(element);
+        }
+      }
+
       return api;
     }
 
@@ -3904,7 +4083,12 @@
           return normalizePartialResult(result, partialContext);
         },
 
-        _adoptMany() {
+        _adoptMany(map = {}) {
+          for (const [id, fn] of Object.entries(map ?? {})) {
+            if (!entries.has(id)) {
+              registry.register(id, fn);
+            }
+          }
           return registry;
         }
       }, registryStore, type);
@@ -4056,7 +4240,11 @@
         },
 
         _adoptMany(map = {}) {
-          for (const pattern of Object.keys(map ?? {})) {
+          for (const [pattern, definition] of Object.entries(map ?? {})) {
+            if (!entries.has(pattern)) {
+              registry.register(pattern, definition);
+              continue;
+            }
             adoptRoute(pattern, entries.get(pattern));
           }
           return registry;
@@ -4168,7 +4356,10 @@
           }
           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);
         },
@@ -4549,7 +4740,7 @@
     const { createRouteRegistry, createRouter } = __routerModule;
     const { createScheduler } = __schedulerModule;
     const { createServerNamespace } = __serverModule;
-    const { createSignal, createSignalRegistry } = __signalsModule;
+    const { cloneSignalDeclaration, createSignal, createSignalRegistry } = __signalsModule;
     const { createRegistryStore } = __registryStoreModule;
     const { attributeName, normalizeAttributeConfig } = __attributesModule;
     const { createLazyRegistry, defineRegistrySnapshot, sameRegistryValue } = __lazyRegistryModule;
@@ -4632,7 +4823,7 @@
         registryAssets: options.registryAssets,
         importModule: options.importModule
       });
-      const registry = options.registry ?? app.registry.view({ target });
+      const registry = options.registry ?? createRuntimeRegistry(app.registry, { target });
       const signals = options.signals ?? createSignalRegistry(undefined, { registry, type: "signal", lazyRegistry });
       const handlers = options.handlers ?? createHandlerRegistry(undefined, { registry, type: "handler", lazyRegistry });
       const serverCache = createCacheRegistry(undefined, { registry, type: "cache.server" });
@@ -5013,6 +5204,22 @@
       registry?.registerMany?.(entries);
     }
 
+    function createRuntimeRegistry(appRegistry, { target } = {}) {
+      const declarations = appRegistry.rawSnapshot();
+      return createRegistryStore({
+        ...declarations,
+        signal: cloneSignalDeclarations(declarations.signal)
+      }, { target });
+    }
+
+    function cloneSignalDeclarations(signals = {}) {
+      const cloned = {};
+      for (const [id, signalLike] of Object.entries(signals ?? {})) {
+        cloned[id] = cloneSignalDeclaration(signalLike);
+      }
+      return cloned;
+    }
+
     function emptyDeclarations() {
       return {
         signal: {},
@@ -5204,6 +5411,13 @@
     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;
       }
@@ -5213,6 +5427,17 @@
       }
     }
 
+    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;