@async/framework 0.11.4 → 0.11.6

package/browser.umd.js

@@ -30,8 +30,9 @@
       let version = 0;
       let registry;
       let registeredId = id;
-      let activeController;
-      let activeAbort;
+      let activeRun;
+      let executionToken = 0;
+      let disposed = false;
       const subscribers = new Set();
       const dependencyCleanups = new Set();
 
@@ -73,109 +74,62 @@
         },
 
         refresh() {
-          if (!registry) {
+          if (!registry || disposed) {
             throw new Error(`Async signal "${registeredId}" is not registered.`);
           }
 
-          if (activeAbort && !activeAbort.aborted) {
-            activeAbort.cancel(new Error(`Async signal "${registeredId}" refreshed.`));
-          }
+          cancelRun(activeRun, new Error(`Async signal "${registeredId}" refreshed.`));
 
+          const runRegistry = registry;
+          const runId = registeredId;
           const runVersion = version + 1;
           version = runVersion;
           loading = true;
           error = null;
           status = "loading";
 
-          const controller = new AbortController();
-          activeController = controller;
-          activeAbort = controller.signal;
-          attachCancel(activeAbort, controller);
+          const run = createRun(runRegistry, runId, runVersion);
+          activeRun = run;
           notify();
 
-          const context = {
-            signals: registry,
-            id: registeredId,
-            get server() {
-              const context = registry._context?.() ?? {};
-              const server = context.server;
-              if (typeof server?._withContext === "function") {
-                return server._withContext({
-                  signals: registry,
-                  router: context.router,
-                  loader: context.loader,
-                  cache: context.cache,
-                  abort: activeAbort,
-                  scheduler: context.scheduler
-                });
-              }
-              return server;
-            },
-            get router() {
-              return registry._context?.().router;
-            },
-            get loader() {
-              return registry._context?.().loader;
-            },
-            get cache() {
-              return registry._context?.().cache;
-            },
-            get scheduler() {
-              return registry._context?.().scheduler;
-            },
-            get version() {
-              return runVersion;
-            },
-            get abort() {
-              return activeAbort;
-            },
-            refresh() {
-              return state.refresh();
-            }
-          };
+          const context = createRunContext(run);
 
           let outcome;
           try {
-            outcome = registry._collectDependencies(() => fn.call(context));
+            outcome = runRegistry._collectDependencies(() => fn.call(context));
           } catch (cause) {
-            finishError(runVersion, cause);
+            finishError(run, cause);
             return Promise.reject(cause);
           }
 
-          syncDependencies(outcome.dependencies);
+          syncDependencies(outcome.dependencies, run);
 
           return Promise.resolve(outcome.value).then(
             (nextValue) => {
-              if (!isCurrent(runVersion)) {
+              if (!isRunCurrent(run)) {
                 return value;
               }
               value = nextValue;
               loading = false;
               error = null;
               status = "ready";
+              activeRun = undefined;
               notify();
               return value;
             },
             (cause) => {
-              if (!isCurrent(runVersion)) {
+              if (!isRunCurrent(run)) {
                 return value;
               }
-              if (activeAbort?.aborted) {
-                loading = false;
-                status = value === undefined ? "idle" : "ready";
-                notify();
-                return value;
-              }
-              finishError(runVersion, cause);
+              finishError(run, cause);
               return value;
             }
           );
         },
 
         cancel(reason) {
-          if (activeAbort && !activeAbort.aborted) {
-            activeAbort.cancel(reason);
-          }
+          cancelCurrentRun(reason, { settle: true, notifyChange: true });
+          return value;
         },
 
         subscribe(fn) {
@@ -204,9 +158,7 @@
           if (!isAsyncSignalSnapshot(snapshot)) {
             return state.set(snapshot);
           }
-          if (activeAbort && !activeAbort.aborted) {
-            activeAbort.cancel(new Error(`Async signal "${registeredId}" restored from snapshot.`));
-          }
+          cancelCurrentRun(new Error(`Async signal "${registeredId}" restored from snapshot.`));
           value = snapshot.value;
           loading = Boolean(snapshot.loading);
           error = snapshot.error ?? null;
@@ -222,7 +174,7 @@
           registry = nextRegistry;
           registeredId = nextId;
           const start = () => {
-            if (registry === nextRegistry && status === "idle") {
+            if (!disposed && registry === nextRegistry && status === "idle") {
               state.refresh();
             }
           };
@@ -238,30 +190,161 @@
         },
 
         _dispose() {
-          state.cancel(new Error(`Async signal "${registeredId}" disposed.`));
+          if (disposed) {
+            return;
+          }
+          disposed = true;
+          cancelQueuedWork();
+          cancelCurrentRun(new Error(`Async signal "${registeredId}" disposed.`));
           for (const cleanup of dependencyCleanups) {
             cleanup();
           }
           dependencyCleanups.clear();
           subscribers.clear();
+          registry = undefined;
         }
       };
 
-      function finishError(runVersion, cause) {
-        if (!isCurrent(runVersion)) {
+      function createRun(runRegistry, runId, runVersion) {
+        const controller = new AbortController();
+        const abort = controller.signal;
+        const runContext = captureRunContext(runRegistry, abort);
+        const run = {
+          token: ++executionToken,
+          version: runVersion,
+          registry: runRegistry,
+          id: runId,
+          controller,
+          abort,
+          ...runContext
+        };
+        attachCancel(abort, controller, (reason) => {
+          cancelRun(run, reason, { settle: true, notifyChange: true });
+        });
+        return run;
+      }
+
+      function captureRunContext(runRegistry, abort) {
+        const context = runRegistry._context?.() ?? {};
+        const serverContext = {
+          signals: runRegistry,
+          router: context.router,
+          loader: context.loader,
+          cache: context.cache,
+          abort,
+          scheduler: context.scheduler
+        };
+        const server = typeof context.server?._withContext === "function"
+          ? context.server._withContext(serverContext)
+          : context.server;
+
+        return {
+          signals: runRegistry,
+          server,
+          router: context.router,
+          loader: context.loader,
+          cache: context.cache,
+          scheduler: context.scheduler
+        };
+      }
+
+      function createRunContext(run) {
+        return {
+          signals: run.signals,
+          id: run.id,
+          get server() {
+            return run.server;
+          },
+          get router() {
+            return run.router;
+          },
+          get loader() {
+            return run.loader;
+          },
+          get cache() {
+            return run.cache;
+          },
+          get scheduler() {
+            return run.scheduler;
+          },
+          get version() {
+            return run.version;
+          },
+          get abort() {
+            return run.abort;
+          },
+          refresh() {
+            return state.refresh();
+          }
+        };
+      }
+
+      function finishError(run, cause) {
+        if (!isRunCurrent(run)) {
           return;
         }
         loading = false;
         error = cause;
         status = "error";
+        activeRun = undefined;
         notify();
       }
 
-      function isCurrent(runVersion) {
-        return runVersion === version && activeController?.signal === activeAbort;
+      function isRunCurrent(run) {
+        return Boolean(run)
+          && !disposed
+          && activeRun === run
+          && run.token === executionToken
+          && run.registry === registry
+          && run.id === registeredId
+          && !run.abort.aborted;
+      }
+
+      function cancelCurrentRun(reason, options = {}) {
+        const run = activeRun;
+        const shouldSettle = Boolean(run) || loading;
+        if (run) {
+          cancelRun(run, reason);
+        } else if (shouldSettle) {
+          executionToken += 1;
+        }
+        if (options.settle && shouldSettle && !disposed) {
+          settleCanceled(options.notifyChange);
+        }
       }
 
-      function syncDependencies(dependencies) {
+      function cancelRun(run, reason, options = {}) {
+        if (!run) {
+          return;
+        }
+        const wasActive = activeRun === run;
+        if (wasActive) {
+          executionToken += 1;
+          activeRun = undefined;
+        }
+        if (!run.abort.aborted) {
+          run.controller.abort(reason);
+        }
+        if (wasActive && options.settle && !disposed) {
+          settleCanceled(options.notifyChange);
+        }
+      }
+
+      function settleCanceled(notifyChange = false) {
+        const nextStatus = value === undefined ? "idle" : "ready";
+        const changed = loading || error !== null || status !== nextStatus;
+        loading = false;
+        error = null;
+        status = nextStatus;
+        if (notifyChange && changed) {
+          notify();
+        }
+      }
+
+      function syncDependencies(dependencies, run) {
+        if (!isRunCurrent(run)) {
+          return;
+        }
         for (const cleanup of dependencyCleanups) {
           cleanup();
         }
@@ -270,15 +353,16 @@
         for (const dependency of dependencies) {
           const dependencyId = String(dependency).split(".")[0];
           if (dependencyId && dependencyId !== registeredId) {
-            dependencyCleanups.add(registry.subscribe(dependency, () => scheduleRefresh()));
+            dependencyCleanups.add(run.registry.subscribe(dependency, () => scheduleRefresh()));
           }
         }
       }
 
       function scheduleRefresh() {
-        if (activeAbort && !activeAbort.aborted) {
-          activeAbort.cancel(new Error(`Async signal "${registeredId}" dependency changed.`));
+        if (disposed || !registry) {
+          return;
         }
+        cancelRun(activeRun, new Error(`Async signal "${registeredId}" dependency changed.`));
         const scheduler = registry?._context?.().scheduler;
         if (!scheduler) {
           state.refresh();
@@ -290,6 +374,11 @@
         });
       }
 
+      function cancelQueuedWork() {
+        const scheduler = registry?._context?.().scheduler;
+        scheduler?.cancelScope?.(registeredId);
+      }
+
       function notify() {
         for (const subscriber of [...subscribers]) {
           subscriber(state);
@@ -324,11 +413,15 @@
       return value === undefined ? "idle" : "ready";
     }
 
-    function attachCancel(signal, controller) {
+    function attachCancel(signal, controller, onCancel) {
       Object.defineProperty(signal, "cancel", {
         configurable: true,
         enumerable: false,
         value(reason) {
+          if (typeof onCancel === "function") {
+            onCancel(reason);
+            return;
+          }
           controller.abort(reason);
         }
       });
@@ -1229,10 +1322,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 +1349,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;
         },
 
@@ -1449,6 +1553,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);
@@ -5349,6 +5456,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);