@tstdl/base 0.91.3 → 0.91.6

package/data-structures/circular-buffer.d.ts

@@ -1,5 +1,5 @@
-import type { CancellationSignal } from '../cancellation/token.js';
-import type { Observable } from 'rxjs';
+import { type Observable } from 'rxjs';
+import { type CancellationSignal } from '../cancellation/token.js';
 import { Collection } from './collection.js';
 export declare class CircularBuffer<T> extends Collection<T, CircularBuffer<T>> {
     private readonly maxBufferSizeSubject;
@@ -7,31 +7,31 @@ export declare class CircularBuffer<T> extends Collection<T, CircularBuffer<T>>
     private backingArray;
     private writeIndex;
     private readIndex;
-    /** emits overwritten items */
+    /** Emits overwritten items */
     readonly overflow$: Observable<T>;
-    /** emits count of free slots in the buffer */
+    /** Emits count of free slots in the buffer */
     readonly freeSlots$: Observable<number>;
-    /** emits when the buffer is full */
+    /** Emits when the buffer is full */
     readonly onFull$: Observable<void>;
-    /** emits when the buffer has free slots */
+    /** Emits when the buffer has free slots */
     readonly onFreeSlots$: Observable<void>;
-    /** emits whether the buffer is full */
+    /** Emits whether the buffer is full */
     readonly isFull$: Observable<boolean>;
-    /** emits whether the buffer has free slots */
+    /** Emits whether the buffer has free slots */
     readonly hasFreeSlots$: Observable<boolean>;
-    /** resolves when the buffer is full */
+    /** Resolves when the buffer is full */
     get $onFull(): Promise<void>;
-    /** resolves when the buffer has items */
+    /** Resolves when the buffer has items */
     get $onFreeSlots(): Promise<void>;
-    /** size of buffer */
+    /** Size of buffer */
     get bufferSize(): number;
-    /** size of buffer */
+    /** Size of buffer */
     get maxBufferSize(): number;
-    /** count of free slots in buffer */
+    /** Count of free slots in buffer */
     get freeSlots(): number;
-    /** whether the buffer is full */
+    /** Whether the buffer is full */
     get isFull(): boolean;
-    /** whether the buffer has free slots */
+    /** Whether the buffer has free slots */
     get hasFreeSlots(): boolean;
     constructor(maxBufferSize?: number);
     includes(item: T): boolean;
@@ -41,10 +41,10 @@ export declare class CircularBuffer<T> extends Collection<T, CircularBuffer<T>>
     tryRemove(): T | undefined;
     clone(newMaxBufferSize?: number | undefined): CircularBuffer<T>;
     items(): IterableIterator<T>;
-    /** yields all items from the buffer and removes them */
+    /** Yields all items from the buffer and removes them */
     consume(): IterableIterator<T>;
     /**
-     * yields all items from the buffer, removes them and waits fore more
+     * Yields all items from the buffer, removes them and waits fore more
      * @param cancellationSignal token to cancel iteration
      * @param yieldOutstandingItems whether to yield all outstanding items or exit immdiately when {@link cancellationSignal} is set
      * @returns

package/data-structures/circular-buffer.js

@@ -1,6 +1,6 @@
+import { BehaviorSubject, Subject, distinctUntilChanged, filter, first, firstValueFrom, from, map, race } from 'rxjs';
 import { CancellationToken } from '../cancellation/token.js';
 import { isArray, isDefined, isUndefined } from '../utils/type-guards.js';
-import { BehaviorSubject, Subject, distinctUntilChanged, filter, first, firstValueFrom, from, map, race } from 'rxjs';
 import { Collection } from './collection.js';
 export class CircularBuffer extends Collection {
     maxBufferSizeSubject;
@@ -8,46 +8,46 @@ export class CircularBuffer extends Collection {
     backingArray;
     writeIndex;
     readIndex;
-    /** emits overwritten items */
+    /** Emits overwritten items */
     overflow$;
-    /** emits count of free slots in the buffer */
+    /** Emits count of free slots in the buffer */
     freeSlots$;
-    /** emits when the buffer is full */
+    /** Emits when the buffer is full */
     onFull$;
-    /** emits when the buffer has free slots */
+    /** Emits when the buffer has free slots */
     onFreeSlots$;
-    /** emits whether the buffer is full */
+    /** Emits whether the buffer is full */
     isFull$;
-    /** emits whether the buffer has free slots */
+    /** Emits whether the buffer has free slots */
     hasFreeSlots$;
-    /** resolves when the buffer is full */
+    /** Resolves when the buffer is full */
     get $onFull() {
         return firstValueFrom(this.onFull$);
     }
-    /** resolves when the buffer has items */
+    /** Resolves when the buffer has items */
     get $onFreeSlots() {
         return firstValueFrom(this.onFreeSlots$);
     }
-    /** size of buffer */
+    /** Size of buffer */
     get bufferSize() {
         return this.backingArray.length;
     }
-    /** size of buffer */
+    /** Size of buffer */
     get maxBufferSize() {
         return this.maxBufferSizeSubject.value ?? Infinity;
     }
-    /** count of free slots in buffer */
+    /** Count of free slots in buffer */
     get freeSlots() {
         if (isUndefined(this.maxBufferSize)) {
             return Infinity;
         }
         return this.bufferSize - this.size;
     }
-    /** whether the buffer is full */
+    /** Whether the buffer is full */
     get isFull() {
         return this.freeSlots == 0;
     }
-    /** whether the buffer has free slots */
+    /** Whether the buffer has free slots */
     get hasFreeSlots() {
         return this.freeSlots > 0;
     }
@@ -134,14 +134,14 @@ export class CircularBuffer extends Collection {
             subscription.unsubscribe();
         }
     }
