@tstdl/base 0.90.13 → 0.90.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.13",
+  "version": "0.90.14",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -109,7 +109,7 @@
     "luxon": "^3.4",
     "reflect-metadata": "^0.1",
     "rxjs": "^7.8",
-    "type-fest": "^4.4"
+    "type-fest": "^4.5"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -120,8 +120,8 @@
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "6.7",
-    "@typescript-eslint/parser": "6.7",
+    "@typescript-eslint/eslint-plugin": "6.8",
+    "@typescript-eslint/parser": "6.8",
     "concurrently": "8.2",
     "esbuild": "0.19",
     "eslint": "8.51",

package/rxjs/index.d.ts

@@ -11,3 +11,4 @@ export * from './start-with-provider.js';
 export * from './teardown.js';
 export * from './timing.js';
 export * from './touch.js';
+export * from './untrack.js';

package/rxjs/index.js

@@ -11,3 +11,4 @@ export * from './start-with-provider.js';
 export * from './teardown.js';
 export * from './timing.js';
 export * from './touch.js';
+export * from './untrack.js';

package/rxjs/untrack.d.ts

@@ -0,0 +1,2 @@
+import type { MonoTypeOperatorFunction } from 'rxjs';
+export declare function untrack<T>(): MonoTypeOperatorFunction<T>;

package/rxjs/untrack.js

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { untracked } from '../signals/api.js';
+export function untrack() {
+    return function untrack(source) {
+        return new Observable((subscriber) => source.subscribe({
+            next: (state) => untracked(() => subscriber.next(state)),
+            complete: () => untracked(() => subscriber.complete()),
+            error: (error) => untracked(() => subscriber.error(error))
+        }));
+    };
+}

package/signals/implementation/api.d.ts

@@ -5,12 +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
  */
-/**
- * Symbol used to tell `Signal`s apart from other functions.
- *
- * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
- */
-export declare const SIGNAL: unique symbol;
+import { SIGNAL } from '../symbol.js';
 /**
  * A reactive value which notifies consumers of any changes.
  *
@@ -27,15 +22,3 @@ export interface Signal<T> {
  * Checks if the given `value` is a reactive `Signal`.
  */
 export declare function isSignal(value: unknown): value is Signal<unknown>;
-/**
- * A comparison function which can determine if two values are equal.
- */
-export type ValueEqualityFn<T> = (a: T, b: T) => boolean;
-/**
- * The default equality function used for `signal` and `computed`, which treats objects and arrays
- * as never equal, and all other primitive values using identity semantics.
- *
- * This allows signals to hold non-primitive values (arrays, objects, other collections) and still
- * propagate change notification upon explicit mutation without identity change.
- */
-export declare function defaultEquals<T>(a: T, b: T): boolean;

package/signals/implementation/api.js

@@ -5,30 +5,10 @@
  * 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
  */
-/**
- * Symbol used to tell `Signal`s apart from other functions.
- *
- * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
- */
-export const SIGNAL = Symbol('SIGNAL');
+import { SIGNAL } from '../symbol.js';
 /**
  * Checks if the given `value` is a reactive `Signal`.
  */
 export function isSignal(value) {
     return typeof value === 'function' && value[SIGNAL] !== undefined;
 }
-/**
- * The default equality function used for `signal` and `computed`, which treats objects and arrays
- * as never equal, and all other primitive values using identity semantics.
- *
- * This allows signals to hold non-primitive values (arrays, objects, other collections) and still
- * propagate change notification upon explicit mutation without identity change.
- */
-export function defaultEquals(a, b) {
-    // `Object.is` compares two values using identity semantics which is desired behavior for
-    // primitive values. If `Object.is` determines two values to be equal we need to make sure that
-    // those don't represent objects (we want to make sure that 2 objects are always considered
-    // "unequal"). The null check is needed for the special case of JavaScript reporting null values
-    // as objects (`typeof null === 'object'`).
-    return (a === null || typeof a !== 'object') && Object.is(a, b);
-}

package/signals/implementation/asserts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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
+ */
+/**
+ * Asserts that the current stack frame is not within a reactive context. Useful
+ * to disallow certain code from running inside a reactive context (see {@link toSignal}).
+ *
+ * @param debugFn a reference to the function making the assertion (used for the error message).
+ *
+ * @publicApi
+ */
+export declare function assertNotInReactiveContext(debugFn: Function, extraContext?: string): void;

package/signals/implementation/asserts.js

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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 { getActiveConsumer } from './graph.js';
+/**
+ * Asserts that the current stack frame is not within a reactive context. Useful
+ * to disallow certain code from running inside a reactive context (see {@link toSignal}).
+ *
+ * @param debugFn a reference to the function making the assertion (used for the error message).
+ *
+ * @publicApi
+ */
+export function assertNotInReactiveContext(debugFn, extraContext) {
+    // Taking a `Function` instead of a string name here prevents the un-minified name of the function
+    // from being retained in the bundle regardless of minification.
+    if (getActiveConsumer() !== null) {
+        throw new Error(`${debugFn.name}() cannot be called from within a reactive context.${extraContext ? ` ${extraContext}` : ''}`);
+    }
+}

