@tstdl/base 0.88.6 → 0.89.0

package/promise/lazy-promise.d.ts

@@ -1,11 +1,11 @@
-type PromiseExecutor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void;
-export declare class LazyPromise<T> implements Promise<T> {
-    static readonly [Symbol.species]: PromiseConstructor;
-    private readonly backingPromise;
+import { CustomPromise } from './custom-promise.js';
+import type { PromiseExecutor } from './types.js';
+export declare class LazyPromise<T> extends CustomPromise<T> {
+    #private;
     readonly [Symbol.toStringTag] = "LazyPromise";
-    constructor(executorOrPromiseProvider: () => (Promise<T> | PromiseExecutor<T>));
+    constructor(executorOrPromiseProvider: PromiseExecutor<T> | (() => PromiseLike<T>));
     then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
     catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
     finally(onfinally?: (() => void) | null | undefined): Promise<T>;
+    private execute;
 }
-export {};

package/promise/lazy-promise.js

@@ -1,25 +1,33 @@
-import { lazyProperty } from '../utils/object/lazy-property.js';
-import { isPromise } from '../utils/type-guards.js';
-export class LazyPromise {
-    static [Symbol.species] = Promise;
-    backingPromise;
+import { isPromiseLike } from '../utils/type-guards.js';
+import { CustomPromise } from './custom-promise.js';
+export class LazyPromise extends CustomPromise {
+    #executed = false;
+    #executorOrPromiseProvider;
     [Symbol.toStringTag] = 'LazyPromise';
     constructor(executorOrPromiseProvider) {
-        lazyProperty(this, 'backingPromise', async () => {
-            const providedValue = executorOrPromiseProvider();
-            if (isPromise(providedValue)) {
-                return providedValue;
-            }
-            return new Promise(providedValue);
-        });
+        super();
+        this.#executorOrPromiseProvider = executorOrPromiseProvider;
     }
     async then(onfulfilled, onrejected) {
-        return this.backingPromise.then(onfulfilled, onrejected);
+        this.execute();
+        return super.then(onfulfilled, onrejected);
     }
     async catch(onrejected) {
-        return this.backingPromise.catch(onrejected);
+        this.execute();
+        return super.catch(onrejected);
     }
     async finally(onfinally) {
-        return this.backingPromise.finally(onfinally);
+        this.execute();
+        return super.finally(onfinally);
+    }
+    execute() {
+        if (this.#executed) {
+            return;
+        }
+        this.#executed = true;
+        const result = this.#executorOrPromiseProvider(this.resolve, this.reject);
+        if (isPromiseLike(result)) {
+            this.resolve(result);
+        }
     }
 }

package/promise/types.d.ts

@@ -0,0 +1,3 @@
+export type PromiseExecutor<T> = ConstructorParameters<typeof Promise<T>>[0];
+export type PromiseResolveFunction<T> = (value: T | PromiseLike<T>) => void;
+export type PromiseRejectFunction = (reason?: any) => void;

package/promise/types.js

@@ -0,0 +1 @@
+export {};

package/signals/implementation/graph.d.ts

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

package/signals/implementation/graph.js

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

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

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

package/signals/implementation/to-observable.js

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

package/signals/implementation/watch.d.ts

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

package/signals/implementation/watch.js

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

package/signals/index.d.ts

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

package/signals/index.js

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

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

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

package/signals/to-observable-2.js

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

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

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

package/utils/type-guards.d.ts

@@ -252,6 +252,12 @@ export declare const assertPromise: AssertFunction<Promise<any>>;
 export declare const assertNotPromise: AssertNotFunction<Promise<any>>;
 export declare const assertPromisePass: AssertPassFunction<Promise<any>>;
 export declare const assertNotPromisePass: AssertNotPassFunction<Promise<any>>;
+export declare const isPromiseLike: IsFunction<PromiseLike<any>>;
+export declare const isNotPromiseLike: IsNotFunction<PromiseLike<any>>;
+export declare const assertPromiseLike: AssertFunction<PromiseLike<any>>;
+export declare const assertNotPromiseLike: AssertNotFunction<PromiseLike<any>>;
+export declare const assertPromiseLikePass: AssertPassFunction<PromiseLike<any>>;
+export declare const assertNotPromiseLikePass: AssertNotPassFunction<PromiseLike<any>>;
 export declare const isError: IsFunction<Error>;
 export declare const isNotError: IsNotFunction<Error>;
 export declare const assertError: AssertFunction<Error>;

package/utils/type-guards.js

@@ -313,6 +313,13 @@ export const assertPromise = promiseGuards.assertPromise;
 export const assertNotPromise = promiseGuards.assertNotPromise;
 export const assertPromisePass = promiseGuards.assertPromisePass;
 export const assertNotPromisePass = promiseGuards.assertNotPromisePass;
+const promiseLikeGuards = createGuards('PromiseLike', (value) => isPromise(value) || ((((typeof value == 'object') && (value != null)) || isFunction(value)) && ((typeof value.then) == 'function')));
+export const isPromiseLike = promiseLikeGuards.isPromiseLike;
+export const isNotPromiseLike = promiseLikeGuards.isNotPromiseLike;
+export const assertPromiseLike = promiseLikeGuards.assertPromiseLike;
+export const assertNotPromiseLike = promiseLikeGuards.assertNotPromiseLike;
+export const assertPromiseLikePass = promiseLikeGuards.assertPromiseLikePass;
+export const assertNotPromiseLikePass = promiseLikeGuards.assertNotPromiseLikePass;
 const errorGuards = createInstanceGuards('error', Error);
 export const isError = errorGuards.isError;
 export const isNotError = errorGuards.isNotError;

package/container/decorators.d.ts

@@ -1,2 +0,0 @@
-export { ForwardArg as forwardArg, ForwardRef as forwardRef, Inject as inject, InjectArg as injectArg, Injectable as injectable, Optional as optional, ReplaceClass as replaceClass, ResolveArg as resolveArg, ResolveArgProvider as resolveArgProvider, Scoped as scoped, Singleton as singleton } from '../injector/decorators.js';
-export type { InjectableOptionsWithoutLifecycle } from '../injector/decorators.js';

package/container/decorators.js

@@ -1 +0,0 @@
-export { ForwardArg as forwardArg, ForwardRef as forwardRef, Inject as inject, InjectArg as injectArg, Injectable as injectable, Optional as optional, ReplaceClass as replaceClass, ResolveArg as resolveArg, ResolveArgProvider as resolveArgProvider, Scoped as scoped, Singleton as singleton } from '../injector/decorators.js';

package/container/index.d.ts

@@ -1,3 +0,0 @@
-export * from './decorators.js';
-export * from './interfaces.js';
-export * from './token.js';

package/container/index.js

@@ -1,3 +0,0 @@
-export * from './decorators.js';
-export * from './interfaces.js';
-export * from './token.js';

package/container/interfaces.d.ts

@@ -1,2 +0,0 @@
-export { afterResolve, resolveArgumentType } from '../injector/interfaces.js';
-export type { AfterResolve, Resolvable as Injectable, ResolveArgument as InjectableArgument } from '../injector/interfaces.js';

package/container/interfaces.js

@@ -1 +0,0 @@
-export { afterResolve, resolveArgumentType } from '../injector/interfaces.js';

package/container/token.d.ts

@@ -1,2 +0,0 @@
-export { ReifyingInjectionToken, getTokenName, injectionToken } from '../injector/token.js';
-export type { ArgumentedInjectionToken, InjectionToken, SimpleInjectionToken } from '../injector/token.js';

package/container/token.js

@@ -1 +0,0 @@
-export { ReifyingInjectionToken, getTokenName, injectionToken } from '../injector/token.js';