@async/framework 0.11.3 → 0.11.5

package/browser.ts

@@ -1219,10 +1219,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);
@@ -1240,14 +1246,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;
       },
 
@@ -1409,6 +1420,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;
@@ -1421,6 +1450,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);
@@ -1465,6 +1497,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;
@@ -5005,7 +5045,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) {
@@ -5283,8 +5323,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);
@@ -5292,7 +5333,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;
   }
 
@@ -5313,6 +5353,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);
@@ -5398,16 +5441,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;
     }

package/browser.umd.js

@@ -1229,10 +1229,16 @@
       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);
@@ -1250,14 +1256,19 @@
 
         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;
         },
 
@@ -1419,6 +1430,24 @@
           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;
@@ -1431,6 +1460,9 @@
         _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);
@@ -1475,6 +1507,14 @@
         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;
@@ -5015,7 +5055,7 @@
 
           if (result.signals) {
             for (const [path, value] of Object.entries(result.signals)) {
-              setOrRegisterSignal(signals, path, value);
+              applySignalPatch(signals, path, value);
             }
           }
           if (result.cache?.browser) {
@@ -5293,8 +5333,9 @@
 
     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);
@@ -5302,7 +5343,6 @@
       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;
     }
 
@@ -5323,6 +5363,9 @@
         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);
@@ -5408,16 +5451,26 @@
       }
     }
 
-    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;
       }