@tstdl/base 0.91.4 → 0.91.7

package/data-structures/collection.js

@@ -1,5 +1,5 @@
 import { BehaviorSubject, Subject, distinctUntilChanged, filter, firstValueFrom, map, startWith } from 'rxjs';
-import { toLazySignal } from '../signals/index.js';
+import { getCurrentSignalsInjector, toLazySignal, untracked } from '../signals/index.js';
 import { lazyProperty } from '../utils/object/lazy-property.js';
 export class Collection {
     sizeSubject = new BehaviorSubject(0);
@@ -50,10 +50,11 @@ export class Collection {
         return this.size > 0;
     }
     constructor() {
-        lazyProperty(this, '$size', () => toLazySignal(this.size$, { requireSync: true }));
-        lazyProperty(this, '$observe', () => toLazySignal(this.observe$, { equal: () => false, requireSync: true }));
-        lazyProperty(this, '$isEmpty', () => toLazySignal(this.isEmpty$, { requireSync: true }));
-        lazyProperty(this, '$hasItems', () => toLazySignal(this.hasItems$, { requireSync: true }));
+        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.4",
+  "version": "0.91.7",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/signals/api.d.ts

@@ -1,6 +1,8 @@
+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 SignalsConfiguration = {
+export type Injector = Tagged<symbol, 'injector'>;
+export type SignalsConfiguration<TInjector = Injector> = {
     signal: typeof Types.signal;
     computed: typeof Types.computed;
     effect: typeof Types.effect;
@@ -8,6 +10,8 @@ export type SignalsConfiguration = {
     isSignal: typeof Types.isSignal;
     toSignal: typeof Types.toSignal;
     toObservable: typeof Types.toObservable;
+    getCurrentSignalsInjector: () => TInjector;
+    runInSignalsInjectionContext: <ReturnT>(injector: TInjector, 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 function configureSignals(configuration: SignalsConfiguration): void;
+export declare let getCurrentSignalsInjector: SignalsConfiguration['getCurrentSignalsInjector'];
+export declare let runInSignalsInjectionContext: SignalsConfiguration['runInSignalsInjectionContext'];
+export declare function configureSignals<TInjector>(configuration: SignalsConfiguration<TInjector>): 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/configure.js

@@ -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/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,6 +6,7 @@
  * 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';
 import { ValueEqualityFn } from './equality.js';
 export interface ToSignalOptions<T> {
@@ -24,6 +25,21 @@ export interface ToSignalOptions<T> {
      * 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.

package/signals/to-lazy-signal.js

@@ -1,7 +1,8 @@
-import { computed, toSignal, untracked } from './api.js';
+import { computed, getCurrentSignalsInjector, runInSignalsInjectionContext, toSignal, untracked } from './api.js';
 export const toLazySignal = function toLazySignal(source, options) {
+    const injector = getCurrentSignalsInjector();
     let computation = () => {
-        const signal = untracked(() => toSignal(source, { ...options })); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+        const signal = untracked(() => runInSignalsInjectionContext(injector, () => toSignal(source, { ...options }))); // eslint-disable-line @typescript-eslint/no-unsafe-argument
         const value = signal();
         computation = signal;
         return value;