@async/framework 0.11.1 → 0.11.3

package/server.js

@@ -187,6 +187,28 @@ const __asyncSignalModule = (() => {
         };
       },
 
+      _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;
@@ -272,6 +294,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,
@@ -919,7 +962,12 @@ const __cacheModule = (() => {
         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);
@@ -1077,6 +1125,10 @@ const __signalsModule = (() => {
 
       snapshot() {
         return value;
+      },
+
+      _cloneSignalDeclaration() {
+        return createSignal(value);
       }
     };
 
@@ -1119,6 +1171,10 @@ const __signalsModule = (() => {
         return backing.snapshot();
       },
 
+      _cloneSignalDeclaration() {
+        return computed(fn);
+      },
+
       _bindRegistry(registry, id) {
         return registry.effect(() => {
           backing.set(fn.call({
@@ -1143,6 +1199,9 @@ const __signalsModule = (() => {
       [effectKind]: true,
       kind: "effect",
       fn,
+      _cloneSignalDeclaration() {
+        return effect(fn);
+      },
       _bindRegistry(registry) {
         return registry.effect(fn);
       }
@@ -1361,10 +1420,14 @@ const __signalsModule = (() => {
       },
 
       _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;
       }
@@ -1442,6 +1505,16 @@ const __signalsModule = (() => {
     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");
   }
@@ -1620,7 +1693,7 @@ const __signalsModule = (() => {
       frame.add(path);
     }
   }
-  return { createSignal, computed, effect, createSignalRegistry, isSignalRef, signal };
+  return { createSignal, computed, effect, createSignalRegistry, cloneSignalDeclaration, isSignalRef, signal };
 })();
 
 const __htmlModule = (() => {
@@ -1862,7 +1935,12 @@ const __componentModule = (() => {
         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);
@@ -1910,12 +1988,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") {
@@ -1923,7 +2005,7 @@ const __componentModule = (() => {
             }
           }, {
             scope,
-            key: `attach:${attachHooks.indexOf(hook)}`
+            key: `attach:${index}`
           }) ?? runAttachHook(hook, target);
         }
       },
@@ -1931,8 +2013,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") {
@@ -1940,12 +2026,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() {
@@ -2201,11 +2287,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));
     }
@@ -2246,6 +2333,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);
@@ -2264,15 +2356,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;
   }
@@ -2291,6 +2375,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) {
@@ -2368,10 +2461,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() };
   }
@@ -2484,6 +2604,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);
@@ -2497,6 +2620,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)}`;
   }
@@ -2518,6 +2651,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.");
@@ -2643,7 +2780,12 @@ const __handlersModule = (() => {
         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);
@@ -2750,7 +2892,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;
@@ -2798,7 +2941,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;
         }
 
@@ -2902,14 +3045,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() {
@@ -2921,7 +3079,7 @@ const __schedulerModule = (() => {
           strategy,
           phases: [...phases],
           pending: counts,
-          scopesDestroyed: destroyedScopes.size,
+          scopesDestroyed: destroyedPrimitiveScopes.size,
           flushing,
           scheduled
         };
@@ -2936,7 +3094,7 @@ const __schedulerModule = (() => {
           queue.length = 0;
         }
         keyedJobs.clear();
-        destroyedScopes.clear();
+        destroyedPrimitiveScopes.clear();
       }
     };
 
@@ -2976,7 +3134,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 {
@@ -3033,6 +3191,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) {
@@ -3093,6 +3265,7 @@ const __loaderModule = (() => {
 
       scan(rootOrFragment = rootNode) {
         assertActive();
+        reviveScopes(rootOrFragment);
         bindSignalAttributes(rootOrFragment);
         bindClassAttributes(rootOrFragment);
         bindEventAttributes(rootOrFragment);
@@ -3596,6 +3769,12 @@ const __loaderModule = (() => {
       }
     }
 
+    function reviveScopes(scope) {
+      for (const element of elementsIn(scope)) {
+        schedulerInstance.reviveScope?.(element);
+      }
+    }
+
     return api;
   }
 
@@ -3895,7 +4074,12 @@ const __partialsModule = (() => {
         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);
@@ -4047,7 +4231,11 @@ const __routerModule = (() => {
       },
 
       _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;
@@ -4159,7 +4347,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);
       },
@@ -4540,7 +4731,7 @@ const __appModule = (() => {
   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;
@@ -4623,7 +4814,7 @@ const __appModule = (() => {
       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" });
@@ -5004,6 +5195,22 @@ const __appModule = (() => {
     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: {},
@@ -5195,6 +5402,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;
     }
@@ -5204,6 +5418,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;
@@ -5454,7 +5679,12 @@ const __serverRegistryModule = (() => {
         return registry;
       },
 
-      _adoptMany() {
+      _adoptMany(map = {}) {
+        for (const [id, fn] of Object.entries(map ?? {})) {
+          if (!entries.has(id)) {
+            registry.register(id, fn);
+          }
+        }
         return registry;
       }
     }, registryStore, type);