@nmtjs/core 0.12.5 → 0.12.7

package/dist/enums.js

@@ -1,22 +1,20 @@
-export let Scope = /* @__PURE__ */ function(Scope) {
-	Scope["Global"] = "Global";
-	Scope["Connection"] = "Connection";
-	Scope["Call"] = "Call";
-	Scope["Transient"] = "Transient";
-	return Scope;
-}({});
-export let Hook = /* @__PURE__ */ function(Hook) {
-	Hook["BeforeInitialize"] = "BeforeInitialize";
-	Hook["AfterInitialize"] = "AfterInitialize";
-	Hook["BeforeStart"] = "BeforeStart";
-	Hook["AfterStart"] = "AfterStart";
-	Hook["BeforeStop"] = "BeforeStop";
-	Hook["AfterStop"] = "AfterStop";
-	Hook["BeforeTerminate"] = "BeforeTerminate";
-	Hook["AfterTerminate"] = "AfterTerminate";
-	Hook["OnConnect"] = "OnConnect";
-	Hook["OnDisconnect"] = "OnDisconnect";
-	return Hook;
-}({});
-
-//# sourceMappingURL=enums.js.map
+export var Scope;
+(function (Scope) {
+    Scope["Global"] = "Global";
+    Scope["Connection"] = "Connection";
+    Scope["Call"] = "Call";
+    Scope["Transient"] = "Transient";
+})(Scope || (Scope = {}));
+export var Hook;
+(function (Hook) {
+    Hook["BeforeInitialize"] = "BeforeInitialize";
+    Hook["AfterInitialize"] = "AfterInitialize";
+    Hook["BeforeStart"] = "BeforeStart";
+    Hook["AfterStart"] = "AfterStart";
+    Hook["BeforeStop"] = "BeforeStop";
+    Hook["AfterStop"] = "AfterStop";
+    Hook["BeforeTerminate"] = "BeforeTerminate";
+    Hook["AfterTerminate"] = "AfterTerminate";
+    Hook["OnConnect"] = "OnConnect";
+    Hook["OnDisconnect"] = "OnDisconnect";
+})(Hook || (Hook = {}));

package/dist/hooks.d.ts

@@ -0,0 +1,19 @@
+import type { Callback } from '@nmtjs/common';
+import { kHookCollection } from './constants.ts';
+import type { Hook } from './enums.ts';
+export interface HookType {
+    [key: string]: (...args: any[]) => any;
+}
+export type CallHook<T extends string> = (hook: T, ...args: T extends keyof HookType ? Parameters<HookType[T]> : any[]) => Promise<void>;
+export declare class Hooks {
+    static merge(from: Hooks, to: Hooks): void;
+    [kHookCollection]: Map<string, Set<Callback>>;
+    add(name: string, callback: Callback): () => void;
+    remove(name: string, callback: Callback): void;
+    call<T extends string | Hook>(name: T, options: {
+        concurrent?: boolean;
+        reverse?: boolean;
+    } | undefined, ...args: T extends Hook ? Parameters<HookType[T]> : any[]): Promise<void>;
+    clear(): void;
+}
+export declare const createErrForHook: (hook: Hook | (object & string)) => string;

package/dist/hooks.js

@@ -1,39 +1,43 @@
 import { kHookCollection } from "./constants.js";
 export class Hooks {
-	static merge(from, to) {
-		for (const [name, callbacks] of from[kHookCollection]) {
-			for (const callback of callbacks) {
-				to.add(name, callback);
-			}
-		}
-	}
-	[kHookCollection] = new Map();
-	add(name, callback) {
-		let hooks = this[kHookCollection].get(name);
-		if (!hooks) this[kHookCollection].set(name, hooks = new Set());
-		hooks.add(callback);
-		return () => this.remove(name, callback);
-	}
-	remove(name, callback) {
-		const hooks = this[kHookCollection].get(name);
-		if (hooks) hooks.delete(callback);
-	}
-	async call(name, options, ...args) {
-		const { concurrent = true, reverse = false } = options ?? {};
-		const hooks = this[kHookCollection].get(name);
-		if (!hooks) return;
-		const hooksArr = Array.from(hooks);
-		if (concurrent) {
-			await Promise.all(hooksArr.map((hook) => hook(...args)));
-		} else {
-			if (reverse) hooksArr.reverse();
-			for (const hook of hooksArr) await hook(...args);
-		}
-	}
-	clear() {
-		this[kHookCollection].clear();
-	}
+    static merge(from, to) {
+        for (const [name, callbacks] of from[kHookCollection]) {
+            for (const callback of callbacks) {
+                to.add(name, callback);
+            }
+        }
+    }
+    [kHookCollection] = new Map();
+    add(name, callback) {
+        let hooks = this[kHookCollection].get(name);
+        if (!hooks)
+            this[kHookCollection].set(name, (hooks = new Set()));
+        hooks.add(callback);
+        return () => this.remove(name, callback);
+    }
+    remove(name, callback) {
+        const hooks = this[kHookCollection].get(name);
+        if (hooks)
+            hooks.delete(callback);
+    }
+    async call(name, options, ...args) {
+        const { concurrent = true, reverse = false } = options ?? {};
+        const hooks = this[kHookCollection].get(name);
+        if (!hooks)
+            return;
+        const hooksArr = Array.from(hooks);
+        if (concurrent) {
+            await Promise.all(hooksArr.map((hook) => hook(...args)));
+        }
+        else {
+            if (reverse)
+                hooksArr.reverse();
+            for (const hook of hooksArr)
+                await hook(...args);
+        }
+    }
+    clear() {
+        this[kHookCollection].clear();
+    }
 }
 export const createErrForHook = (hook) => `Error during [${hook}] hook`;
