ts-ioc-container 56.1.0 → 56.2.0

package/typings/token/SingleAliasToken.d.ts

@@ -0,0 +1,21 @@
+import { DependencyKey, IContainer, ResolveOneOptions } from '../container/IContainer.js';
+import { InjectionToken } from './InjectionToken.js';
+import { IRegistration } from '../registration/IRegistration.js';
+import { BindToken } from './BindToken.js';
+import { ArgsFn } from '../provider/IProvider.js';
+export declare class SingleAliasToken<T = any> extends InjectionToken<T> implements BindToken<T> {
+    readonly token: DependencyKey;
+    private readonly _getArgsFn;
+    private readonly _isLazy;
+    constructor(token: DependencyKey, { getArgsFn, isLazy }?: {
+        getArgsFn?: ArgsFn;
+        isLazy?: boolean;
+    });
+    select<R>(fn: (target: T) => R): (s: IContainer) => R;
+    resolve(s: IContainer, { args, lazy }?: ResolveOneOptions): T;
+    bindTo(r: IRegistration<T>): void;
+    args(...newArgs: unknown[]): SingleAliasToken<T>;
+    argsFn(fn: (s: IContainer) => unknown[]): SingleAliasToken<T>;
+    lazy(): SingleAliasToken<T>;
+}
+export declare const toSingleAlias: <T>(token: DependencyKey) => SingleAliasToken<T>;

package/typings/token/SingleToken.d.ts

@@ -0,0 +1,19 @@
+import { DependencyKey, IContainer } from '../container/IContainer.js';
+import { InjectionToken } from './InjectionToken.js';
+import { IRegistration } from '../registration/IRegistration.js';
+import { ArgsFn, ProviderOptions } from '../provider/IProvider.js';
+export declare class SingleToken<T = any> extends InjectionToken<T> {
+    token: DependencyKey;
+    private readonly _getArgsFn;
+    private readonly _isLazy;
+    constructor(token: DependencyKey, { getArgsFn, isLazy }?: {
+        getArgsFn?: ArgsFn;
+        isLazy?: boolean;
+    });
+    select<R>(fn: (target: T) => R): (s: IContainer) => R;
+    resolve(s: IContainer, { args, lazy }?: ProviderOptions): T;
+    bindTo(r: IRegistration<T>): void;
+    args(...newArgs: unknown[]): SingleToken<T>;
+    argsFn(fn: (s: IContainer) => unknown[]): SingleToken<T>;
+    lazy(): SingleToken<T>;
+}

package/typings/token/toToken.d.ts

@@ -0,0 +1,6 @@
+import { DependencyKey } from '../container/IContainer.js';
+import { InjectionToken } from './InjectionToken.js';
+import { InjectFn } from '../hooks/hook.js';
+import { type constructor } from '../utils/basic.js';
+export declare const toToken: <T = any>(token: InjectFn<T> | InjectionToken<T> | DependencyKey | constructor<T>) => InjectionToken<T>;
+export declare const argToToken: (v: unknown) => InjectionToken<unknown>;

package/typings/utils/array.d.ts

@@ -0,0 +1,3 @@
+export declare const Filter: {
+    exclude: <T>(arr: Set<T> | T[]) => (v: T) => boolean;
+};

package/typings/utils/basic.d.ts

@@ -0,0 +1,11 @@
+export type constructor<T> = new (...args: any[]) => T;
+export interface Instance<T = unknown> {
+    new (...args: unknown[]): T;
+}
+export declare const Is: {
+    nullish: <T>(value: T | undefined | null) => value is null | undefined;
+    object: (target: unknown) => target is object;
+    instance: (target: unknown) => target is Instance;
+    constructor: (target: unknown) => target is constructor<unknown>;
+};
+export declare function resolveConstructor(target: object): object;

package/typings/utils/debounce.d.ts

@@ -0,0 +1 @@
+export declare const debounce: (ms: number) => MethodDecorator;

package/typings/utils/errorHandler.d.ts

@@ -0,0 +1,6 @@
+export type HandleErrorParams = (error: unknown, context: {
+    target: string;
+    method: string;
+}) => void;
+export declare const handleAsyncError: (errorHandler: HandleErrorParams) => MethodDecorator;
+export declare const handleError: (errorHandler: HandleErrorParams) => MethodDecorator;

package/typings/utils/fp.d.ts

@@ -0,0 +1,13 @@
+export type MapFn<A, B = A> = (value: A) => B;
+export declare function pipe<A>(fn1: MapFn<A>): MapFn<A>;
+export declare function pipe<A, B>(fn1: MapFn<A, B>): MapFn<A, B>;
+export declare function pipe<A, B, C>(fn1: MapFn<A, B>, fn2: MapFn<B, C>): MapFn<A, C>;
+export declare function pipe<A, B, C, D>(fn1: MapFn<A, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>): MapFn<A, D>;
+export declare function pipe<A, B, C, D, E>(fn1: MapFn<A, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>): MapFn<A, E>;
+export declare function pipe<A, B, C, D, E, F>(fn1: MapFn<A, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>): MapFn<A, F>;
+export declare function pipe<A, B, C, D, E, F, G>(fn1: MapFn<A, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>): MapFn<A, G>;
+export declare function pipe<A, B, C, D, E, F, G, H>(fn1: MapFn<A, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>): MapFn<A, H>;
+export declare function pipe<A, B, C, D, E, F, G, H, I>(fn1: MapFn<A, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>, fn8: MapFn<H, I>): MapFn<A, I>;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J>(fn1: MapFn<A, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>, fn8: MapFn<H, I>, fn9: MapFn<I, J>): MapFn<A, J>;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(fn1: MapFn<A, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>, fn8: MapFn<H, I>, fn9: MapFn<I, J>, fn10: MapFn<J, K>): MapFn<A, K>;
+export declare function pipe<T>(...mappers: MapFn<T>[]): MapFn<T>;

package/typings/utils/once.d.ts

@@ -0,0 +1,8 @@
+type RepeatOptions = {
+    index: number;
+    args: unknown[];
+};
+export declare const once: ({ onRepeat }?: {
+    onRepeat?: (options: RepeatOptions) => void;
+}) => MethodDecorator;
+export {};

package/typings/utils/promise.d.ts

@@ -0,0 +1 @@
+export declare const promisify: <T>(arg: T | Promise<T>) => Promise<T>;

package/typings/utils/proxy.d.ts

@@ -0,0 +1,4 @@
+export declare function isProxy(value: object): boolean;
+export declare function getProxyTarget<T extends object>(value: T): T;
+export declare function lazyProxy<T extends object>(resolveInstance: () => T): T;
+export declare function toLazyIf<T extends object>(resolveInstance: () => T, isLazy?: boolean): T;

package/typings/utils/shallowCache.d.ts

@@ -0,0 +1 @@
+export declare const shallowCache: (getKeyByArgs: (...args: unknown[]) => unknown) => MethodDecorator;

package/typings/utils/throttle.d.ts

@@ -0,0 +1 @@
+export declare const throttle: (ms: number) => MethodDecorator;