-    /** yields all items from the buffer and removes them */
+    /** Yields all items from the buffer and removes them */
     *consume() {
         while (this.size > 0) {
             yield this.tryRemove();
         }
     }
     /**
-     * yields all items from the buffer, removes them and waits fore more
+     * Yields all items from the buffer, removes them and waits fore more
      * @param cancellationSignal token to cancel iteration
      * @param yieldOutstandingItems whether to yield all outstanding items or exit immdiately when {@link cancellationSignal} is set
      * @returns

package/data-structures/collection.d.ts

@@ -1,24 +1,33 @@
-import type { ToJson } from '../interfaces.js';
 import { type Observable } from 'rxjs';
+import type { ToJson } from '../interfaces.js';
+import { type Signal } from '../signals/index.js';
 export declare abstract class Collection<T, TThis extends Collection<T, TThis> = Collection<T, any>> implements Iterable<T>, ToJson {
     private readonly sizeSubject;
     private readonly changeSubject;
     private readonly clearSubject;
-    /** Emits collection on subscribe and change */
-    readonly observe$: Observable<TThis>;
     /** Emits size of collection */
     readonly size$: Observable<number>;
+    /** Size of collection */
+    readonly $size: Signal<number>;
     /** Emits collection on change */
     readonly change$: Observable<TThis>;
+    /** Emits collection on subscribe and change */
+    readonly observe$: Observable<TThis>;
+    /** Notifies on change */
+    readonly $observe: Signal<TThis>;
     readonly clear$: Observable<TThis>;
-    /** Emits when the collection is empty */
-    readonly onEmpty$: Observable<void>;
-    /** Emits when the collection has items */
-    readonly onItems$: Observable<void>;
     /** Emits whether the collection is empty */
     readonly isEmpty$: Observable<boolean>;
+    /** Whether the collection is empty */
+    readonly $isEmpty: Signal<boolean>;
     /** Emits whether the collection has items */
     readonly hasItems$: Observable<boolean>;
+    /** Whether the collection has items */
+    readonly $hasItems: Signal<boolean>;
+    /** Emits when the collection is empty */
+    readonly onEmpty$: Observable<undefined>;
+    /** Emits when the collection has items */
+    readonly onItems$: Observable<undefined>;
     /** Resolves when the collection is empty */
     get $onEmpty(): Promise<void>;
     /** Resolves when the collection has items */

package/data-structures/collection.js

@@ -1,24 +1,34 @@
 import { BehaviorSubject, Subject, distinctUntilChanged, filter, firstValueFrom, map, startWith } from 'rxjs';
