@async/framework 0.11.3 → 0.11.5

package/server.js

@@ -1220,10 +1220,16 @@ const __signalsModule = (() => {
     let subscriptionCounter = 0;
     let effectCounter = 0;
 
+    for (const id of entries.keys()) {
+      if (asyncDescriptors.has(id)) {
+        throw new Error(`Signal "${id}" is already registered.`);
+      }
+    }
+
     const registry = attachRegistryInspection({
       register(id, signalLike) {
         assertId(id);
-        if (entries.has(id)) {
+        if (entries.has(id) || asyncDescriptors.has(id)) {
           throw new Error(`Signal "${id}" is already registered.`);
         }
         const entry = normalizeSignal(signalLike);
@@ -1241,14 +1247,19 @@ const __signalsModule = (() => {
 
       unregister(id) {
         assertId(id);
-        if (!entries.has(id)) {
+        const hadEntry = entries.has(id);
+        const hadDescriptor = asyncDescriptors.has(id);
+        if (!hadEntry && !hadDescriptor) {
           return false;
         }
-        registryCleanups.get(id)?.();
-        registryCleanups.delete(id);
-        entries.get(id)?._dispose?.();
-        entries.delete(id);
-        boundEntries.delete(id);
+        if (hadEntry) {
+          registryCleanups.get(id)?.();
+          registryCleanups.delete(id);
+          entries.get(id)?._dispose?.();
+          entries.delete(id);
+          boundEntries.delete(id);
+        }
+        asyncDescriptors.delete(id);
         return true;
       },
 
@@ -1410,6 +1421,24 @@ const __signalsModule = (() => {
         return requireEntry(entries, id);
       },
 
+      _setPath(path, value) {
+        const parsed = parseRootPath(path);
+        if (!entries.has(parsed.id)) {
+          if (asyncDescriptors.has(parsed.id)) {
+            materializeAsyncSignal(parsed.id);
+          } else {
+            registry.register(parsed.id, createSignal(parsed.parts.length === 0 ? value : {}));
+          }
+        }
+        const entry = requireEntry(entries, parsed.id);
+        if (parsed.parts.length === 0) {
+          return entry.set(value);
+        }
+        const nextValue = setPath(entry.value, parsed.parts, value);
+        entry.set(nextValue);
+        return value;
+      },
+
       _setContext(context = {}) {
         Object.assign(runtimeContext, context);
         return registry;
@@ -1422,6 +1451,9 @@ const __signalsModule = (() => {
       _adoptMany(map = {}) {
         for (const [id, signalLike] of Object.entries(map ?? {})) {
           if (!entries.has(id)) {
+            if (asyncDescriptors.has(id)) {
+              throw new Error(`Signal "${id}" is already registered.`);
+            }
             const entry = cloneSignalDeclaration(signalLike);
             entries.set(id, entry);
             bindEntry(id, entry);
@@ -1466,6 +1498,14 @@ const __signalsModule = (() => {
       return { id, parts, path };
     }
 
+    function parseRootPath(path) {
+      if (typeof path !== "string" || path.length === 0) {
+        throw new TypeError("Signal path must be a non-empty string.");
+      }
+      const [id, ...parts] = path.split(".");
+      return { id, parts, path };
+    }
+
     function materializeAsyncSignal(id) {
       if (entries.has(id) || !asyncDescriptors.has(id)) {
         return;
@@ -5006,7 +5046,7 @@ const __appModule = (() => {
 
         if (result.signals) {
           for (const [path, value] of Object.entries(result.signals)) {
-            setOrRegisterSignal(signals, path, value);
+            applySignalPatch(signals, path, value);
           }
         }
         if (result.cache?.browser) {
@@ -5284,8 +5324,9 @@ const __appModule = (() => {
 
   function applySnapshotToRuntime(runtime, snapshot = {}, options = {}) {
     const normalized = normalizeSnapshot(snapshot);
-    for (const [path, value] of Object.entries(normalized.signal)) {
-      setOrRegisterSignal(runtime.signals, path, value);
+    mergeRegistryEntries(runtime, "asyncSignal", normalized.asyncSignal, null, options);
+    for (const [id, value] of Object.entries(normalized.signal)) {
+      restoreSignalEntry(runtime.signals, id, value);
     }
     runtime.browser.cache.restore(normalized.cache.browser);
     mergeRegistryEntries(runtime, "handler", normalized.handler, runtime.handlers, options);
@@ -5293,7 +5334,6 @@ const __appModule = (() => {
     mergeRegistryEntries(runtime, "partial", normalized.partial, runtime.partials, options);
     mergeRegistryEntries(runtime, "route", normalized.route, runtime.routes, options);
     mergeRegistryEntries(runtime, "component", normalized.component, runtime.components, options);
-    mergeRegistryEntries(runtime, "asyncSignal", normalized.asyncSignal, null, options);
     return runtime;
   }
 
@@ -5314,6 +5354,9 @@ const __appModule = (() => {
       return;
     }
     for (const [id, value] of Object.entries(entries)) {
+      if (type === "asyncSignal" && runtime.signals?.has?.(id) && !runtime.registry.has(type, id)) {
+        throw new Error(`Signal "${id}" is already registered.`);
+      }
       registerSnapshotEntry(runtime.registry, type, id, value, options);
     }
     concreteRegistry?._adoptMany?.(entries);
@@ -5399,16 +5442,26 @@ const __appModule = (() => {
     }
   }
 
-  function setOrRegisterSignal(signals, path, value) {
-    const id = String(path).split(".")[0];
+  function restoreSignalEntry(signals, id, value) {
     if (signals.has?.(id)) {
-      if (path === id) {
-        const entry = signals._entry?.(id);
-        if (typeof entry?._restore === "function" && isAsyncSignalSnapshot(value)) {
-          entry._restore(value);
-          return;
-        }
+      const entry = signals._entry?.(id);
+      if (typeof entry?._restore === "function" && isAsyncSignalSnapshot(value)) {
+        entry._restore(value);
+        return;
       }
+      signals.set(id, value);
+      return;
+    }
+    signals.register(id, createSignal(value));
+  }
+
+  function applySignalPatch(signals, path, value) {
+    if (typeof signals._setPath === "function") {
+      signals._setPath(path, value);
+      return;
+    }
+    const id = String(path).split(".")[0];
+    if (signals.has?.(id)) {
       signals.set(path, value);
       return;
     }