-
-//# sourceMappingURL=hooks.js.map

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './constants.ts';
+export * from './container.ts';
+export * from './enums.ts';
+export * from './hooks.ts';
+export * from './injectables.ts';
+export * from './logger.ts';
+export * from './metadata.ts';
+export * from './plugin.ts';
+export * from './registry.ts';
+export * from './types.ts';
+export * from './utils/index.ts';

package/dist/index.js

@@ -1,3 +1,6 @@
+// biome-ignore lint/correctness/noUnusedImports: TSC wants it
+// biome-ignore assist/source/organizeImports: TSC wants it
+import {} from 'pino';
 export * from "./constants.js";
 export * from "./container.js";
 export * from "./enums.js";
@@ -9,5 +12,3 @@ export * from "./plugin.js";
 export * from "./registry.js";
 export * from "./types.js";
 export * from "./utils/index.js";
-
-//# sourceMappingURL=index.js.map

package/dist/injectables.d.ts

@@ -0,0 +1,115 @@
+import { type Async, type ClassConstructor, type ClassConstructorArgs, type ClassInstance } from '@nmtjs/common';
+import { kClassInjectable, kFactoryInjectable, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable } from './constants.ts';
+import { type Hook, Scope } from './enums.ts';
+import { Hooks, type HookType } from './hooks.ts';
+import type { Logger } from './logger.ts';
+import type { Registry } from './registry.ts';
+export type DependencyOptional<T extends AnyInjectable = AnyInjectable> = {
+    [kOptionalDependency]: any;
+    injectable: T;
+};
+export type Depedency = DependencyOptional | AnyInjectable;
+export type Dependencies = Record<string, Depedency>;
+export type ResolveInjectableType<T extends AnyInjectable> = T extends Injectable<infer Type, any, any> ? Type : never;
+export interface Dependant<Deps extends Dependencies = Dependencies> {
+    dependencies: Deps;
+    label?: string;
+    stack?: string;
+}
+export type DependencyInjectable<T extends Depedency> = T extends AnyInjectable ? T : T extends DependencyOptional ? T['injectable'] : never;
+export type DependencyContext<Deps extends Dependencies> = {
+    readonly [K in keyof Deps as Deps[K] extends AnyInjectable ? K : never]: Deps[K] extends AnyInjectable ? ResolveInjectableType<Deps[K]> : never;
+} & {
+    readonly [K in keyof Deps as Deps[K] extends DependencyOptional ? K : never]?: Deps[K] extends DependencyOptional ? ResolveInjectableType<Deps[K]['injectable']> : never;
+};
+export type InjectableFactoryType<InjectableType, InjectableDeps extends Dependencies> = (context: DependencyContext<InjectableDeps>) => Async<InjectableType>;
+export type InjectablePickType<Input, Output> = (injectable: Input) => Output;
+export type InjectableDisposeType<InjectableType, InjectableDeps extends Dependencies> = (instance: InjectableType, context: DependencyContext<InjectableDeps>) => any;
+export interface LazyInjectable<T, S extends Scope = Scope.Global> extends Dependant<{}> {
+    scope: S;
+    [kInjectable]: any;
+    [kLazyInjectable]: T;
+}
+export interface ValueInjectable<T> extends Dependant<{}> {
+    scope: Scope.Global;
+    value: T;
+    [kInjectable]: any;
+    [kValueInjectable]: any;
+}
+export interface FactoryInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global, P = T> extends Dependant<D> {
+    scope: S;
+    factory: InjectableFactoryType<P, D>;
+    pick: InjectablePickType<P, T>;
+    dispose?: InjectableDisposeType<P, D>;
+    [kInjectable]: any;
+    [kFactoryInjectable]: any;
+}
+export interface BaseClassInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global> extends Dependant<D> {
+    new (...args: any[]): T;
+    scope: S;
+    [kInjectable]: any;
+    [kClassInjectable]: any;
+}
+export interface ClassInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global, A extends any[] = []> extends Dependant<D> {
+    new ($context: DependencyContext<D>, ...args: A): T & {
+        $context: DependencyContext<D>;
+    };
+    scope: S;
+    [kInjectable]: any;
+    [kClassInjectable]: any;
+}
+export type Injectable<V = any, D extends Dependencies = {}, S extends Scope = Scope> = LazyInjectable<V, S> | ValueInjectable<V> | FactoryInjectable<V, D, S, any> | BaseClassInjectable<V, D, S>;
+export type AnyInjectable<T = any, S extends Scope = Scope> = Injectable<T, any, S>;
+export declare const isLazyInjectable: (injectable: any) => injectable is LazyInjectable<any>;
+export declare const isFactoryInjectable: (injectable: any) => injectable is FactoryInjectable<any>;
+export declare const isClassInjectable: (injectable: any) => injectable is ClassInjectable<any>;
+export declare const isValueInjectable: (injectable: any) => injectable is ValueInjectable<any>;
+export declare const isInjectable: (injectable: any) => injectable is AnyInjectable<any>;
+export declare const isOptionalInjectable: (injectable: any) => injectable is DependencyOptional<any>;
+export declare function getInjectableScope(injectable: AnyInjectable): Scope;
+export declare function getDepedencencyInjectable(dependency: Depedency): AnyInjectable;
+export declare function createOptionalInjectable<T extends AnyInjectable>(injectable: T): DependencyOptional<T>;
+export declare function createLazyInjectable<T, S extends Scope = Scope.Global>(scope?: S, label?: string, stackTraceDepth?: number): LazyInjectable<T, S>;
+export declare function createValueInjectable<T>(value: T, label?: string, stackTraceDepth?: number): ValueInjectable<T>;
+export declare function createFactoryInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global, P = T>(paramsOrFactory: {
+    dependencies?: D;
+    scope?: S;
+    pick?: InjectablePickType<P, T>;
+    factory: InjectableFactoryType<P, D>;
+    dispose?: InjectableDisposeType<P, D>;
+} | InjectableFactoryType<P, D>, label?: string, stackTraceDepth?: number): FactoryInjectable<null extends T ? P : T, D, S, P>;
+export declare const createClassInjectable: <D extends Dependencies = {}, S extends Scope = Scope.Global>(dependencies?: D, scope?: S, stackTraceDepth?: number) => ClassInjectable<ClassInstance<{
+    new ($context: DependencyContext<D>): {
+        $context: DependencyContext<D>;
+        $onCreate(): Promise<void>;
+        $onDispose(): Promise<void>;
+    };
+    dependencies: D;
+    scope: S;
+    stack: string | undefined;
+    get label(): string;
+    [kInjectable]: boolean;
+    [kClassInjectable]: boolean;
+}>, D, S>;
+export declare function createExtendableClassInjectable<B extends ClassConstructor<any>, D extends Dependencies = {}, S extends Scope = Scope.Global>(baseClass: B, dependencies?: D, scope?: S, stackTraceDepth?: number): B extends ClassInjectable<any> ? ClassInjectable<ClassInstance<B>, D, S> : ClassInjectable<ClassInstance<B>, D, S, ClassConstructorArgs<B, []>>;
+export type DependenciesSubstitution<T extends Dependencies> = {
+    [K in keyof T]?: T[K] extends AnyInjectable<infer Type> ? AnyInjectable<Type> | DependenciesSubstitution<T[K]['dependencies']> : never;
+};
+export declare function substitute<T extends FactoryInjectable<any, any, Scope> | BaseClassInjectable<any, any, Scope>>(injectable: T, substitution: DependenciesSubstitution<T['dependencies']>, stackTraceDepth?: number): T;
+export declare function compareScope(left: Scope, operator: '>' | '<' | '>=' | '<=' | '=' | '!=', right: Scope): boolean;
+export declare const CoreInjectables: {
+    logger: LazyInjectable<Logger, Scope.Global>;
+    registry: LazyInjectable<Registry, Scope.Global>;
+    inject: LazyInjectable<(<T extends AnyInjectable>(injectable: T, context: { [K in keyof T["dependencies"]]?: ResolveInjectableType<T["dependencies"][K]> | AnyInjectable<ResolveInjectableType<T["dependencies"][K]>> | undefined; }) => Promise<ResolveInjectableType<T>>) & {
+        explicit: <T extends AnyInjectable>(injectable: T, context: { [K in keyof T["dependencies"]]?: ResolveInjectableType<T["dependencies"][K]> | AnyInjectable<ResolveInjectableType<T["dependencies"][K]>> | undefined; }) => Promise<Awaited<ResolveInjectableType<T>> & {
+            [Symbol.asyncDispose]: () => Promise<void>;
+        }>;
+    }, Scope.Global>;
+    dispose: LazyInjectable<(<T extends AnyInjectable>(injectable: T, instance?: any) => Promise<void>), Scope.Global>;
+    hook: FactoryInjectable<(<T extends Hook>(name: T, callback: HookType[T]) => () => void), {
+        registry: LazyInjectable<Registry, Scope.Global>;
+    }, Scope.Transient, {
+        hooks: Hooks;
+        on: <T extends Hook>(name: T, callback: HookType[T]) => () => void;
+    }>;
+};