+import { getCurrentSignalsInjector, toLazySignal, untracked } from '../signals/index.js';
+import { lazyProperty } from '../utils/object/lazy-property.js';
 export class Collection {
-    sizeSubject;
-    changeSubject;
-    clearSubject;
-    /** Emits collection on subscribe and change */
-    observe$;
+    sizeSubject = new BehaviorSubject(0);
+    changeSubject = new Subject();
+    clearSubject = new Subject();
     /** Emits size of collection */
-    size$;
+    size$ = this.sizeSubject.asObservable();
+    /** Size of collection */
+    $size;
     /** Emits collection on change */
-    change$;
+    change$ = this.changeSubject.asObservable();
+    /** Emits collection on subscribe and change */
+    observe$ = this.change$.pipe(startWith(this)); // eslint-disable-line @typescript-eslint/no-unnecessary-type-assertion
+    /** Notifies on change */
+    $observe;
     /* Emits collection on clear */
-    clear$;
-    /** Emits when the collection is empty */
-    onEmpty$;
-    /** Emits when the collection has items */
-    onItems$;
+    clear$ = this.clearSubject.asObservable();
     /** Emits whether the collection is empty */
-    isEmpty$;
+    isEmpty$ = this.size$.pipe(map(() => this.isEmpty), distinctUntilChanged());
+    /** Whether the collection is empty */
+    $isEmpty;
     /** Emits whether the collection has items */
-    hasItems$;
+    hasItems$ = this.size$.pipe(map(() => this.hasItems), distinctUntilChanged());
+    /** Whether the collection has items */
+    $hasItems;
+    /** Emits when the collection is empty */
+    onEmpty$ = this.isEmpty$.pipe(filter((isEmpty) => isEmpty), map(() => undefined));
+    /** Emits when the collection has items */
+    onItems$ = this.hasItems$.pipe(filter((hasItems) => hasItems), map(() => undefined));
     /** Resolves when the collection is empty */
     get $onEmpty() {
         return firstValueFrom(this.onEmpty$);
@@ -40,17 +50,11 @@ export class Collection {
         return this.size > 0;
     }
     constructor() {
-        this.sizeSubject = new BehaviorSubject(0);
-        this.changeSubject = new Subject();
-        this.clearSubject = new Subject();
-        this.size$ = this.sizeSubject.asObservable();
-        this.change$ = this.changeSubject.asObservable();
-        this.clear$ = this.clearSubject.asObservable();
-        this.observe$ = this.change$.pipe(startWith(this));
-        this.isEmpty$ = this.size$.pipe(map(() => this.isEmpty), distinctUntilChanged());
-        this.hasItems$ = this.size$.pipe(map(() => this.hasItems), distinctUntilChanged());
-        this.onEmpty$ = this.isEmpty$.pipe(filter((isEmpty) => isEmpty), map(() => undefined));
-        this.onItems$ = this.hasItems$.pipe(filter((hasItems) => hasItems), map(() => undefined));
+        const injector = getCurrentSignalsInjector();
+        lazyProperty(this, '$size', () => untracked(() => toLazySignal(this.size$, { injector, requireSync: true })));
+        lazyProperty(this, '$observe', () => untracked(() => toLazySignal(this.observe$, { injector, requireSync: true, equal: () => false })));
+        lazyProperty(this, '$isEmpty', () => untracked(() => toLazySignal(this.isEmpty$, { injector, requireSync: true })));
+        lazyProperty(this, '$hasItems', () => untracked(() => toLazySignal(this.hasItems$, { injector, requireSync: true })));
     }
     [Symbol.iterator]() {
         return this.items();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.3",
+  "version": "0.91.6",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -108,10 +108,10 @@
   },
   "dependencies": {
     "disposablestack": "1.1",
-    "luxon": "^3.4",
+    "luxon": "^3.5",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.23"
+    "type-fest": "4.24"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -142,7 +142,7 @@
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.6",
-    "drizzle-orm": "^0.32",
+    "drizzle-orm": "^0.33",
     "handlebars": "^4.7",
     "koa": "^2.15",
     "minio": "^8.0",
@@ -150,7 +150,7 @@
     "mongodb": "^6.8",
     "nodemailer": "^6.9",
     "pg": "^8.12",
-    "playwright": "^1.45",
+    "playwright": "^1.46",
     "preact": "^10.23",
     "preact-render-to-string": "^6.5",
     "undici": "^6.19",

package/signals/api.d.ts

@@ -1,5 +1,7 @@
+import type { Tagged } from 'type-fest';
 import type * as Types from './implementation/index.js';
 export type { CreateComputedOptions, CreateEffectOptions, CreateSignalOptions, EffectCleanupRegisterFn, EffectRef, Signal, ToSignalOptions, WritableSignal } from './implementation/index.js';
+export type Injector = Tagged<symbol, 'injector'>;
 export type SignalsConfiguration = {
     signal: typeof Types.signal;
     computed: typeof Types.computed;
@@ -8,6 +10,8 @@ export type SignalsConfiguration = {
     isSignal: typeof Types.isSignal;
     toSignal: typeof Types.toSignal;
     toObservable: typeof Types.toObservable;
+    getCurrentSignalsInjector: () => Injector;
+    runInSignalsInjectionContext: <ReturnT>(injector: Injector, fn: () => ReturnT) => ReturnT;
 };
 export declare let signal: typeof Types.signal;
 export declare let computed: typeof Types.computed;
@@ -16,4 +20,6 @@ export declare let untracked: typeof Types.untracked;
 export declare let isSignal: typeof Types.isSignal;
 export declare let toSignal: typeof Types.toSignal;
 export declare let toObservable: typeof Types.toObservable;
+export declare let getCurrentSignalsInjector: SignalsConfiguration['getCurrentSignalsInjector'];
+export declare let runInSignalsInjectionContext: SignalsConfiguration['runInSignalsInjectionContext'];
 export declare function configureSignals(configuration: SignalsConfiguration): void;

package/signals/api.js

@@ -6,9 +6,11 @@ export let untracked = throwSignalsNotConfigured;
 export let isSignal = throwSignalsNotConfigured;
 export let toSignal = throwSignalsNotConfigured;
 export let toObservable = throwSignalsNotConfigured;
+export let getCurrentSignalsInjector = throwSignalsNotConfigured;
+export let runInSignalsInjectionContext = throwSignalsNotConfigured;
 /* eslint-enable import/no-mutable-exports */
 export function configureSignals(configuration) {
-    ({ signal, computed, effect, untracked, isSignal, toSignal, toObservable } = configuration);
+    ({ signal, computed, effect, untracked, isSignal, toSignal, toObservable, runInSignalsInjectionContext, getCurrentSignalsInjector } = configuration);
 }
 function throwSignalsNotConfigured() {
     throw new Error('Signals are not configured. Use configureDefaultSignalsImplementation() for default implementation or configureSignals() for custom implementation.');

package/signals/computed-with-dependencies.d.ts

@@ -1,2 +1,2 @@
-import type { CreateComputedOptions, Signal } from './api.js';
+import { type CreateComputedOptions, type Signal } from './api.js';
 export declare function computedWithDependencies<T>(computation: () => T, dependencies: Signal<any>[], options?: CreateComputedOptions<T>): Signal<T>;

package/signals/effect-with-dependencies.d.ts

@@ -1,2 +1,2 @@
-import type { CreateEffectOptions, EffectCleanupRegisterFn, EffectRef, Signal } from './api.js';
+import { type CreateEffectOptions, type EffectCleanupRegisterFn, type EffectRef, type Signal } from './api.js';
 export declare function effectWithDependencies(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, dependencies: Signal<any>[], options?: CreateEffectOptions): EffectRef;

package/signals/implementation/computed.js

@@ -67,7 +67,9 @@ const COMPUTED_NODE = {
         finally {
             consumerAfterComputation(node, prevConsumer);
         }
-        if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
+        if (oldValue !== UNSET &&
+            oldValue !== ERRORED &&
+            newValue !== ERRORED &&
             node.equal(oldValue, newValue)) {
             // No change to `valueVersion` - old and new values are
             // semantically equivalent.

package/signals/implementation/configure.js

@@ -2,10 +2,10 @@ import { configureSignals } from '../api.js';
 import { isSignal } from './api.js';
 import { computed } from './computed.js';
 import { effect } from './effect.js';
-import { signal } from './signal.js';
 import { toObservable } from './to-observable.js';
 import { toSignal } from './to-signal.js';
 import { untracked } from './untracked.js';
+import { signal } from './writable-signal.js';
 export function configureDefaultSignalsImplementation() {
     configureSignals({
         signal,
@@ -14,6 +14,8 @@ export function configureDefaultSignalsImplementation() {
         untracked,
         isSignal,
         toSignal,
-        toObservable
+        toObservable,
+        getCurrentSignalsInjector: () => null,
+        runInSignalsInjectionContext: (_, fn) => fn()
     });
 }

package/signals/implementation/effect.d.ts

@@ -1,3 +1,11 @@
+/**
+ * @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 { Injector } from '../api.js';
 /**
  * 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
@@ -45,6 +53,20 @@ export interface EffectRef {
  * Options passed to the `effect` function.
  */
 export interface CreateEffectOptions {
+    /**
+     * The `Injector` in which to create the effect.
+     *
+     * If this is not provided, the current [injection context](guide/di/dependency-injection-context)
+     * will be used instead (via `inject`).
+     */
+    injector?: Injector;
+    /**
+     * Whether the `effect` should require manual cleanup.
+     *
+     * If this is `false` (the default) the effect will automatically register itself to be cleaned up
+     * with the current `DestroyRef`.
+     */
+    manualCleanup?: boolean;
     /**
      * Whether the `effect` should allow writing to signals.
      *

package/signals/implementation/effect.js

@@ -1,11 +1,4 @@
 /* eslint-disable */
-/**
- * @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 { assertNotInReactiveContext } from './asserts.js';
 import { createWatch } from './watch.js';
 /**

package/signals/implementation/equality.js

@@ -1,4 +1,10 @@
-/* eslint-disable */
+/**
+ * @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.
  */

package/signals/implementation/graph.js

@@ -85,8 +85,9 @@ export function producerAccessed(node) {
         activeConsumer.producerNode[idx] = node;
         // If the active consumer is live, then add it as a live consumer. If not, then use 0 as a
         // placeholder value.
-        activeConsumer.producerIndexOfThis[idx] =
-            consumerIsLive(activeConsumer) ? producerAddLiveConsumer(node, activeConsumer, idx) : 0;
+        activeConsumer.producerIndexOfThis[idx] = consumerIsLive(activeConsumer)
+            ? producerAddLiveConsumer(node, activeConsumer, idx)
+            : 0;
     }
     activeConsumer.producerLastReadVersion[idx] = node.version;
 }
@@ -176,7 +177,9 @@ export function consumerBeforeComputation(node) {
  */
 export function consumerAfterComputation(node, prevConsumer) {
     setActiveConsumer(prevConsumer);
-    if (!node || node.producerNode === undefined || node.producerIndexOfThis === undefined ||
+    if (!node ||
+        node.producerNode === undefined ||
+        node.producerIndexOfThis === undefined ||
         node.producerLastReadVersion === undefined) {
         return;
     }
@@ -234,8 +237,10 @@ export function consumerDestroy(node) {
         }
     }
     // Truncate all the arrays to drop all connection from this node to the graph.
-    node.producerNode.length = node.producerLastReadVersion.length = node.producerIndexOfThis.length =
-        0;
+    node.producerNode.length =
+        node.producerLastReadVersion.length =
+            node.producerIndexOfThis.length =
+                0;
     if (node.liveConsumerNode) {
         node.liveConsumerNode.length = node.liveConsumerIndexOfThis.length = 0;
     }
@@ -248,8 +253,7 @@ export function consumerDestroy(node) {
  */
 function producerAddLiveConsumer(node, consumer, indexOfThis) {
     assertProducerNode(node);
-    assertConsumerNode(node);
-    if (node.liveConsumerNode.length === 0) {
+    if (node.liveConsumerNode.length === 0 && isConsumerNode(node)) {
         // When going from 0 to 1 live consumers, we become a live consumer to our producers.
         for (let i = 0; i < node.producerNode.length; i++) {
             node.producerIndexOfThis[i] = producerAddLiveConsumer(node.producerNode[i], node, i);
@@ -263,11 +267,10 @@ 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) {
+    if (node.liveConsumerNode.length === 1 && isConsumerNode(node)) {
         // 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
         // liveness as well).
@@ -304,3 +307,6 @@ function assertProducerNode(node) {
     node.liveConsumerNode ??= [];
     node.liveConsumerIndexOfThis ??= [];
 }
+function isConsumerNode(node) {
+    return node.producerNode !== undefined;
+}

package/signals/implementation/index.d.ts

@@ -10,3 +10,4 @@ export * from './to-observable.js';
 export * from './to-signal.js';
 export * from './untracked.js';
 export * from './watch.js';
+export * from './writable-signal.js';

package/signals/implementation/index.js

@@ -10,3 +10,4 @@ export * from './to-observable.js';
 export * from './to-signal.js';
 export * from './untracked.js';
 export * from './watch.js';
+export * from './writable-signal.js';

package/signals/implementation/signal.d.ts

@@ -5,14 +5,12 @@
  * 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 } from './api.js';
 import type { ValueEqualityFn } from './equality.js';
 import type { ReactiveNode } from './graph.js';
 import { SIGNAL } 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;
@@ -28,37 +26,4 @@ export declare function setPostSignalSetFn(fn: (() => void) | null): (() => void
 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;
-/**
- * A `Signal` with a value that can be mutated via a setter interface.
- */
-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
-     * notify any dependents.
-     */
-    update(updateFn: (value: T) => T): void;
-    /**
-     * Returns a readonly version of this signal. Readonly signals can be accessed to read their value
-     * but can't be changed using set or update methods. The readonly signals do _not_ have
-     * any built-in mechanism that would prevent deep-mutation of their value.
-     */
-    asReadonly(): Signal<T>;
-}
-/**
- * Options passed to the `signal` creation function.
- */
-export interface CreateSignalOptions<T> {
-    /**
-     * A comparison function which defines equality for signal values.
-     */
-    equal?: ValueEqualityFn<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 const SIGNAL_NODE: SignalNode<unknown>;

package/signals/implementation/signal.js

@@ -35,13 +35,7 @@ export function signalSetFn(node, newValue) {
     if (!producerUpdatesAllowed()) {
         throwInvalidWriteToSignalError();
     }
-    const value = node.value;
-    if (Object.is(value, newValue)) {
-        if (!node.equal(value, newValue)) {
-            console.warn('Signal value equality implementations should always return `true` for values that are the same according to `Object.is` but returned `false` instead.');
-        }
-    }
-    else if (!node.equal(value, newValue)) {
+    if (!node.equal(node.value, newValue)) {
         node.value = newValue;
         signalValueChanged(node);
     }
@@ -52,15 +46,7 @@ export function signalUpdateFn(node, updater) {
     }
     signalSetFn(node, updater(node.value));
 }
-export function signalMutateFn(node, mutator) {
-    if (!producerUpdatesAllowed()) {
-        throwInvalidWriteToSignalError();
-    }
-    // Mutate bypasses equality checks as it's by definition changing the value.
-    mutator(node.value);
-    signalValueChanged(node);
-}
-const SIGNAL_NODE = {
+export const SIGNAL_NODE = {
     ...REACTIVE_NODE,
     equal: defaultEquals,
     value: undefined,
@@ -71,26 +57,3 @@ function signalValueChanged(node) {
     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) {
-        const readonlyFn = () => this();
-        readonlyFn[SIGNAL] = node;
-        node.readonlyFn = readonlyFn;
-    }
-    return node.readonlyFn;
-}

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

@@ -1,8 +1,23 @@
 import { Observable } from 'rxjs';
+import type { Injector } from '../api.js';
 import type { Signal } from './api.js';
+/**
+ * Options for `toObservable`.
+ *
+ * @developerPreview
+ */
+export interface ToObservableOptions {
+    /**
+     * The `Injector` to use when creating the underlying `effect` which watches the signal.
+     *
+     * If this isn't specified, the current [injection context](guide/di/dependency-injection-context)
+     * will be used.
+     */
+    injector?: Injector;
+}
 /**
  * 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 toObservable<T>(source: Signal<T>): Observable<T>;
+export declare function toObservable<T>(source: Signal<T>, options?: ToObservableOptions): Observable<T>;

package/signals/implementation/to-observable.js

@@ -6,7 +6,7 @@ import { untracked } from './untracked.js';
  *
  * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
  */
-export function toObservable(source) {
+export function toObservable(source, options) {
     return new Observable((subscriber) => {
         const effectRef = effect(() => {
             try {
@@ -16,7 +16,7 @@ export function toObservable(source) {
             catch (error) {
                 untracked(() => subscriber.error(error));
             }
-        }, { allowSignalWrites: true });
+        }, { allowSignalWrites: true, injector: options?.injector });
         return () => effectRef.destroy();
     });
 }

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

@@ -6,11 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import type { Observable, Subscribable } from 'rxjs';
+import { Injector } from '../api.js';
 import type { Signal } from './api.js';
-/**
- * Options for `toSignal`.
- */
-export interface ToSignalOptions {
+import { ValueEqualityFn } from './equality.js';
+export interface ToSignalOptions<T> {
     /**
      * Initial value for the signal produced by `toSignal`.
      *
@@ -26,6 +25,21 @@ export interface ToSignalOptions {
      * not met.
      */
     requireSync?: boolean;
+    /**
+     * `Injector` which will provide the `DestroyRef` used to clean up the Observable subscription.
+     *
+     * If this is not provided, a `DestroyRef` will be retrieved from the current [injection
+     * context](guide/di/dependency-injection-context), unless manual cleanup is requested.
+     */
+    injector?: Injector;
+    /**
+     * Whether the subscription should be automatically cleaned up (via `DestroyRef`) when
+     * `toSignal`'s creation context is destroyed.
+     *
+     * If manual cleanup is enabled, then `DestroyRef` is not used, and the subscription will persist
+     * until the `Observable` itself completes.
+     */
+    manualCleanup?: boolean;
     /**
      * Whether `toSignal` should throw errors from the Observable error channel back to RxJS, where
      * they'll be processed as uncaught exceptions.
@@ -35,21 +49,27 @@ export interface ToSignalOptions {
      * the behavior of the `async` pipe.
      */
     rejectErrors?: boolean;
+    /**
+     * A comparison function which defines equality for values emitted by the observable.
+     *
+     * Equality comparisons are executed against the initial value if one is provided.
+     */
+    equal?: ValueEqualityFn<T>;
 }
 export declare function toSignal<T>(source: Observable<T> | Subscribable<T>): Signal<T | undefined>;
-export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: ToSignalOptions & {
+export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | undefined>> & {
     initialValue?: undefined;
     requireSync?: false;
 }): Signal<T | undefined>;
-export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: ToSignalOptions & {
+export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | null>> & {
     initialValue?: null;
     requireSync?: false;
 }): Signal<T | null>;
-export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: ToSignalOptions & {
+export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T>> & {
     initialValue?: undefined;
     requireSync: true;
 }): Signal<T>;
-export declare function toSignal<T, const U extends T>(source: Observable<T> | Subscribable<T>, options: ToSignalOptions & {
+export declare function toSignal<T, const U extends T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | U>> & {
     initialValue: U;
     requireSync?: false;
 }): Signal<T | U>;

package/signals/implementation/to-signal.js

@@ -2,7 +2,7 @@
 import { registerFinalization } from '../../memory/finalization.js';
 import { assertNotInReactiveContext } from './asserts.js';
 import { computed } from './computed.js';
-import { signal } from './signal.js';
+import { signal } from './writable-signal.js';
 /**
  * Get the current value of an `Observable` as a reactive `Signal`.
  *
@@ -18,16 +18,17 @@ import { signal } from './signal.js';
 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.');
+    const equal = makeToSignalEqual(options?.equal);
     // 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;
     if (options?.requireSync) {
         // Initially the signal is in a `NoValue` state.
-        state = signal({ kind: StateKind.NoValue });
+        state = signal({ kind: StateKind.NoValue }, { equal });
     }
     else {
         // If an initial value was passed, use it. Otherwise, use `undefined` as the initial value.
-        state = signal({ kind: StateKind.Value, value: options?.initialValue });
+        state = signal({ kind: StateKind.Value, value: options?.initialValue }, { equal });
     }
     // 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
@@ -36,8 +37,8 @@ export function toSignal(source, options) {
     // 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 => {
+        next: (value) => state.set({ kind: StateKind.Value, value }),
+        error: (error) => {
             if (options?.rejectErrors) {
                 // Kick the error back to RxJS. It will be caught and rethrown in a macrotask, which causes
                 // the error to end up as an uncaught exception.
@@ -62,13 +63,15 @@ export function toSignal(source, options) {
                 throw current.error;
             case StateKind.NoValue:
                 // This shouldn't really happen because the error is thrown on creation.
-                // TODO(alxhub): use a RuntimeError when we finalize the error semantics
                 throw new Error('`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');
         }
-    });
+    }, { equal: options?.equal });
     registerFinalization(result, () => sub.unsubscribe());
     return result;
 }
+function makeToSignalEqual(userEquality = Object.is) {
+    return (a, b) => a.kind === StateKind.Value && b.kind === StateKind.Value && userEquality(a.value, b.value);
+}
 var StateKind;
 (function (StateKind) {
     StateKind[StateKind["NoValue"] = 0] = "NoValue";

package/signals/implementation/watch.d.ts

@@ -5,8 +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 type { ReactiveNode } from './graph.js';
-import { SIGNAL } from './graph.js';
+import { type ReactiveNode, SIGNAL } 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.

package/signals/implementation/watch.js

@@ -1,5 +1,11 @@
-/* eslint-disable */
-import { consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, isInNotificationPhase, REACTIVE_NODE, SIGNAL } from './graph.js';
+/**
+ * @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 { consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, isInNotificationPhase, REACTIVE_NODE, SIGNAL, } from './graph.js';
 export function createWatch(fn, schedule, allowSignalWrites) {
     const node = Object.create(WATCH_NODE);
     if (allowSignalWrites) {

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

@@ -0,0 +1,48 @@
+import { Signal } from './api.js';
+import { ValueEqualityFn } from './equality.js';
+import { SignalGetter } from './signal.js';
+/**
+ * @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 `Signal` with a value that can be mutated via a setter interface.
+ */
+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
+     * notify any dependents.
+     */
+    update(updateFn: (value: T) => T): void;
+    /**
+     * Returns a readonly version of this signal. Readonly signals can be accessed to read their value
+     * but can't be changed using set or update methods. The readonly signals do _not_ have
+     * any built-in mechanism that would prevent deep-mutation of their value.
+     */
+    asReadonly(): Signal<T>;
+}
+/**
+ * Options passed to the `signal` creation function.
+ */
+export interface CreateSignalOptions<T> {
+    /**
+     * A comparison function which defines equality for signal values.
+     */
+    equal?: ValueEqualityFn<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 signalAsReadonlyFn<T>(this: SignalGetter<T>): Signal<T>;
+/**
+ * Checks if the given `value` is a writeable signal.
+ */
+export declare function isWritableSignal(value: unknown): value is WritableSignal<unknown>;

package/signals/implementation/writable-signal.js

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import { SIGNAL } from '../symbol.js';
+import { isSignal } from './api.js';
+import { createSignal, signalSetFn, signalUpdateFn } from './signal.js';
+/**
+ * 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;
+}
+export function signalAsReadonlyFn() {
+    const node = this[SIGNAL];
+    if (node.readonlyFn === undefined) {
+        const readonlyFn = () => this();
+        readonlyFn[SIGNAL] = node;
+        node.readonlyFn = readonlyFn;
+    }
+    return node.readonlyFn;
+}
+/**
+ * Checks if the given `value` is a writeable signal.
+ */
+export function isWritableSignal(value) {
+    return isSignal(value) && typeof value.set === 'function';
+}

package/signals/operators/derive-async.d.ts

@@ -1,6 +1,6 @@
 import { concatAll, exhaustAll, mergeAll, switchAll, type Observable } from 'rxjs';
 import { type Signal, type ToSignalOptions } from '../api.js';
-export type DeriveAsyncOptions = ToSignalOptions & {
+export type DeriveAsyncOptions<T> = ToSignalOptions<T> & {
     behavior?: DeriveAsyncBehavior;
 };
 declare const operatorMap: {
@@ -12,19 +12,19 @@ declare const operatorMap: {
 export type DeriveAsyncBehavior = keyof typeof operatorMap;
 type DeriveAsyncSourceParameter<T> = () => (T | Promise<T> | Observable<T>);
 export declare function deriveAsync<T>(source: DeriveAsyncSourceParameter<T>): Signal<T | undefined>;
-export declare function deriveAsync<T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions & {
+export declare function deriveAsync<T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions<T> & {
     initialValue?: undefined;
     requireSync?: false;
 }): Signal<T | undefined>;
-export declare function deriveAsync<T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions & {
+export declare function deriveAsync<T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions<T> & {
     initialValue?: null;
     requireSync?: false;
 }): Signal<T | null>;
-export declare function deriveAsync<T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions & {
+export declare function deriveAsync<T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions<T> & {
     initialValue?: undefined;
     requireSync: true;
 }): Signal<T>;
-export declare function deriveAsync<T, const U extends T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions & {
+export declare function deriveAsync<T, const U extends T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions<T> & {
     initialValue: U;
     requireSync?: false;
 }): Signal<T | U>;

package/signals/to-lazy-signal.js

@@ -1,19 +1,11 @@
-import { Subject, switchMap } from 'rxjs';
-import { computed, toSignal } from './api.js';
-const LAZY = Symbol('LAZY');
+import { computed, getCurrentSignalsInjector, runInSignalsInjectionContext, toSignal, untracked } from './api.js';
 export const toLazySignal = 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
+    const injector = getCurrentSignalsInjector();
     let computation = () => {
-        subscribe$.next();
-        subscribe$.complete();
+        const signal = untracked(() => runInSignalsInjectionContext(injector, () => toSignal(source, { ...options }))); // eslint-disable-line @typescript-eslint/no-unsafe-argument
         const value = signal();
         computation = signal;
-        if (value == LAZY) {
-            throw new Error('`toLazySignal()` called with `requireSync` but `Observable` did not emit synchronously.');
-        }
         return value;
     };
-    return computed(() => computation());
+    return computed(() => computation(), { equal: options?.equal });
 };

package/utils/function/memoize.d.ts

@@ -4,12 +4,12 @@ export type MemoizeOptions = {
     weak?: boolean;
 };
 /**
- * memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
+ * Memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
  * @param fn function memoize
  * @returns memoized function
  */ export declare function memoize<Fn extends (...parameters: any[]) => any>(fn: Fn, options?: MemoizeOptions): Fn;
 /**
- * memoizes a function with a single parameter. Faster than {@link memoize}
+ * Memoizes a function with a single parameter. Faster than {@link memoize}
  * @param fn function memoize
  * @returns memoized function
  */

package/utils/function/memoize.js

@@ -1,7 +1,7 @@
 import { IterableWeakMap } from '../../data-structures/iterable-weak-map.js';
 import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
 /**
- * memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
+ * Memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
  * @param fn function memoize
  * @returns memoized function
  */ export function memoize(fn, options = {}) {
@@ -19,7 +19,7 @@ import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
     }[name];
 }
 /**
- * memoizes a function with a single parameter. Faster than {@link memoize}
+ * Memoizes a function with a single parameter. Faster than {@link memoize}
  * @param fn function memoize
  * @returns memoized function
  */

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

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