package/signals/implementation/computed.d.ts

@@ -5,7 +5,39 @@
  * 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 type { Signal, ValueEqualityFn } from './api.js';
+import { SIGNAL } from '../symbol.js';
+import type { Signal } from './api.js';
+import type { ValueEqualityFn } from './equality.js';
+import type { ReactiveNode } from './graph.js';
+/**
+ * A computation, which derives a value from a declarative reactive expression.
+ *
+ * `Computed`s are both producers and consumers of reactivity.
+ */
+export interface ComputedNode<T> extends ReactiveNode {
+    /**
+     * Current value of the computation, or one of the sentinel values above (`UNSET`, `COMPUTING`,
+     * `ERROR`).
+     */
+    value: T;
+    /**
+     * If `value` is `ERRORED`, the error caught from the last computation attempt which will
+     * be re-thrown.
+     */
+    error: unknown;
+    /**
+     * The computation function which will produce a new value.
+     */
+    computation: () => T;
+    equal: ValueEqualityFn<T>;
+}
+export type ComputedGetter<T> = (() => T) & {
+    [SIGNAL]: ComputedNode<T>;
+};
+/**
+ * Create a computed signal which derives a reactive value from an expression.
+ */
+export declare function createComputed<T>(computation: () => T): ComputedGetter<T>;
 /**
  * Options passed to the `computed` creation function.
  */

package/signals/implementation/computed.js

@@ -5,15 +5,15 @@
  * 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 { SIGNAL, defaultEquals } from './api.js';
-import { REACTIVE_NODE, consumerAfterComputation, consumerBeforeComputation, producerAccessed, producerUpdateValueVersion } from './graph.js';
+import { SIGNAL } from '../symbol.js';
+import { defaultEquals } from './equality.js';
+import { consumerAfterComputation, consumerBeforeComputation, producerAccessed, producerUpdateValueVersion, REACTIVE_NODE } from './graph.js';
 /**
- * Create a computed `Signal` which derives a reactive value from an expression.
+ * Create a computed signal which derives a reactive value from an expression.
  */
