@tstdl/base 0.88.7 → 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/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';