@tstdl/base 0.88.6 → 0.88.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.88.6",
+  "version": "0.88.7",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/signals/implementation/graph.d.ts

@@ -9,21 +9,8 @@ type Version = number & {
     __brand: 'Version';
 };
 export declare function setActiveConsumer(consumer: ReactiveNode | null): ReactiveNode | null;
-export declare const REACTIVE_NODE: {
-    version: Version;
-    dirty: boolean;
-    producerNode: undefined;
-    producerLastReadVersion: undefined;
-    producerIndexOfThis: undefined;
-    nextProducerIndex: number;
-    liveConsumerNode: undefined;
-    liveConsumerIndexOfThis: undefined;
-    consumerAllowSignalWrites: boolean;
-    consumerIsAlwaysLive: boolean;
-    producerMustRecompute: () => boolean;
-    producerRecomputeValue: () => void;
-    consumerMarkedDirty: () => void;
-};
+export declare function isInNotificationPhase(): boolean;
+export declare const REACTIVE_NODE: ReactiveNode;
 /**
  * A producer and/or consumer which participates in the reactive graph.
  *

package/signals/implementation/graph.js

@@ -17,6 +17,9 @@ export function setActiveConsumer(consumer) {
     activeConsumer = consumer;
     return prev;
 }
+export function isInNotificationPhase() {
+    return inNotificationPhase;
+}
 export const REACTIVE_NODE = {
     version: 0,
     dirty: false,
@@ -153,7 +156,9 @@ export function consumerAfterComputation(node, prevConsumer) {
         }
     }
     // Truncate the producer tracking arrays.
-    for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
+    // Perf note: this is essentially truncating the length to `node.nextProducerIndex`, but
+    // benchmarking has shown that individual pop operations are faster.
+    while (node.producerNode.length > node.nextProducerIndex) {
         node.producerNode.pop();
         node.producerLastReadVersion.pop();
         node.producerIndexOfThis.pop();

package/signals/implementation/to-observable.d.ts

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import type { Signal } from './api.js';
 /**
- * Exposes the value of an Angular `Signal` as an RxJS `Observable`.
+ * Exposes the value of an `Signal` as an RxJS `Observable`.
  *
  * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
  */

package/signals/implementation/to-observable.js

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { effect } from './effect.js';
 import { untracked } from './untracked.js';
 /**
- * Exposes the value of an Angular `Signal` as an RxJS `Observable`.
+ * Exposes the value of an `Signal` as an RxJS `Observable`.
  *
  * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
  */

package/signals/implementation/watch.d.ts

@@ -24,5 +24,11 @@ export interface Watch {
      */
     run(): void;
     cleanup(): void;
+    /**
+     * Destroy the watcher:
+     * - disconnect it from the reactive graph;
+     * - mark it as destroyed so subsequent run and notify operations are noop.
+     */
+    destroy(): void;
 }
 export declare function watch(fn: (onCleanup: WatchCleanupRegisterFn) => void, schedule: (watch: Watch) => void, allowSignalWrites: boolean): Watch;

package/signals/implementation/watch.js

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { consumerAfterComputation, consumerBeforeComputation, consumerMarkDirty, consumerPollProducersForChange, REACTIVE_NODE } from './graph.js';
+import { consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, isInNotificationPhase, REACTIVE_NODE } from './graph.js';
 export function watch(fn, schedule, allowSignalWrites) {
     const node = Object.create(WATCH_NODE);
     if (allowSignalWrites) {
@@ -16,7 +16,27 @@ export function watch(fn, schedule, allowSignalWrites) {
     const registerOnCleanup = (cleanupFn) => {
         node.cleanupFn = cleanupFn;
     };
+    function isWatchNodeDestroyed(node) {
+        return node.fn === null && node.schedule === null;
+    }
+    function destroyWatchNode(node) {
+        if (!isWatchNodeDestroyed(node)) {
+            consumerDestroy(node); // disconnect watcher from the reactive graph
+            node.cleanupFn();
+            // nullify references to the integration functions to mark node as destroyed
+            node.fn = null;
+            node.schedule = null;
+            node.cleanupFn = NOOP_CLEANUP_FN;
+        }
+    }
     const run = () => {
+        if (node.fn === null) {
+            // trying to run a destroyed watch is noop
+            return;
+        }
+        if (isInNotificationPhase()) {
+            throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
+        }
         node.dirty = false;
         if (node.hasRun && !consumerPollProducersForChange(node)) {
             return;
@@ -36,6 +56,7 @@ export function watch(fn, schedule, allowSignalWrites) {
         notify: () => consumerMarkDirty(node),
         run,
         cleanup: () => node.cleanupFn(),
+        destroy: () => destroyWatchNode(node),
     };
     return node.ref;
 }
@@ -45,7 +66,9 @@ const WATCH_NODE = {
     consumerIsAlwaysLive: true,
     consumerAllowSignalWrites: false,
     consumerMarkedDirty: (node) => {
-        node.schedule(node.ref);
+        if (node.schedule !== null) {
+            node.schedule(node.ref);
+        }
     },
     hasRun: false,
     cleanupFn: NOOP_CLEANUP_FN,

package/signals/index.d.ts

@@ -4,6 +4,7 @@ export * from './effect-with-dependencies.js';
 export * from './lazylize.js';
 export * from './pipe.js';
 export * from './switch-map.js';
+export * from './to-observable-2.js';
 export * from './to-signal-2.js';
 export * from './types.js';
 export * from './untracked-operator.js';

package/signals/index.js

@@ -4,6 +4,7 @@ export * from './effect-with-dependencies.js';
 export * from './lazylize.js';
 export * from './pipe.js';
 export * from './switch-map.js';
+export * from './to-observable-2.js';
 export * from './to-signal-2.js';
 export * from './types.js';
 export * from './untracked-operator.js';

package/signals/to-observable-2.d.ts

@@ -0,0 +1,8 @@
+import type { Observable } from 'rxjs';
+import type { Signal } from './api.js';
+/**
+ * Exposes the value of an `Signal` as an RxJS `Observable`.
+ *
+ * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
+ */
+export declare function toObservable2<T>(source: Signal<T>): Observable<T>;

package/signals/to-observable-2.js

@@ -0,0 +1,9 @@
+import { toObservable } from './implementation/to-observable.js';
+/**
+ * Exposes the value of an `Signal` as an RxJS `Observable`.
+ *
+ * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
+ */
+export function toObservable2(source) {
+    return toObservable(source);
+}

package/signals/to-signal-2.d.ts

@@ -5,7 +5,10 @@ export type ToSignal2Options<T> = ToSignalOptions<T> & {
     /** defer subscription until signal is used */
     lazy?: boolean;
 };
-/** like `toSignal`, except that it uses untracked internal operations (required for some scenarios, but might be less safe in terms of bugs catching) and has the ability to subscribe lazily */
+/**
+ * Like `toSignal`, except that it uses untracked internal operations (required for some scenarios, but might be less safe in terms of bugs catching) and has the ability to subscribe lazily.
+ * Subscription to observable is cleaned up using finalization (garbage collection) of the signal.
+ */
 export declare function toSignal2<T>(source: ToSignalInput<T>): Signal<T | undefined>;
 export declare function toSignal2<T>(source: ToSignalInput<T>, options: ToSignal2Options<undefined> & {
     requireSync: true;