-export function computed(computation, options) {
+export function createComputed(computation) {
     const node = Object.create(COMPUTED_NODE);
     node.computation = computation;
-    options?.equal && (node.equal = options.equal);
     const computed = () => {
         // Check if the value needs updating before returning it.
         producerUpdateValueVersion(node);
@@ -31,19 +31,19 @@ export function computed(computation, options) {
  * A dedicated symbol used before a computed value has been calculated for the first time.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const UNSET = Symbol('UNSET');
+const UNSET = /* @__PURE__ */ Symbol('UNSET');
 /**
  * A dedicated symbol used in place of a computed signal value to indicate that a given computation
  * is in progress. Used to detect cycles in computation chains.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const COMPUTING = Symbol('COMPUTING');
+const COMPUTING = /* @__PURE__ */ Symbol('COMPUTING');
 /**
  * A dedicated symbol used in place of a computed signal value to indicate that a given computation
  * failed. The thrown error is cached until the computation gets dirty again.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const ERRORED = Symbol('ERRORED');
+const ERRORED = /* @__PURE__ */ Symbol('ERRORED');
 const COMPUTED_NODE = {
     ...REACTIVE_NODE,
     value: UNSET,
@@ -51,8 +51,8 @@ const COMPUTED_NODE = {
     error: null,
     equal: defaultEquals,
     producerMustRecompute(node) {
-        // Force a recomputation if there's no current value, or if the current value is in the process
-        // of being calculated (which should throw an error).
+        // Force a recomputation if there's no current value, or if the current value is in the
+        // process of being calculated (which should throw an error).
         return node.value === UNSET || node.value === COMPUTING;
     },
     producerRecomputeValue(node) {
@@ -85,3 +85,13 @@ const COMPUTED_NODE = {
         node.version++;
     },
 };
+/**
+ * Create a computed `Signal` which derives a reactive value from an expression.
+ */
+export function computed(computation, options) {
+    const getter = createComputed(computation);
+    if (options?.equal) {
+        getter[SIGNAL].equal = options.equal;
+    }
+    return getter;
+}

package/signals/implementation/effect.d.ts

@@ -1,10 +1,3 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * 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
- */
 /**
  * An effect can, optionally, register a cleanup function. If registered, the cleanup is executed
  * before the next effect run. The cleanup function makes it possible to "cancel" any work that the
@@ -15,16 +8,34 @@ export type EffectCleanupFn = () => void;
  * A callback passed to the effect function that makes it possible to register cleanup logic.
  */
 export type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;
+export interface SchedulableEffect {
+    run(): void;
+}
 /**
- * Tracks all effects registered within a given application and runs them via `flush`.
+ * A scheduler which manages the execution of effects.
  */
-export declare class EffectManager {
-    private readonly all;
+export declare abstract class EffectScheduler {
+    /**
+     * Schedule the given effect to be executed at a later time.
+     *
+     * It is an error to attempt to execute any effects synchronously during a scheduling operation.
+     */
+    abstract scheduleEffect(e: SchedulableEffect): void;
+}
+/**
+ * Interface to an `EffectScheduler` capable of running scheduled effects synchronously.
+ */
+export interface FlushableEffectRunner {
+    /**
+     * Run any scheduled effects.
+     */
+    flush(): void;
+}
+export declare class TstdlEffectScheduler implements EffectScheduler, FlushableEffectRunner {
     private readonly queue;
     private pendingFlush;
-    create(effectFn: (onCleanup: (cleanupFn: EffectCleanupFn) => void) => void, allowSignalWrites: boolean): EffectRef;
+    scheduleEffect(effect: SchedulableEffect): void;
     flush(): void;
-    get isQueueEmpty(): boolean;
 }
 /**
  * A global reactive effect, which can be manually destroyed.

package/signals/implementation/effect.js

@@ -1,3 +1,4 @@
+/* eslint-disable */
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -5,57 +6,74 @@
  * 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 { watch } from './watch.js';
+import { assertNotInReactiveContext } from './asserts.js';
+import { createWatch } from './watch.js';
 /**
- * Tracks all effects registered within a given application and runs them via `flush`.
+ * A scheduler which manages the execution of effects.
  */
-export class EffectManager {
-    all = new Set();
+export class EffectScheduler {
+}
+export class TstdlEffectScheduler {
     queue = new Set();
-    pendingFlush;
-    create(effectFn, allowSignalWrites) {
-        const w = watch(effectFn, () => {
-            if (!this.all.has(w)) {
-                return;
-            }
-            this.queue.add(w);
-            if (!this.pendingFlush) {
-                this.pendingFlush = true;
-                queueMicrotask(() => {
-                    this.pendingFlush = false;
-                    this.flush();
-                });
-            }
-        }, allowSignalWrites);
-        this.all.add(w);
-        // Effects start dirty.
-        w.notify();
-        const destroy = () => {
-            w.cleanup();
-            this.all.delete(w);
-            this.queue.delete(w);
-        };
-        return {
-            destroy
-        };
+    pendingFlush = false;
+    scheduleEffect(effect) {
+        this.queue.add(effect);
+        if (!this.pendingFlush) {
+            this.pendingFlush = true;
+            queueMicrotask(() => {
+                this.pendingFlush = false;
+                this.flush();
+            });
+        }
     }
     flush() {
-        if (this.queue.size === 0) {
-            return;
-        }
-        for (const w of this.queue) {
-            this.queue.delete(w);
-            w.run();
+        for (const effect of this.queue) {
+            this.queue.delete(effect);
+            effect.run();
         }
     }
-    get isQueueEmpty() {
-        return this.queue.size === 0;
+}
+/**
+ * Core reactive node for an Angular effect.
+ *
+ * `EffectHandle` combines the reactive graph's `Watch` base node for effects with the framework's
+ * scheduling abstraction (`EffectScheduler`) as well as automatic cleanup via `DestroyRef` if
+ * available/requested.
+ */
+class EffectHandle {
+    scheduler;
+    effectFn;
+    watcher;
+    constructor(scheduler, effectFn, allowSignalWrites) {
+        this.scheduler = scheduler;
+        this.effectFn = effectFn;
+        this.watcher = createWatch((onCleanup) => this.runEffect(onCleanup), () => this.schedule(), allowSignalWrites);
+    }
+    runEffect(onCleanup) {
+        this.effectFn(onCleanup);
+    }
+    run() {
+        this.watcher.run();
+    }
+    schedule() {
+        this.scheduler.scheduleEffect(this);
+    }
+    notify() {
+        this.watcher.notify();
+    }
+    destroy() {
+        this.watcher.destroy();
+        // Note: if the effect is currently scheduled, it's not un-scheduled, and so the scheduler will
+        // retain a reference to it. Attempting to execute it will be a no-op.
     }
 }
-const effectManager = new EffectManager();
+const effectScheduler = new TstdlEffectScheduler();
 /**
  * Create a global `Effect` for the given reactive function.
  */
 export function effect(effectFn, options) {
-    return effectManager.create(effectFn, options?.allowSignalWrites ?? false);
+    assertNotInReactiveContext(effect, 'Call `effect` outside of a reactive context. For example, schedule the effect inside the component constructor.');
+    const handle = new EffectHandle(effectScheduler, effectFn, options?.allowSignalWrites ?? false);
+    handle.notify();
+    return handle;
 }

package/signals/implementation/equality.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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
+ */
+/**
+ * A comparison function which can determine if two values are equal.
+ */
+export type ValueEqualityFn<T> = (a: T, b: T) => boolean;
+/**
+ * The default equality function used for `signal` and `computed`, which uses referential equality.
+ */
+export declare function defaultEquals<T>(a: T, b: T): boolean;

package/signals/implementation/equality.js

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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
+ */
+/**
+ * The default equality function used for `signal` and `computed`, which uses referential equality.
+ */
+export function defaultEquals(a, b) {
+    return Object.is(a, b);
+}

package/signals/implementation/graph.d.ts

@@ -5,11 +5,17 @@
  * 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 { SIGNAL } from '../symbol.js';
 type Version = number & {
     __brand: 'Version';
 };
 export declare function setActiveConsumer(consumer: ReactiveNode | null): ReactiveNode | null;
+export declare function getActiveConsumer(): ReactiveNode | null;
 export declare function isInNotificationPhase(): boolean;
+export interface Reactive {
+    [SIGNAL]: ReactiveNode;
+}
+export declare function isReactive(value: unknown): value is Reactive;
 export declare const REACTIVE_NODE: ReactiveNode;
 /**
  * A producer and/or consumer which participates in the reactive graph.
@@ -95,6 +101,10 @@ export interface ReactiveNode {
     producerMustRecompute(node: unknown): boolean;
     producerRecomputeValue(node: unknown): void;
     consumerMarkedDirty(node: unknown): void;
+    /**
+     * Called when a signal is read within this consumer.
+     */
+    consumerOnSignalRead(node: unknown): void;
 }
 /**
  * Called by implementations when a producer's signal is read.

package/signals/implementation/graph.js

@@ -5,6 +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 { SIGNAL } from '../symbol.js';
 /**
  * The currently active consumer `ReactiveNode`, if running code in a reactive context.
  *
@@ -17,9 +18,15 @@ export function setActiveConsumer(consumer) {
     activeConsumer = consumer;
     return prev;
 }
+export function getActiveConsumer() {
+    return activeConsumer;
+}
 export function isInNotificationPhase() {
     return inNotificationPhase;
 }
+export function isReactive(value) {
+    return value[SIGNAL] !== undefined;
+}
 export const REACTIVE_NODE = {
     version: 0,
     dirty: false,
@@ -34,6 +41,7 @@ export const REACTIVE_NODE = {
     producerMustRecompute: () => false,
     producerRecomputeValue: () => { },
     consumerMarkedDirty: () => { },
+    consumerOnSignalRead: () => { },
 };
 /**
  * Called by implementations when a producer's signal is read.
@@ -46,6 +54,7 @@ export function producerAccessed(node) {
         // Accessed outside of a reactive context, so nothing to record.
         return;
     }
+    activeConsumer.consumerOnSignalRead(node);
     // This producer is the `idx`th dependency of `activeConsumer`.
     const idx = activeConsumer.nextProducerIndex++;
     assertConsumerNode(activeConsumer);
@@ -232,6 +241,9 @@ function producerAddLiveConsumer(node, consumer, indexOfThis) {
 function producerRemoveLiveConsumerAtIndex(node, idx) {
     assertProducerNode(node);
     assertConsumerNode(node);
+    if (idx >= node.liveConsumerNode.length) {
+        throw new Error(`Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`);
+    }
     if (node.liveConsumerNode.length === 1) {
         // When removing the last live consumer, we will no longer be live. We need to remove
         // ourselves from our producers' tracking (which may cause consumer-producers to lose

package/signals/implementation/index.d.ts

@@ -1,7 +1,9 @@
 export * from './api.js';
+export * from './asserts.js';
 export * from './computed.js';
 export * from './configure.js';
 export * from './effect.js';
+export * from './equality.js';
 export * from './graph.js';
 export * from './signal.js';
 export * from './to-observable.js';

package/signals/implementation/index.js

@@ -1,7 +1,9 @@
 export * from './api.js';
+export * from './asserts.js';
 export * from './computed.js';
 export * from './configure.js';
 export * from './effect.js';
+export * from './equality.js';
 export * from './graph.js';
 export * from './signal.js';
 export * from './to-observable.js';

package/signals/implementation/signal.d.ts

@@ -5,25 +5,40 @@
  * 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 type { Signal, ValueEqualityFn } from './api.js';
+import { SIGNAL } from '../symbol.js';
+import { Signal } from './api.js';
+import type { ValueEqualityFn } from './equality.js';
+import type { ReactiveNode } from './graph.js';
+export interface SignalNode<T> extends ReactiveNode {
+    value: T;
+    equal: ValueEqualityFn<T>;
+    readonly [SIGNAL]: SignalNode<T>;
+}
+export type SignalBaseGetter<T> = (() => T) & {
+    readonly [SIGNAL]: unknown;
+};
+export interface SignalGetter<T> extends SignalBaseGetter<T> {
+    readonly [SIGNAL]: SignalNode<T>;
+}
 /**
- * A `Signal` with a value that can be mutated via a setter interface.
+ * Create a `Signal` that can be set or updated directly.
  */
+export declare function createSignal<T>(initialValue: T): SignalGetter<T>;
+export declare function setPostSignalSetFn(fn: (() => void) | null): (() => void) | null;
+export declare function signalGetFn<T>(this: SignalNode<T>): T;
+export declare function signalSetFn<T>(node: SignalNode<T>, newValue: T): void;
+export declare function signalUpdateFn<T>(node: SignalNode<T>, updater: (value: T) => T): void;
+export declare function signalMutateFn<T>(node: SignalNode<T>, mutator: (value: T) => void): void;
 export interface WritableSignal<T> extends Signal<T> {
     /**
      * Directly set the signal to a new value, and notify any dependents.
      */
     set(value: T): void;
     /**
-     * Update the value of the signal based on its current value, and
+     * Update the value of the signal based on itfs current value, and
      * notify any dependents.
      */
     update(updateFn: (value: T) => T): void;
-    /**
-     * Update the current value by mutating it in-place, and
-     * notify any dependents.
-     */
-    mutate(mutatorFn: (value: T) => void): void;
     /**
      * Returns a readonly version of this signal. Readonly signals can be accessed to read their value
      * but can't be changed using set, update or mutate methods. The readonly signals do _not_ have
@@ -44,4 +59,3 @@ export interface CreateSignalOptions<T> {
  * Create a `Signal` that can be set or updated directly.
  */
 export declare function signal<T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T>;
-export declare function setPostSignalSetFn(fn: (() => void) | null): (() => void) | null;

package/signals/implementation/signal.js

@@ -1,3 +1,4 @@
+/* eslint-disable */
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -5,9 +6,10 @@
  * 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 { SIGNAL, defaultEquals } from './api.js';
+import { SIGNAL } from '../symbol.js';
+import { defaultEquals } from './equality.js';
 import { throwInvalidWriteToSignalError } from './errors.js';
-import { REACTIVE_NODE, producerAccessed, producerNotifyConsumers, producerUpdatesAllowed } from './graph.js';
+import { producerAccessed, producerNotifyConsumers, producerUpdatesAllowed, REACTIVE_NODE } from './graph.js';
 /**
  * If set, called after `WritableSignal`s are updated.
  *
@@ -18,38 +20,26 @@ let postSignalSetFn = null;
 /**
  * Create a `Signal` that can be set or updated directly.
  */
-export function signal(initialValue, options) {
+export function createSignal(initialValue) {
     const node = Object.create(SIGNAL_NODE);
     node.value = initialValue;
-    options?.equal && (node.equal = options.equal);
-    function signalFn() {
+    const getter = (() => {
         producerAccessed(node);
         return node.value;
-    }
-    signalFn.set = signalSetFn;
-    signalFn.update = signalUpdateFn;
-    signalFn.mutate = signalMutateFn;
-    signalFn.asReadonly = signalAsReadonlyFn;
-    signalFn[SIGNAL] = node;
-    return signalFn;
+    });
+    getter[SIGNAL] = node;
+    return getter;
 }
 export function setPostSignalSetFn(fn) {
     const prev = postSignalSetFn;
     postSignalSetFn = fn;
     return prev;
 }
-const SIGNAL_NODE = {
-    ...REACTIVE_NODE,
-    equal: defaultEquals,
-    readonlyFn: undefined,
-};
-function signalValueChanged(node) {
-    node.version++;
-    producerNotifyConsumers(node);
-    postSignalSetFn?.();
+export function signalGetFn() {
+    producerAccessed(this);
+    return this.value;
 }
-function signalSetFn(newValue) {
-    const node = this[SIGNAL];
+export function signalSetFn(node, newValue) {
     if (!producerUpdatesAllowed()) {
         throwInvalidWriteToSignalError();
     }
@@ -58,14 +48,13 @@ function signalSetFn(newValue) {
         signalValueChanged(node);
     }
 }
-function signalUpdateFn(updater) {
+export function signalUpdateFn(node, updater) {
     if (!producerUpdatesAllowed()) {
         throwInvalidWriteToSignalError();
     }
-    signalSetFn.call(this, updater(this[SIGNAL].value));
+    signalSetFn(node, updater(node.value));
 }
-function signalMutateFn(mutator) {
-    const node = this[SIGNAL];
+export function signalMutateFn(node, mutator) {
     if (!producerUpdatesAllowed()) {
         throwInvalidWriteToSignalError();
     }
@@ -73,6 +62,35 @@ function signalMutateFn(mutator) {
     mutator(node.value);
     signalValueChanged(node);
 }
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const SIGNAL_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        equal: defaultEquals,
+        value: undefined,
+    };
+})();
+function signalValueChanged(node) {
+    node.version++;
+    producerNotifyConsumers(node);
+    postSignalSetFn?.();
+}
+/**
+ * Create a `Signal` that can be set or updated directly.
+ */
+export function signal(initialValue, options) {
+    const signalFn = createSignal(initialValue);
+    const node = signalFn[SIGNAL];
+    if (options?.equal) {
+        node.equal = options.equal;
+    }
+    signalFn.set = (newValue) => signalSetFn(node, newValue);
+    signalFn.update = (updateFn) => signalUpdateFn(node, updateFn);
+    signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
+    return signalFn;
+}
 function signalAsReadonlyFn() {
     const node = this[SIGNAL];
     if (node.readonlyFn === undefined) {

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

@@ -1,22 +1,15 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * 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 type { Observable, Subscribable } from 'rxjs';
-import type { Signal } from './api.js';
+import { Signal } from './api.js';
 /**
  * Options for `toSignal`.
  */
-export interface ToSignalOptions<T> {
+export interface ToSignalOptions {
     /**
      * Initial value for the signal produced by `toSignal`.
      *
      * This will be the value of the signal until the observable emits its first value.
      */
-    initialValue?: T;
+    initialValue?: unknown;
     /**
      * Whether to require that the observable emits synchronously when `toSignal` subscribes.
      *
@@ -27,61 +20,20 @@ export interface ToSignalOptions<T> {
      */
     requireSync?: boolean;
 }
-/**
- * Get the current value of an `Observable` as a reactive `Signal`.
- *
- * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced
- * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
- * have the most recent value emitted by the subscription, and will throw an error if the
- * `Observable` errors.
- *
- * Before the `Observable` emits its first value, the `Signal` will return `undefined`. To avoid
- * this, either an `initialValue` can be passed or the `requireSync` option enabled.
- */
 export declare function toSignal<T>(source: Observable<T> | Subscribable<T>): Signal<T | undefined>;
-/**
- * Get the current value of an `Observable` as a reactive `Signal`.
- *
- * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced
- * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
- * have the most recent value emitted by the subscription, and will throw an error if the
- * `Observable` errors.
- *
- * Before the `Observable` emits its first value, the `Signal` will return the configured
- * `initialValue`, or `undefined` if no `initialValue` is provided. If the `Observable` is
- * guaranteed to emit synchronously, then the `requireSync` option can be passed instead.
- */
-export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options?: ToSignalOptions<undefined> & {
+export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: ToSignalOptions & {
+    initialValue?: undefined;
     requireSync?: false;
 }): Signal<T | undefined>;
-/**
- * Get the current value of an `Observable` as a reactive `Signal`.
- *
- * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced
- * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
- * have the most recent value emitted by the subscription, and will throw an error if the
- * `Observable` errors.
- *
- * Before the `Observable` emits its first value, the `Signal` will return the configured
- * `initialValue`. If the `Observable` is guaranteed to emit synchronously, then the `requireSync`
- * option can be passed instead.
- */
-export declare function toSignal<T, U extends T | null | undefined>(source: Observable<T> | Subscribable<T>, options: ToSignalOptions<U> & {
-    initialValue: U;
+export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: ToSignalOptions & {
+    initialValue?: null;
     requireSync?: false;
-}): Signal<T | U>;
-/**
- * Get the current value of an `Observable` as a reactive `Signal`.
- *
- * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced
- * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
- * have the most recent value emitted by the subscription, and will throw an error if the
- * `Observable` errors.
- *
- * With `requireSync` set to `true`, `toSignal` will assert that the `Observable` produces a value
- * immediately upon subscription. No `initialValue` is needed in this case, and the returned signal
- * does not include an `undefined` type.
- */
-export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: ToSignalOptions<undefined> & {
+}): Signal<T | null>;
+export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: ToSignalOptions & {
+    initialValue?: undefined;
     requireSync: true;
 }): Signal<T>;
+export declare function toSignal<T, const U extends T>(source: Observable<T> | Subscribable<T>, options: ToSignalOptions & {
+    initialValue: U;
+    requireSync?: false;
+}): Signal<T | U>;

package/signals/implementation/to-signal.js

@@ -1,3 +1,4 @@
+/* eslint-disable */
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -5,18 +6,24 @@
  * 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 { isDevMode } from '../../core.js';
 import { registerFinalization } from '../../memory/finalization.js';
+import { assertNotInReactiveContext } from './asserts.js';
 import { computed } from './computed.js';
 import { signal } from './signal.js';
-import { untracked } from './untracked.js';
-var StateKind;
-(function (StateKind) {
-    StateKind[StateKind["NoValue"] = 0] = "NoValue";
-    StateKind[StateKind["Value"] = 1] = "Value";
-    StateKind[StateKind["Error"] = 2] = "Error";
-})(StateKind || (StateKind = {}));
+/**
+ * Get the current value of an `Observable` as a reactive `Signal`.
+ *
+ * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced
+ * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
+ * have the most recent value emitted by the subscription, and will throw an error if the
+ * `Observable` errors.
+ *
+ * With `requireSync` set to `true`, `toSignal` will assert that the `Observable` produces a value
+ * immediately upon subscription. No `initialValue` is needed in this case, and the returned signal
+ * does not include an `undefined` type.
+ */
 export function toSignal(source, options) {
+    assertNotInReactiveContext(toSignal, 'Invoking `toSignal` causes new subscriptions every time. Consider moving `toSignal` outside of the reactive context and read the signal value where needed.');
     // Note: T is the Observable value type, and U is the initial value type. They don't have to be
     // the same - the returned signal gives values of type `T`.
     let state;
@@ -28,13 +35,19 @@ export function toSignal(source, options) {
         // If an initial value was passed, use it. Otherwise, use `undefined` as the initial value.
         state = signal({ kind: StateKind.Value, value: options?.initialValue });
     }
+    // Note: This code cannot run inside a reactive context (see assertion above). If we'd support
+    // this, we would subscribe to the observable outside of the current reactive context, avoiding
+    // that side-effect signal reads/writes are attribute to the current consumer. The current
+    // consumer only needs to be notified when the `state` signal changes through the observable
+    // subscription. Additional context (related to async pipe):
+    // https://github.com/angular/angular/pull/50522.
     const sub = source.subscribe({
         next: value => state.set({ kind: StateKind.Value, value }),
         error: error => state.set({ kind: StateKind.Error, error }),
         // Completion of the Observable is meaningless to the signal. Signals don't have a concept of
         // "complete".
     });
-    if (isDevMode() && options?.requireSync && untracked(state).kind === StateKind.NoValue) {
+    if (options?.requireSync && state().kind === StateKind.NoValue) {
         throw new Error('`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');
     }
     // The actual returned signal is a `computed` of the `State` signal, which maps the various states
@@ -53,3 +66,9 @@ export function toSignal(source, options) {
     registerFinalization(result, () => sub.unsubscribe());
     return result;
 }
+var StateKind;
+(function (StateKind) {
+    StateKind[StateKind["NoValue"] = 0] = "NoValue";
+    StateKind[StateKind["Value"] = 1] = "Value";
+    StateKind[StateKind["Error"] = 2] = "Error";
+})(StateKind || (StateKind = {}));

package/signals/implementation/watch.d.ts

@@ -5,6 +5,8 @@
  * 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 { SIGNAL } from '../symbol.js';
+import type { ReactiveNode } from './graph.js';
 /**
  * A cleanup function that can be optionally registered from the watch logic. If registered, the
  * cleanup logic runs before the next watch execution.
@@ -30,5 +32,13 @@ export interface Watch {
      * - mark it as destroyed so subsequent run and notify operations are noop.
      */
     destroy(): void;
+    [SIGNAL]: WatchNode;
 }
-export declare function watch(fn: (onCleanup: WatchCleanupRegisterFn) => void, schedule: (watch: Watch) => void, allowSignalWrites: boolean): Watch;
+export interface WatchNode extends ReactiveNode {
+    hasRun: boolean;
+    fn: ((onCleanup: WatchCleanupRegisterFn) => void) | null;
+    schedule: ((watch: Watch) => void) | null;
+    cleanupFn: WatchCleanupFn;
+    ref: Watch;
+}
+export declare function createWatch(fn: (onCleanup: WatchCleanupRegisterFn) => void, schedule: (watch: Watch) => void, allowSignalWrites: boolean): Watch;

package/signals/implementation/watch.js

@@ -1,3 +1,4 @@
+/* eslint-disable */
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -5,8 +6,9 @@
  * 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 { SIGNAL } from '../symbol.js';
 import { consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, isInNotificationPhase, REACTIVE_NODE } from './graph.js';
-export function watch(fn, schedule, allowSignalWrites) {
+export function createWatch(fn, schedule, allowSignalWrites) {
     const node = Object.create(WATCH_NODE);
     if (allowSignalWrites) {
         node.consumerAllowSignalWrites = true;
@@ -57,6 +59,7 @@ export function watch(fn, schedule, allowSignalWrites) {
         run,
         cleanup: () => node.cleanupFn(),
         destroy: () => destroyWatchNode(node),
+        [SIGNAL]: node,
     };
     return node.ref;
 }

package/signals/index.d.ts

@@ -5,6 +5,6 @@ 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 './to-lazy-signal.js';
 export * from './types.js';
 export * from './untracked-operator.js';

package/signals/index.js

@@ -5,6 +5,6 @@ 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 './to-lazy-signal.js';
 export * from './types.js';
 export * from './untracked-operator.js';

package/signals/pipe.js

@@ -1,11 +1,11 @@
 import { distinctUntilChanged } from 'rxjs';
 import { startWithProvider } from '../rxjs/start-with-provider.js';
-import { toObservable } from './api.js';
-import { toSignal2 } from './to-signal-2.js';
+import { untrack } from '../rxjs/untrack.js';
+import { toObservable, toSignal } from './api.js';
 export function pipe(source, ...operators) {
     return rawPipe(source, startWithProvider(source), distinctUntilChanged(), ...operators);
 }
 export function rawPipe(source, ...operators) {
-    const piped = toObservable(source).pipe(...operators);
-    return toSignal2(piped, { requireSync: true });
+    const piped = toObservable(source).pipe(...operators, untrack());
+    return toSignal(piped, { requireSync: true });
 }

package/signals/symbol.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Symbol used to tell `Signal`s apart from other functions.
+ *
+ * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
+ */
+export declare const SIGNAL: unique symbol;

package/signals/symbol.js

@@ -0,0 +1,6 @@
+/**
+ * Symbol used to tell `Signal`s apart from other functions.
+ *
+ * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
+ */
+export const SIGNAL = /* @__PURE__ */ Symbol('SIGNAL');

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

@@ -0,0 +1,23 @@
+import type { Observable } from 'rxjs';
+import type { Signal, ToSignalOptions } from './api.js';
+/**
+ * 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 toLazySignal<T>(source: Observable<T>): Signal<T | undefined>;
+export declare function toLazySignal<T>(source: Observable<T>, options: ToSignalOptions & {
+    initialValue?: undefined;
+    requireSync?: false;
+}): Signal<T | undefined>;
+export declare function toLazySignal<T>(source: Observable<T>, options: ToSignalOptions & {
+    initialValue?: null;
+    requireSync?: false;
+}): Signal<T | null>;
+export declare function toLazySignal<T>(source: Observable<T>, options: ToSignalOptions & {
+    initialValue?: undefined;
+    requireSync: true;
+}): Signal<T>;
+export declare function toLazySignal<T, const I extends T>(source: Observable<T>, options: ToSignalOptions & {
+    initialValue: I;
+    requireSync?: false;
+}): Signal<T | I>;

package/signals/to-lazy-signal.js

@@ -0,0 +1,20 @@
+import { Subject, switchMap } from 'rxjs';
+import { computed, toSignal } from './api.js';
+const LAZY = Symbol('LAZY');
+export function toLazySignal(source, options) {
+    const subscribe$ = new Subject();
+    const lazySource = subscribe$.pipe(switchMap(() => source));
+    const signal = toSignal(lazySource, { initialValue: LAZY, ...options }); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+    let subscribed = false;
+    return computed(() => {
+        if (!subscribed) {
+            subscribed = true;
+            subscribe$.next();
+            subscribe$.complete();
+            if (signal() == LAZY) {
+                throw new Error('`toLazySignal()` called with `requireSync` but `Observable` did not emit synchronously.');
+            }
+        }
+        return signal();
+    });
+}

package/utils/reactive-value-to-signal.d.ts

@@ -1,13 +1,13 @@
 import type { Signal, ToSignalOptions } from '../signals/api.js';
 import type { ReactiveValue } from '../types.js';
-export type ReactiveValueToSignalOptions<T> = ToSignalOptions<T>;
-export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options?: ReactiveValueToSignalOptions<undefined> & {
+export type ReactiveValueToSignalOptions = ToSignalOptions;
+export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options?: ReactiveValueToSignalOptions & {
     requireSync?: false;
 }): Signal<T | undefined>;
-export declare function reactiveValueToSignal<T, I>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<I> & {
+export declare function reactiveValueToSignal<T, I>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions & {
     initialValue: I;
     requireSync?: false;
 }): Signal<T | I>;
-export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<undefined> & {
+export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions & {
     requireSync: true;
 }): Signal<T>;

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

@@ -1,19 +0,0 @@
-import type { Observable, Subscribable } from 'rxjs';
-import type { Signal, ToSignalOptions } from './api.js';
-type ToSignalInput<T> = Observable<T> | Subscribable<T>;
-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.
- * 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;
-}): Signal<T>;
-export declare function toSignal2<T, const I = undefined>(source: ToSignalInput<T>, options: ToSignal2Options<I> & {
-    requireSync?: false;
-}): Signal<T | I>;
-export {};

package/signals/to-signal-2.js

@@ -1,44 +0,0 @@
-import { isDevMode } from '../core.js';
-import { registerFinalization } from '../memory/finalization.js';
-import { isUndefined } from '../utils/type-guards.js';
-import { computed, signal, untracked } from './api.js';
-var StateKind;
-(function (StateKind) {
-    StateKind[StateKind["NoValue"] = 0] = "NoValue";
-    StateKind[StateKind["Value"] = 1] = "Value";
-    StateKind[StateKind["Error"] = 2] = "Error";
-})(StateKind || (StateKind = {}));
-export function toSignal2(source, options) {
-    const initialState = (options?.requireSync == true) ? { kind: StateKind.NoValue } : { kind: StateKind.Value, value: options?.initialValue };
-    const state = signal(initialState);
-    let subscription;
-    if (options?.lazy != true) {
-        subscription = subscribe(source, state, options);
-    }
-    const result = computed(() => {
-        if (isUndefined(subscription)) {
-            subscription = subscribe(source, state, options);
-        }
-        const current = state();
-        switch (current.kind) { // eslint-disable-line default-case
-            case StateKind.Value:
-                return current.value;
-            case StateKind.Error:
-                throw current.error;
-            case StateKind.NoValue:
-                throw new Error('`toSignalLazy()` called with `requireSync` but `Observable` did not emit synchronously.');
-        }
-    });
-    registerFinalization(result, () => subscription?.unsubscribe());
-    return result;
-}
-function subscribe(source, state, options) {
-    const subscription = source.subscribe({
-        next: (value) => untracked(() => state.set({ kind: StateKind.Value, value })),
-        error: (error) => untracked(() => state.set({ kind: StateKind.Error, error }))
-    });
-    if (isDevMode() && (options?.requireSync == true) && untracked(state).kind == StateKind.NoValue) {
-        throw new Error('`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');
-    }
-    return subscription;
-}