@nmtjs/core 0.11.2 → 0.11.4

package/dist/container.js

@@ -1,5 +1,7 @@
+import assert from "node:assert";
+import { tryCaptureStackTrace } from "@nmtjs/common";
 import { Scope } from "./enums.js";
-import { CoreInjectables, compareScope, createValueInjectable, getDepedencencyInjectable, isClassInjectable, isFactoryInjectable, isInjectable, isLazyInjectable, isOptionalInjectable, isValueInjectable } from "./injectables.js";
+import { CoreInjectables, compareScope, createExtendableClassInjectable, createValueInjectable, getDepedencencyInjectable, isClassInjectable, isFactoryInjectable, isInjectable, isLazyInjectable, isOptionalInjectable, isValueInjectable } from "./injectables.js";
 export class Container {
 	instances = new Map();
 	resolvers = new Map();
@@ -13,7 +15,9 @@ export class Container {
 		if (scope === Scope.Transient) {
 			throw new Error("Invalid scope");
 		}
-		this.provide(CoreInjectables.inject, createInjectFunction(this));
+		this.provide(CoreInjectables.inject, this.createInjectFunction());
+		this.provide(CoreInjectables.dispose, this.createDisposeFunction());
+		this.provide(CoreInjectables.registry, application.registry);
 	}
 	async load() {
 		const traverse = (dependencies) => {
@@ -38,7 +42,9 @@ export class Container {
 		this.disposing = true;
 		const disposalOrder = this.getDisposalOrder();
 		for (const injectable of disposalOrder) {
-			await this.disposeInjectable(injectable);
+			if (this.instances.has(injectable)) {
+				await this.disposeInjectableInstances(injectable);
+			}
 		}
 		this.instances.clear();
 		this.injectables.clear();
@@ -53,8 +59,11 @@ export class Container {
 		return this.containsWithinSelf(injectable) || (this.parent?.contains(injectable) ?? false);
 	}
 	get(injectable) {
+		if (injectable.scope === Scope.Transient) {
+			throw new Error("Cannot get transient injectable directly");
+		}
 		if (this.instances.has(injectable)) {
-			return this.instances.get(injectable).instance;
+			return this.instances.get(injectable).at(0).public;
 		}
 		if (this.parent?.contains(injectable)) {
 			return this.parent.get(injectable);
@@ -84,11 +93,11 @@ export class Container {
 		if (compareScope(injectable.scope, ">", this.scope)) {
 			throw new Error("Invalid scope");
 		}
-		this.instances.set(injectable, {
-			instance,
-			picked: instance,
+		this.instances.set(injectable, [{
+			private: instance,
+			public: instance,
 			context: undefined
-		});
+		}]);
 	}
 	satisfies(injectable) {
 		return compareScope(injectable.scope, "<=", this.scope);
@@ -112,7 +121,7 @@ export class Container {
 		} else if (this.parent?.contains(injectable) || this.parent?.satisfies(injectable) && compareScope(this.parent.scope, "<", this.scope)) {
 			return this.parent.resolveInjectable(injectable, dependant);
 		} else {
-			const { scope, dependencies, stack, label } = injectable;
+			const { stack, label } = injectable;
 			if (dependant) {
 				let dependants = this.dependants.get(injectable);
 				if (!dependants) {
@@ -120,9 +129,10 @@ export class Container {
 				}
 				dependants.add(dependant);
 			}
-			if (this.instances.has(injectable)) {
-				return Promise.resolve(this.instances.get(injectable).picked);
-			} else if (this.resolvers.has(injectable)) {
+			const isTransient = injectable.scope === Scope.Transient;
+			if (!isTransient && this.instances.has(injectable)) {
+				return Promise.resolve(this.instances.get(injectable).at(0).public);
+			} else if (!isTransient && this.resolvers.has(injectable)) {
 				return this.resolvers.get(injectable);
 			} else {
 				const isLazy = isLazyInjectable(injectable);
@@ -131,8 +141,10 @@ export class Container {
 					if (isOptional) return Promise.resolve(undefined);
 					return Promise.reject(new Error(`No instance provided for ${label || "an"} injectable:\n${stack}`));
 				} else {
-					const resolution = this.createResolution(injectable, dependencies, scope);
-					if (scope !== Scope.Transient) {
+					const resolution = this.createResolution(injectable).finally(() => {
+						this.resolvers.delete(injectable);
+					});
+					if (injectable.scope !== Scope.Transient) {
 						this.resolvers.set(injectable, resolution);
 					}
 					return resolution;
@@ -140,48 +152,84 @@ export class Container {
 			}
 		}
 	}
-	async createResolution(injectable, dependencies, scope) {
-		try {
-			if (isFactoryInjectable(injectable)) {
-				const context = await this.createInjectableContext(dependencies, injectable);
-				const instance = await Promise.resolve(injectable.factory(context));
-				const picked = injectable.pick(instance);
-				if (compareScope(this.scope, ">=", scope)) {
-					this.instances.set(injectable, {
-						instance,
-						picked,
-						context
-					});
-				}
-				if (scope !== Scope.Transient) {
-					this.resolvers.delete(injectable);
-				}
-				return picked;
-			} else if (isClassInjectable(injectable)) {
-				const context = await this.createInjectableContext(dependencies, injectable);
-				const instance = new injectable(context);
-				await instance.$onCreate();
-				if (compareScope(this.scope, ">=", scope)) {
-					this.instances.set(injectable, {
-						instance,
-						picked: instance,
-						context: undefined
-					});
+	async createResolution(injectable) {
+		const { dependencies } = injectable;
+		const context = await this.createInjectableContext(dependencies, injectable);
+		const wrapper = {
+			private: null,
+			public: null,
+			context
+		};
+		if (isFactoryInjectable(injectable)) {
+			wrapper.private = await Promise.resolve(injectable.factory(wrapper.context));
+			wrapper.public = injectable.pick(wrapper.private);
+		} else if (isClassInjectable(injectable)) {
+			wrapper.private = new injectable(context);
+			wrapper.public = wrapper.private;
+			await wrapper.private.$onCreate();
+		} else {
+			throw new Error("Invalid injectable type");
+		}
+		let instances = this.instances.get(injectable);
+		if (!instances) {
+			instances = [];
+			this.instances.set(injectable, instances);
+		}
+		instances.push(wrapper);
+		return wrapper.public;
+	}
+	createInjectFunction() {
+		const inject = (injectable, context) => {
+			const dependencies = { ...injectable.dependencies };
+			for (const key in context) {
+				const dep = context[key];
+				if (isInjectable(dep) || isOptionalInjectable(dep)) {
+					dependencies[key] = dep;
+				} else {
+					dependencies[key] = createValueInjectable(dep);
 				}
-				if (scope !== Scope.Transient) {
-					this.resolvers.delete(injectable);
+			}
+			const newInjectable = isClassInjectable(injectable) ? createExtendableClassInjectable(injectable, dependencies, Scope.Transient, 1) : {
+				...injectable,
+				dependencies,
+				scope: Scope.Transient,
+				stack: tryCaptureStackTrace(1)
+			};
+			return this.resolve(newInjectable);
+		};
+		const explicit = async (injectable, context) => {
+			if ("asyncDispose" in Symbol === false) {
+				throw new Error("Symbol.asyncDispose is not supported in this environment");
+			}
+			const instance = await inject(injectable, context);
+			const dispose = this.createDisposeFunction();
+			return Object.assign(instance, { [Symbol.asyncDispose]: async () => {
+				await dispose(injectable, instance);
+			} });
+		};
+		return Object.assign(inject, { explicit });
+	}
+	createDisposeFunction() {
+		return async (injectable, instance) => {
+			if (injectable.scope === Scope.Transient) {
+				assert(instance, "Instance is required for transient injectable disposal");
+				const wrappers = this.instances.get(injectable);
+				if (wrappers) {
+					for (const wrapper of wrappers) {
+						if (wrapper.public === instance) {
+							await this.disposeInjectableInstance(injectable, wrapper.private, wrapper.context);
+							const index = wrappers.indexOf(wrapper);
+							wrappers.splice(index, 1);
+						}
+					}
+					if (wrappers.length === 0) {
+						this.instances.delete(injectable);
+					}
 				}
-				return instance;
 			} else {
-				throw new Error("Invalid injectable type");
-			}
-		} catch (error) {
-			if (scope !== Scope.Transient) {
-				this.resolvers.delete(injectable);
+				await this.disposeInjectableInstances(injectable);
 			}
-			this.instances.delete(injectable);
-			throw error;
-		}
+		};
 	}
 	getDisposalOrder() {
 		const visited = new Set();
@@ -206,17 +254,11 @@ export class Container {
 		}
 		return result;
 	}
-	async disposeInjectable(injectable) {
+	async disposeInjectableInstances(injectable) {
 		try {
-			if (isFactoryInjectable(injectable)) {
-				const { dispose } = injectable;
-				if (dispose) {
-					const { instance, context } = this.instances.get(injectable);
-					await dispose(instance, context);
-				}
-			} else if (isClassInjectable(injectable)) {
-				const { instance } = this.instances.get(injectable);
-				await instance.$onDispose();
+			if (this.instances.has(injectable)) {
+				const wrappers = this.instances.get(injectable);
+				await Promise.all(wrappers.map((wrapper) => this.disposeInjectableInstance(injectable, wrapper.private, wrapper.context)));
 			}
 		} catch (cause) {
 			const error = new Error("Injectable disposal error. Potential memory leak", { cause });
@@ -225,25 +267,14 @@ export class Container {
 			this.instances.delete(injectable);
 		}
 	}
-}
-export function createInjectFunction(container) {
-	return (injectable, context) => {
-		const dependencies = { ...injectable.dependencies };
-		for (const key in context) {
-			const dep = context[key];
-			if (isInjectable(dep) || isOptionalInjectable(dep)) {
-				dependencies[key] = dep;
-			} else {
-				dependencies[key] = createValueInjectable(dep);
-			}
+	async disposeInjectableInstance(injectable, instance, context) {
+		if (isFactoryInjectable(injectable)) {
+			const { dispose } = injectable;
+			if (dispose) await dispose(instance, context);
+		} else if (isClassInjectable(injectable)) {
+			await instance.$onDispose();
 		}
-		const newInjectable = {
-			...injectable,
-			dependencies,
-			scope: Scope.Transient
-		};
-		return container.resolve(newInjectable);
-	};
+	}
 }
 
 //# sourceMappingURL=container.js.map

package/dist/container.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,aAAa,YAAY;AAClC,SAEE,iBACA,cACA,uBAGA,2BACA,mBACA,qBACA,cACA,kBACA,sBACA,yBAEK,kBAAkB;AAIzB,OAAO,MAAM,UAAU;CACrB,AAAS,YAAY,IAAI;CAIzB,AAAiB,YAAY,IAAI;CACjC,AAAiB,cAAc,IAAI;CACnC,AAAiB,aAAa,IAAI;CAClC,AAAQ,YAAY;CAEpB,YACmBA,aAIDC,QAAyC,MAAM,QAC9CC,QACjB;OANiB;OAID;OACC;AAEjB,MAAK,UAAkB,MAAM,WAAW;AACtC,SAAM,IAAI,MAAM;EACjB;AACD,OAAK,QAAQ,gBAAgB,QAAQ,qBAAqB,KAAK,CAAC;CACjE;CAED,MAAM,OAAO;EACX,MAAM,WAAW,CAACC,iBAA+B;AAC/C,QAAK,MAAM,OAAO,cAAc;IAC9B,MAAM,aAAa,aAAa;IAChC,MAAM,aAAa,0BAA0B,WAAW;AACxD,SAAK,YAAY,IAAI,WAAW;AAChC,aAAS,WAAW,aAAa;GAClC;EACF;AAED,OAAK,MAAM,aAAa,KAAK,YAAY,SAAS,eAAe,EAAE;AACjE,YAAS,UAAU,aAAa;EACjC;EAED,MAAM,cAAc,MAAM,KAAK,KAAK,6BAA6B,CAAC;AAClE,QAAM,QAAQ,IAAI,YAAY,IAAI,CAAC,eAAe,KAAK,QAAQ,WAAW,CAAC,CAAC;CAC7E;CAED,KAAKF,OAAwC;AAC3C,SAAO,IAAI,UAAU,KAAK,aAAa,OAAO;CAC/C;CAED,MAAM,UAAU;AACd,OAAK,YAAY,OAAO,MAAM,mCAAmC,KAAK,MAAM;AAG5E,OAAK,YAAY;EAGjB,MAAM,gBAAgB,KAAK,kBAAkB;AAG7C,OAAK,MAAM,cAAc,eAAe;AACtC,SAAM,KAAK,kBAAkB,WAAW;EACzC;AAED,OAAK,UAAU,OAAO;AACtB,OAAK,YAAY,OAAO;AACxB,OAAK,UAAU,OAAO;AACtB,OAAK,WAAW,OAAO;AAEvB,OAAK,YAAY;CAClB;CAED,mBAAmBG,YAA2B;AAC5C,SAAO,KAAK,UAAU,IAAI,WAAW,IAAI,KAAK,UAAU,IAAI,WAAW;CACxE;CAED,SAASA,YAAoC;AAC3C,SACE,KAAK,mBAAmB,WAAW,KAClC,KAAK,QAAQ,SAAS,WAAW,IAAI;CAEzC;CAED,IAA6BC,YAAyC;AACpE,MAAI,KAAK,UAAU,IAAI,WAAW,EAAE;AAClC,UAAO,KAAK,UAAU,IAAI,WAAW,CAAE;EACxC;AAED,MAAI,KAAK,QAAQ,SAAS,WAAW,EAAE;AACrC,UAAO,KAAK,OAAO,IAAI,WAAW;EACnC;AAED,QAAM,IAAI,MAAM;CACjB;CAED,QAAiCA,YAAe;AAC9C,SAAO,KAAK,kBAAkB,WAAW;CAC1C;CAED,MAAM,cAAsCC,cAAiB;AAC3D,SAAO,KAAK,wBAAwB,aAAa;CAClD;CAED,MAAc,wBACZA,cACAC,WACA;EACA,MAAMC,aAAkC,CAAE;EAC1C,MAAM,OAAO,OAAO,QAAQ,aAAa;EACzC,MAAMC,YAA4B,MAAM,KAAK,OAAO;AACpD,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;GACpC,MAAM,CAAC,KAAK,WAAW,GAAG,KAAK;GAC/B,MAAM,aAAa,0BAA0B,WAAW;GACxD,MAAM,WAAW,KAAK,kBAAkB,YAAY,UAAU;AAC9D,aAAU,KAAK,SAAS,KAAK,CAAC,UAAW,WAAW,OAAO,MAAO;EACnE;AACD,QAAM,QAAQ,IAAI,UAAU;AAC5B,SAAO,OAAO,OAAO,WAAW;CACjC;CAED,MAAM,QACJJ,YACAK,UACA;AACA,MAAI,aAAa,WAAW,OAAO,KAAK,KAAK,MAAM,EAAE;AACnD,SAAM,IAAI,MAAM;EACjB;AACD,OAAK,UAAU,IAAI,YAAY;GAC7B;GACA,QAAQ;GACR,SAAS;EACV,EAAC;CACH;CAED,UAAUN,YAA2B;AACnC,SAAO,aAAa,WAAW,OAAO,MAAM,KAAK,MAAM;CACxD;CAED,CAAS,8BAA8B;AACrC,OAAK,MAAM,cAAc,KAAK,aAAa;AACzC,OAAI,WAAW,UAAU,KAAK,OAAO;AACnC,UAAM;GACP;EACF;CACF;CAED,AAAQ,kBACNC,YACAE,WACmC;AACnC,MAAI,KAAK,WAAW;AAClB,SAAM,IAAI,MAAM;EACjB;AAED,MAAI,aAAa,aAAa,UAAU,OAAO,KAAK,WAAW,MAAM,EAAE;AAErE,SAAM,IAAI,MAAM;EACjB;AAED,MAAI,kBAAkB,WAAW,EAAE;AACjC,UAAO,QAAQ,QAAQ,WAAW,MAAM;EACzC,WACC,KAAK,QAAQ,SAAS,WAAW,IAChC,KAAK,QAAQ,UAAU,WAAW,IACjC,aAAa,KAAK,OAAO,OAAO,KAAK,KAAK,MAAM,EAClD;AACA,UAAO,KAAK,OAAO,kBAAkB,YAAY,UAAU;EAC5D,OAAM;GACL,MAAM,EAAE,OAAO,cAAc,OAAO,OAAO,GAAG;AAE9C,OAAI,WAAW;IACb,IAAI,aAAa,KAAK,WAAW,IAAI,WAAW;AAChD,SAAK,YAAY;AACf,UAAK,WAAW,IAAI,YAAa,aAAa,IAAI,MAAO;IAC1D;AACD,eAAW,IAAI,UAAU;GAC1B;AAED,OAAI,KAAK,UAAU,IAAI,WAAW,EAAE;AAClC,WAAO,QAAQ,QAAQ,KAAK,UAAU,IAAI,WAAW,CAAE,OAAO;GAC/D,WAAU,KAAK,UAAU,IAAI,WAAW,EAAE;AACzC,WAAO,KAAK,UAAU,IAAI,WAAW;GACtC,OAAM;IACL,MAAM,SAAS,iBAAiB,WAAW;AAE3C,QAAI,QAAQ;KACV,MAAM,aAAa,qBAAqB,WAAW;AACnD,SAAI,WAAY,QAAO,QAAQ,QAAQ,UAAiB;AACxD,YAAO,QAAQ,OACb,IAAI,OACD,2BAA2B,SAAS,KAAK,gBAAgB,MAAM,GAEnE;IACF,OAAM;KACL,MAAM,aAAa,KAAK,iBACtB,YACA,cACA,MACD;AACD,SAAI,UAAU,MAAM,WAAW;AAC7B,WAAK,UAAU,IAAI,YAAY,WAAW;KAC3C;AACD,YAAO;IACR;GACF;EACF;CACF;CAED,MAAc,iBACZF,YACAF,cACAQ,OACmC;AACnC,MAAI;AACF,OAAI,oBAAoB,WAAW,EAAE;IACnC,MAAM,UAAU,MAAM,KAAK,wBACzB,cACA,WACD;IACD,MAAM,WAAW,MAAM,QAAQ,QAAQ,WAAW,QAAQ,QAAQ,CAAC;IACnE,MAAM,SAAS,WAAW,KAAK,SAAS;AAExC,QAAI,aAAa,KAAK,OAAO,MAAM,MAAM,EAAE;AACzC,UAAK,UAAU,IAAI,YAAY;MAAE;MAAU;MAAQ;KAAS,EAAC;IAC9D;AAED,QAAI,UAAU,MAAM,WAAW;AAC7B,UAAK,UAAU,OAAO,WAAW;IAClC;AAED,WAAO;GACR,WAAU,kBAAkB,WAAW,EAAE;IACxC,MAAM,UAAU,MAAM,KAAK,wBACzB,cACA,WACD;IACD,MAAM,WAAW,IAAI,WAAW;AAChC,UAAM,SAAS,WAAW;AAE1B,QAAI,aAAa,KAAK,OAAO,MAAM,MAAM,EAAE;AACzC,UAAK,UAAU,IAAI,YAAY;MAC7B;MACA,QAAQ;MACR,SAAS;KACV,EAAC;IACH;AAED,QAAI,UAAU,MAAM,WAAW;AAC7B,UAAK,UAAU,OAAO,WAAW;IAClC;AAED,WAAO;GACR,OAAM;AACL,UAAM,IAAI,MAAM;GACjB;EACF,SAAQ,OAAO;AAEd,OAAI,UAAU,MAAM,WAAW;AAC7B,SAAK,UAAU,OAAO,WAAW;GAClC;AACD,QAAK,UAAU,OAAO,WAAW;AACjC,SAAM;EACP;CACF;CAED,AAAQ,mBAAoC;EAC1C,MAAM,UAAU,IAAI;EACpB,MAAMC,SAA0B,CAAE;EAElC,MAAM,QAAQ,CAACR,eAA8B;AAC3C,OAAI,QAAQ,IAAI,WAAW,CAAE;AAC7B,WAAQ,IAAI,WAAW;GAEvB,MAAM,aAAa,KAAK,WAAW,IAAI,WAAW;AAClD,OAAI,YAAY;AACd,SAAK,MAAM,aAAa,YAAY;AAClC,SAAI,KAAK,UAAU,IAAI,UAAU,EAAE;AACjC,YAAM,UAAU;KACjB;IACF;GACF;AAGD,OAAI,KAAK,UAAU,IAAI,WAAW,EAAE;AAClC,WAAO,KAAK,WAAW;GACxB;EACF;AAED,OAAK,MAAM,cAAc,KAAK,UAAU,MAAM,EAAE;AAC9C,SAAM,WAAW;EAClB;AAED,SAAO;CACR;CAED,MAAc,kBAAkBA,YAA2B;AACzD,MAAI;AACF,OAAI,oBAAoB,WAAW,EAAE;IACnC,MAAM,EAAE,SAAS,GAAG;AACpB,QAAI,SAAS;KACX,MAAM,EAAE,UAAU,SAAS,GAAG,KAAK,UAAU,IAAI,WAAW;AAC5D,WAAM,QAAQ,UAAU,QAAQ;IACjC;GACF,WAAU,kBAAkB,WAAW,EAAE;IACxC,MAAM,EAAE,UAAU,GAAG,KAAK,UAAU,IAAI,WAAW;AACnD,UAAM,SAAS,YAAY;GAC5B;EACF,SAAQ,OAAO;GACd,MAAM,QAAQ,IAAI,MAChB,oDACA,EAAE,MAAO;AAEX,QAAK,YAAY,OAAO,MAAM,MAAM;EACrC,UAAS;AACR,QAAK,UAAU,OAAO,WAAW;EAClC;CACF;AACF;AAED,OAAO,SAAS,qBAAqBS,WAAsB;AACzD,QAAO,CACLR,YACAS,YACG;EACH,MAAMX,eAA6B,EACjC,GAAG,WAAW,aACf;AAED,OAAK,MAAM,OAAO,SAAS;GACzB,MAAM,MAAM,QAAQ;AACpB,OAAI,aAAa,IAAI,IAAI,qBAAqB,IAAI,EAAE;AAClD,iBAAa,OAAO;GACrB,OAAM;AACL,iBAAa,OAAO,sBAAsB,IAAI;GAC/C;EACF;EAED,MAAM,gBAAgB;GACpB,GAAG;GACH;GACA,OAAO,MAAM;EACd;AAED,SAAO,UAAU,QAAQ,cAAc;CACxC;AACF","names":["application: {\n      registry: Registry\n      logger: Logger\n    }","scope: Exclude<Scope, Scope.Transient>","parent?: Container","dependencies: Dependencies","injectable: AnyInjectable","injectable: T","dependencies: T","dependant?: AnyInjectable","injections: Record<string, any>","resolvers: Promise<any>[]","instance: ResolveInjectableType<T>","scope: Scope","result: AnyInjectable[]","container: Container","context: InlineInjectionDependencies<T>"],"sources":["../src/container.ts"],"sourcesContent":["import { Scope } from './enums.ts'\nimport {\n  type AnyInjectable,\n  CoreInjectables,\n  compareScope,\n  createValueInjectable,\n  type Dependencies,\n  type DependencyContext,\n  getDepedencencyInjectable,\n  isClassInjectable,\n  isFactoryInjectable,\n  isInjectable,\n  isLazyInjectable,\n  isOptionalInjectable,\n  isValueInjectable,\n  type ResolveInjectableType,\n} from './injectables.ts'\nimport type { Logger } from './logger.ts'\nimport type { Registry } from './registry.ts'\n\nexport class Container {\n  readonly instances = new Map<\n    AnyInjectable,\n    { instance: any; picked?: any; context?: any }\n  >()\n  private readonly resolvers = new Map<AnyInjectable, Promise<any>>()\n  private readonly injectables = new Set<AnyInjectable>()\n  private readonly dependants = new Map<AnyInjectable, Set<AnyInjectable>>()\n  private disposing = false\n\n  constructor(\n    private readonly application: {\n      registry: Registry\n      logger: Logger\n    },\n    public readonly scope: Exclude<Scope, Scope.Transient> = Scope.Global,\n    private readonly parent?: Container,\n  ) {\n    if ((scope as any) === Scope.Transient) {\n      throw new Error('Invalid scope')\n    }\n    this.provide(CoreInjectables.inject, createInjectFunction(this))\n  }\n\n  async load() {\n    const traverse = (dependencies: Dependencies) => {\n      for (const key in dependencies) {\n        const dependency = dependencies[key]\n        const injectable = getDepedencencyInjectable(dependency)\n        this.injectables.add(injectable)\n        traverse(injectable.dependencies)\n      }\n    }\n\n    for (const dependant of this.application.registry.getDependants()) {\n      traverse(dependant.dependencies)\n    }\n\n    const injectables = Array.from(this.findCurrentScopeInjectables())\n    await Promise.all(injectables.map((injectable) => this.resolve(injectable)))\n  }\n\n  fork(scope: Exclude<Scope, Scope.Transient>) {\n    return new Container(this.application, scope, this)\n  }\n\n  async dispose() {\n    this.application.logger.trace('Disposing [%s] scope context...', this.scope)\n\n    // Prevent new resolutions during disposal\n    this.disposing = true\n\n    // Get proper disposal order using topological sort\n    const disposalOrder = this.getDisposalOrder()\n\n    // Dispose in the correct order\n    for (const injectable of disposalOrder) {\n      await this.disposeInjectable(injectable)\n    }\n\n    this.instances.clear()\n    this.injectables.clear()\n    this.resolvers.clear()\n    this.dependants.clear()\n\n    this.disposing = false\n  }\n\n  containsWithinSelf(injectable: AnyInjectable) {\n    return this.instances.has(injectable) || this.resolvers.has(injectable)\n  }\n\n  contains(injectable: AnyInjectable): boolean {\n    return (\n      this.containsWithinSelf(injectable) ||\n      (this.parent?.contains(injectable) ?? false)\n    )\n  }\n\n  get<T extends AnyInjectable>(injectable: T): ResolveInjectableType<T> {\n    if (this.instances.has(injectable)) {\n      return this.instances.get(injectable)!.instance\n    }\n\n    if (this.parent?.contains(injectable)) {\n      return this.parent.get(injectable)\n    }\n\n    throw new Error('No instance found')\n  }\n\n  resolve<T extends AnyInjectable>(injectable: T) {\n    return this.resolveInjectable(injectable)\n  }\n\n  async createContext<T extends Dependencies>(dependencies: T) {\n    return this.createInjectableContext(dependencies)\n  }\n\n  private async createInjectableContext<T extends Dependencies>(\n    dependencies: T,\n    dependant?: AnyInjectable,\n  ) {\n    const injections: Record<string, any> = {}\n    const deps = Object.entries(dependencies)\n    const resolvers: Promise<any>[] = Array(deps.length)\n    for (let i = 0; i < deps.length; i++) {\n      const [key, dependency] = deps[i]\n      const injectable = getDepedencencyInjectable(dependency)\n      const resolver = this.resolveInjectable(injectable, dependant)\n      resolvers[i] = resolver.then((value) => (injections[key] = value))\n    }\n    await Promise.all(resolvers)\n    return Object.freeze(injections) as DependencyContext<T>\n  }\n\n  async provide<T extends AnyInjectable>(\n    injectable: T,\n    instance: ResolveInjectableType<T>,\n  ) {\n    if (compareScope(injectable.scope, '>', this.scope)) {\n      throw new Error('Invalid scope') // TODO: more informative error\n    }\n    this.instances.set(injectable, {\n      instance,\n      picked: instance,\n      context: undefined,\n    })\n  }\n\n  satisfies(injectable: AnyInjectable) {\n    return compareScope(injectable.scope, '<=', this.scope)\n  }\n\n  private *findCurrentScopeInjectables() {\n    for (const injectable of this.injectables) {\n      if (injectable.scope === this.scope) {\n        yield injectable\n      }\n    }\n  }\n\n  private resolveInjectable<T extends AnyInjectable>(\n    injectable: T,\n    dependant?: AnyInjectable,\n  ): Promise<ResolveInjectableType<T>> {\n    if (this.disposing) {\n      throw new Error('Cannot resolve during disposal')\n    }\n\n    if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {\n      // TODO: more informative error\n      throw new Error('Invalid scope: dependant is looser than injectable')\n    }\n\n    if (isValueInjectable(injectable)) {\n      return Promise.resolve(injectable.value)\n    } else if (\n      this.parent?.contains(injectable) ||\n      (this.parent?.satisfies(injectable) &&\n        compareScope(this.parent.scope, '<', this.scope))\n    ) {\n      return this.parent.resolveInjectable(injectable, dependant)\n    } else {\n      const { scope, dependencies, stack, label } = injectable\n\n      if (dependant) {\n        let dependants = this.dependants.get(injectable)\n        if (!dependants) {\n          this.dependants.set(injectable, (dependants = new Set()))\n        }\n        dependants.add(dependant)\n      }\n\n      if (this.instances.has(injectable)) {\n        return Promise.resolve(this.instances.get(injectable)!.picked)\n      } else if (this.resolvers.has(injectable)) {\n        return this.resolvers.get(injectable)!\n      } else {\n        const isLazy = isLazyInjectable(injectable)\n\n        if (isLazy) {\n          const isOptional = isOptionalInjectable(injectable)\n          if (isOptional) return Promise.resolve(undefined as any)\n          return Promise.reject(\n            new Error(\n              `No instance provided for ${label || 'an'} injectable:\\n${stack}`,\n            ),\n          )\n        } else {\n          const resolution = this.createResolution(\n            injectable,\n            dependencies,\n            scope,\n          )\n          if (scope !== Scope.Transient) {\n            this.resolvers.set(injectable, resolution)\n          }\n          return resolution\n        }\n      }\n    }\n  }\n\n  private async createResolution<T extends AnyInjectable>(\n    injectable: T,\n    dependencies: Dependencies,\n    scope: Scope,\n  ): Promise<ResolveInjectableType<T>> {\n    try {\n      if (isFactoryInjectable(injectable)) {\n        const context = await this.createInjectableContext(\n          dependencies,\n          injectable,\n        )\n        const instance = await Promise.resolve(injectable.factory(context))\n        const picked = injectable.pick(instance)\n\n        if (compareScope(this.scope, '>=', scope)) {\n          this.instances.set(injectable, { instance, picked, context })\n        }\n\n        if (scope !== Scope.Transient) {\n          this.resolvers.delete(injectable)\n        }\n\n        return picked\n      } else if (isClassInjectable(injectable)) {\n        const context = await this.createInjectableContext(\n          dependencies,\n          injectable,\n        )\n        const instance = new injectable(context)\n        await instance.$onCreate()\n\n        if (compareScope(this.scope, '>=', scope)) {\n          this.instances.set(injectable, {\n            instance,\n            picked: instance,\n            context: undefined,\n          })\n        }\n\n        if (scope !== Scope.Transient) {\n          this.resolvers.delete(injectable)\n        }\n\n        return instance\n      } else {\n        throw new Error('Invalid injectable type')\n      }\n    } catch (error) {\n      // Clean up on failure to prevent memory leaks\n      if (scope !== Scope.Transient) {\n        this.resolvers.delete(injectable)\n      }\n      this.instances.delete(injectable)\n      throw error\n    }\n  }\n\n  private getDisposalOrder(): AnyInjectable[] {\n    const visited = new Set<AnyInjectable>()\n    const result: AnyInjectable[] = []\n\n    const visit = (injectable: AnyInjectable) => {\n      if (visited.has(injectable)) return\n      visited.add(injectable)\n\n      const dependants = this.dependants.get(injectable)\n      if (dependants) {\n        for (const dependant of dependants) {\n          if (this.instances.has(dependant)) {\n            visit(dependant)\n          }\n        }\n      }\n\n      // Only add to result if this container owns the instance\n      if (this.instances.has(injectable)) {\n        result.push(injectable)\n      }\n    }\n\n    for (const injectable of this.instances.keys()) {\n      visit(injectable)\n    }\n\n    return result\n  }\n\n  private async disposeInjectable(injectable: AnyInjectable) {\n    try {\n      if (isFactoryInjectable(injectable)) {\n        const { dispose } = injectable\n        if (dispose) {\n          const { instance, context } = this.instances.get(injectable)!\n          await dispose(instance, context)\n        }\n      } else if (isClassInjectable(injectable)) {\n        const { instance } = this.instances.get(injectable)!\n        await instance.$onDispose()\n      }\n    } catch (cause) {\n      const error = new Error(\n        'Injectable disposal error. Potential memory leak',\n        { cause },\n      )\n      this.application.logger.error(error)\n    } finally {\n      this.instances.delete(injectable)\n    }\n  }\n}\n\nexport function createInjectFunction(container: Container) {\n  return <T extends AnyInjectable>(\n    injectable: T,\n    context: InlineInjectionDependencies<T>,\n  ) => {\n    const dependencies: Dependencies = {\n      ...injectable.dependencies,\n    }\n\n    for (const key in context) {\n      const dep = context[key]\n      if (isInjectable(dep) || isOptionalInjectable(dep)) {\n        dependencies[key] = dep\n      } else {\n        dependencies[key] = createValueInjectable(dep)\n      }\n    }\n\n    const newInjectable = {\n      ...injectable,\n      dependencies,\n      scope: Scope.Transient,\n    }\n\n    return container.resolve(newInjectable)\n  }\n}\n\ntype InlineInjectionDependencies<T extends AnyInjectable> = {\n  [K in keyof T['dependencies']]?:\n    | ResolveInjectableType<T['dependencies'][K]>\n    | AnyInjectable<ResolveInjectableType<T['dependencies'][K]>>\n}\n\nexport type InjectFn = ReturnType<typeof createInjectFunction>\n"],"version":3,"file":"container.js"}
+{"mappings":"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","names":["application: ContainerOptions","scope: Exclude<Scope, Scope.Transient>","parent?: Container","dependencies: Dependencies","injectable: AnyInjectable","injectable: T","dependencies: T","dependant?: AnyInjectable","injections: Record<string, any>","resolvers: Promise<any>[]","instance: ResolveInjectableType<T>","context: InlineInjectionDependencies<T>","instance?: any","result: AnyInjectable[]","instance: any","context: any"],"sources":["../src/container.ts"],"sourcesContent":["import assert from 'node:assert'\nimport { tryCaptureStackTrace } from '@nmtjs/common'\nimport { Scope } from './enums.ts'\nimport {\n  type AnyInjectable,\n  CoreInjectables,\n  compareScope,\n  createExtendableClassInjectable,\n  createValueInjectable,\n  type Dependencies,\n  type DependencyContext,\n  getDepedencencyInjectable,\n  isClassInjectable,\n  isFactoryInjectable,\n  isInjectable,\n  isLazyInjectable,\n  isOptionalInjectable,\n  isValueInjectable,\n  type ResolveInjectableType,\n} from './injectables.ts'\nimport type { Logger } from './logger.ts'\nimport type { Registry } from './registry.ts'\n\ntype InstanceWrapper = { private: any; public: any; context: any }\n\ntype ContainerOptions = {\n  registry: Registry\n  logger: Logger\n}\n\nexport class Container {\n  readonly instances = new Map<AnyInjectable, InstanceWrapper[]>()\n  private readonly resolvers = new Map<AnyInjectable, Promise<any>>()\n  private readonly injectables = new Set<AnyInjectable>()\n  private readonly dependants = new Map<AnyInjectable, Set<AnyInjectable>>()\n  // private readonly transients = new Map<any, any>()\n  private disposing = false\n\n  constructor(\n    private readonly application: ContainerOptions,\n    public readonly scope: Exclude<Scope, Scope.Transient> = Scope.Global,\n    private readonly parent?: Container,\n  ) {\n    if ((scope as any) === Scope.Transient) {\n      throw new Error('Invalid scope')\n    }\n    this.provide(CoreInjectables.inject, this.createInjectFunction())\n    this.provide(CoreInjectables.dispose, this.createDisposeFunction())\n    this.provide(CoreInjectables.registry, application.registry)\n  }\n\n  async load() {\n    const traverse = (dependencies: Dependencies) => {\n      for (const key in dependencies) {\n        const dependency = dependencies[key]\n        const injectable = getDepedencencyInjectable(dependency)\n        this.injectables.add(injectable)\n        traverse(injectable.dependencies)\n      }\n    }\n\n    for (const dependant of this.application.registry.getDependants()) {\n      traverse(dependant.dependencies)\n    }\n\n    const injectables = Array.from(this.findCurrentScopeInjectables())\n    await Promise.all(injectables.map((injectable) => this.resolve(injectable)))\n  }\n\n  fork(scope: Exclude<Scope, Scope.Transient>) {\n    return new Container(this.application, scope, this)\n  }\n\n  async dispose() {\n    this.application.logger.trace('Disposing [%s] scope context...', this.scope)\n\n    // Prevent new resolutions during disposal\n    this.disposing = true\n\n    // Get proper disposal order using topological sort\n    const disposalOrder = this.getDisposalOrder()\n\n    // Dispose in the correct order\n    for (const injectable of disposalOrder) {\n      if (this.instances.has(injectable)) {\n        await this.disposeInjectableInstances(injectable)\n      }\n    }\n\n    this.instances.clear()\n    this.injectables.clear()\n    this.resolvers.clear()\n    this.dependants.clear()\n\n    this.disposing = false\n  }\n\n  containsWithinSelf(injectable: AnyInjectable) {\n    return this.instances.has(injectable) || this.resolvers.has(injectable)\n  }\n\n  contains(injectable: AnyInjectable): boolean {\n    return (\n      this.containsWithinSelf(injectable) ||\n      (this.parent?.contains(injectable) ?? false)\n    )\n  }\n\n  get<T extends AnyInjectable>(injectable: T): ResolveInjectableType<T> {\n    if (injectable.scope === Scope.Transient) {\n      throw new Error('Cannot get transient injectable directly')\n    }\n\n    if (this.instances.has(injectable)) {\n      return this.instances.get(injectable)!.at(0)!.public\n    }\n\n    if (this.parent?.contains(injectable)) {\n      return this.parent.get(injectable)\n    }\n\n    throw new Error('No instance found')\n  }\n\n  resolve<T extends AnyInjectable>(injectable: T) {\n    return this.resolveInjectable(injectable)\n  }\n\n  async createContext<T extends Dependencies>(dependencies: T) {\n    return this.createInjectableContext(dependencies)\n  }\n\n  private async createInjectableContext<T extends Dependencies>(\n    dependencies: T,\n    dependant?: AnyInjectable,\n  ) {\n    const injections: Record<string, any> = {}\n    const deps = Object.entries(dependencies)\n    const resolvers: Promise<any>[] = Array(deps.length)\n    for (let i = 0; i < deps.length; i++) {\n      const [key, dependency] = deps[i]\n      const injectable = getDepedencencyInjectable(dependency)\n      const resolver = this.resolveInjectable(injectable, dependant)\n      resolvers[i] = resolver.then((value) => (injections[key] = value))\n    }\n    await Promise.all(resolvers)\n    return Object.freeze(injections) as DependencyContext<T>\n  }\n\n  async provide<T extends AnyInjectable>(\n    injectable: T,\n    instance: ResolveInjectableType<T>,\n  ) {\n    if (compareScope(injectable.scope, '>', this.scope)) {\n      throw new Error('Invalid scope') // TODO: more informative error\n    }\n\n    this.instances.set(injectable, [\n      {\n        private: instance,\n        public: instance,\n        context: undefined,\n      },\n    ])\n  }\n\n  satisfies(injectable: AnyInjectable) {\n    return compareScope(injectable.scope, '<=', this.scope)\n  }\n\n  private *findCurrentScopeInjectables() {\n    for (const injectable of this.injectables) {\n      if (injectable.scope === this.scope) {\n        yield injectable\n      }\n    }\n  }\n\n  private resolveInjectable<T extends AnyInjectable>(\n    injectable: T,\n    dependant?: AnyInjectable,\n  ): Promise<ResolveInjectableType<T>> {\n    if (this.disposing) {\n      throw new Error('Cannot resolve during disposal')\n    }\n\n    if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {\n      // TODO: more informative error\n      throw new Error('Invalid scope: dependant is looser than injectable')\n    }\n\n    if (isValueInjectable(injectable)) {\n      return Promise.resolve(injectable.value)\n    } else if (\n      this.parent?.contains(injectable) ||\n      (this.parent?.satisfies(injectable) &&\n        compareScope(this.parent.scope, '<', this.scope))\n    ) {\n      return this.parent.resolveInjectable(injectable, dependant)\n    } else {\n      const { stack, label } = injectable\n\n      if (dependant) {\n        let dependants = this.dependants.get(injectable)\n        if (!dependants) {\n          this.dependants.set(injectable, (dependants = new Set()))\n        }\n        dependants.add(dependant)\n      }\n\n      const isTransient = injectable.scope === Scope.Transient\n\n      if (!isTransient && this.instances.has(injectable)) {\n        return Promise.resolve(this.instances.get(injectable)!.at(0)!.public)\n      } else if (!isTransient && this.resolvers.has(injectable)) {\n        return this.resolvers.get(injectable)!\n      } else {\n        const isLazy = isLazyInjectable(injectable)\n\n        if (isLazy) {\n          const isOptional = isOptionalInjectable(injectable)\n          if (isOptional) return Promise.resolve(undefined as any)\n          return Promise.reject(\n            new Error(\n              `No instance provided for ${label || 'an'} injectable:\\n${stack}`,\n            ),\n          )\n        } else {\n          const resolution = this.createResolution(injectable).finally(() => {\n            this.resolvers.delete(injectable)\n          })\n          if (injectable.scope !== Scope.Transient) {\n            this.resolvers.set(injectable, resolution)\n          }\n          return resolution\n        }\n      }\n    }\n  }\n\n  private async createResolution<T extends AnyInjectable>(\n    injectable: T,\n  ): Promise<ResolveInjectableType<T>> {\n    const { dependencies } = injectable\n    const context = await this.createInjectableContext(dependencies, injectable)\n    const wrapper = {\n      private: null as any,\n      public: null as ResolveInjectableType<T>,\n      context,\n    }\n    if (isFactoryInjectable(injectable)) {\n      wrapper.private = await Promise.resolve(\n        injectable.factory(wrapper.context),\n      )\n      wrapper.public = injectable.pick(wrapper.private)\n    } else if (isClassInjectable(injectable)) {\n      wrapper.private = new injectable(context)\n      wrapper.public = wrapper.private\n      await wrapper.private.$onCreate()\n    } else {\n      throw new Error('Invalid injectable type')\n    }\n\n    let instances = this.instances.get(injectable)\n\n    if (!instances) {\n      instances = []\n      this.instances.set(injectable, instances)\n    }\n    instances.push(wrapper)\n\n    return wrapper.public\n  }\n\n  private createInjectFunction() {\n    const inject = <T extends AnyInjectable>(\n      injectable: T,\n      context: InlineInjectionDependencies<T>,\n    ) => {\n      const dependencies: Dependencies = {\n        ...injectable.dependencies,\n      }\n\n      for (const key in context) {\n        const dep = context[key]\n        if (isInjectable(dep) || isOptionalInjectable(dep)) {\n          dependencies[key] = dep\n        } else {\n          dependencies[key] = createValueInjectable(dep)\n        }\n      }\n\n      const newInjectable = isClassInjectable(injectable)\n        ? createExtendableClassInjectable(\n            injectable,\n            dependencies,\n            Scope.Transient,\n            1,\n          )\n        : {\n            ...injectable,\n            dependencies,\n            scope: Scope.Transient,\n            stack: tryCaptureStackTrace(1),\n          }\n\n      return this.resolve(newInjectable) as Promise<ResolveInjectableType<T>>\n    }\n\n    const explicit = async <T extends AnyInjectable>(\n      injectable: T,\n      context: InlineInjectionDependencies<T>,\n    ) => {\n      if ('asyncDispose' in Symbol === false) {\n        throw new Error(\n          'Symbol.asyncDispose is not supported in this environment',\n        )\n      }\n      const instance = await inject(injectable, context)\n      const dispose = this.createDisposeFunction()\n      return Object.assign(instance, {\n        [Symbol.asyncDispose]: async () => {\n          await dispose(injectable, instance)\n        },\n      })\n    }\n\n    return Object.assign(inject, { explicit })\n  }\n\n  private createDisposeFunction() {\n    return async <T extends AnyInjectable>(injectable: T, instance?: any) => {\n      if (injectable.scope === Scope.Transient) {\n        assert(\n          instance,\n          'Instance is required for transient injectable disposal',\n        )\n        const wrappers = this.instances.get(injectable)\n        if (wrappers) {\n          for (const wrapper of wrappers) {\n            if (wrapper.public === instance) {\n              await this.disposeInjectableInstance(\n                injectable,\n                wrapper.private,\n                wrapper.context,\n              )\n              const index = wrappers.indexOf(wrapper)\n              wrappers.splice(index, 1)\n            }\n          }\n\n          if (wrappers.length === 0) {\n            this.instances.delete(injectable)\n          }\n        }\n      } else {\n        await this.disposeInjectableInstances(injectable)\n      }\n    }\n  }\n\n  private getDisposalOrder(): AnyInjectable[] {\n    const visited = new Set<AnyInjectable>()\n    const result: AnyInjectable[] = []\n\n    const visit = (injectable: AnyInjectable) => {\n      if (visited.has(injectable)) return\n      visited.add(injectable)\n\n      const dependants = this.dependants.get(injectable)\n      if (dependants) {\n        for (const dependant of dependants) {\n          if (this.instances.has(dependant)) {\n            visit(dependant)\n          }\n        }\n      }\n\n      // Only add to result if this container owns the instance\n      if (this.instances.has(injectable)) {\n        result.push(injectable)\n      }\n    }\n\n    for (const injectable of this.instances.keys()) {\n      visit(injectable)\n    }\n\n    return result\n  }\n\n  private async disposeInjectableInstances(injectable: AnyInjectable) {\n    try {\n      if (this.instances.has(injectable)) {\n        const wrappers = this.instances.get(injectable)!\n        await Promise.all(\n          wrappers.map((wrapper) =>\n            this.disposeInjectableInstance(\n              injectable,\n              wrapper.private,\n              wrapper.context,\n            ),\n          ),\n        )\n      }\n    } catch (cause) {\n      const error = new Error(\n        'Injectable disposal error. Potential memory leak',\n        { cause },\n      )\n      this.application.logger.error(error)\n    } finally {\n      this.instances.delete(injectable)\n    }\n  }\n\n  private async disposeInjectableInstance(\n    injectable: AnyInjectable,\n    instance: any,\n    context: any,\n  ) {\n    if (isFactoryInjectable(injectable)) {\n      const { dispose } = injectable\n      if (dispose) await dispose(instance, context)\n    } else if (isClassInjectable(injectable)) {\n      await instance.$onDispose()\n    }\n  }\n}\n\ntype InlineInjectionDependencies<T extends AnyInjectable> = {\n  [K in keyof T['dependencies']]?:\n    | ResolveInjectableType<T['dependencies'][K]>\n    | AnyInjectable<ResolveInjectableType<T['dependencies'][K]>>\n}\n\nexport type InjectFn = ReturnType<Container['createInjectFunction']>\nexport type DisposeFn = ReturnType<Container['createDisposeFunction']>\n"],"version":3,"file":"container.js"}

package/dist/hooks.js.map

@@ -1 +1 @@
-{"mappings":"AACA,SAAS,uBAAuB,gBAAgB;AAsBhD,OAAO,MAAM,MAAM;CACjB,OAAO,MAAMA,MAAaC,IAAW;AACnC,OAAK,MAAM,CAAC,MAAM,UAAU,IAAI,KAAK,kBAAkB;AACrD,QAAK,MAAM,YAAY,WAAW;AAChC,OAAG,IAAI,MAAM,SAAS;GACvB;EACF;CACF;CAED,CAAC,mBAAmB,IAAI;CAExB,IAAIC,MAAcC,UAAoB;EACpC,IAAI,QAAQ,KAAK,iBAAiB,IAAI,KAAK;AAC3C,OAAK,MAAO,MAAK,iBAAiB,IAAI,MAAO,QAAQ,IAAI,MAAO;AAChE,QAAM,IAAI,SAAS;AACnB,SAAO,MAAM,KAAK,OAAO,MAAM,SAAS;CACzC;CAED,OAAOD,MAAcC,UAAoB;EACvC,MAAM,QAAQ,KAAK,iBAAiB,IAAI,KAAK;AAC7C,MAAI,MAAO,OAAM,OAAO,SAAS;CAClC;CAED,MAAM,KACJC,MACAC,SACA,GAAG,MACH;EACA,MAAM,EAAE,aAAa,MAAM,UAAU,OAAO,GAAG,WAAW,CAAE;EAC5D,MAAM,QAAQ,KAAK,iBAAiB,IAAI,KAAK;AAC7C,OAAK,MAAO;EACZ,MAAM,WAAW,MAAM,KAAK,MAAM;AAClC,MAAI,YAAY;AACd,SAAM,QAAQ,IAAI,SAAS,IAAI,CAAC,SAAS,KAAK,GAAG,KAAK,CAAC,CAAC;EACzD,OAAM;AACL,OAAI,QAAS,UAAS,SAAS;AAC/B,QAAK,MAAM,QAAQ,SAAU,OAAM,KAAK,GAAG,KAAK;EACjD;CACF;CAED,QAAQ;AACN,OAAK,iBAAiB,OAAO;CAC9B;AACF;AAED,OAAO,MAAM,mBAAmB,CAACC,UAC9B,gBAAgB,KAAK","names":["from: Hooks","to: Hooks","name: string","callback: Callback","name: T","options: { concurrent?: boolean; reverse?: boolean } | undefined","hook: Hook | (object & string)"],"sources":["../src/hooks.ts"],"sourcesContent":["import type { Callback } from '../../common/src/index.ts'\nimport { kHookCollection } from './constants.ts'\nimport type { Hook } from './enums.ts'\n// import type { HookType } from './types.ts'\n\nexport interface HookType {\n  [key: string]: (...args: any[]) => any\n  // [Hook.AfterInitialize]: () => any\n  // [Hook.BeforeStart]: () => any\n  // [Hook.AfterStart]: () => any\n  // [Hook.BeforeStop]: () => any\n  // [Hook.AfterStop]: () => any\n  // [Hook.BeforeTerminate]: () => any\n  // [Hook.AfterTerminate]: () => any\n  // [Hook.OnConnect]: (...args: any[]) => any\n  // [Hook.OnDisconnect]: (...args: any[]) => any\n}\n\nexport type CallHook<T extends string> = (\n  hook: T,\n  ...args: T extends keyof HookType ? Parameters<HookType[T]> : any[]\n) => Promise<void>\n\nexport class Hooks {\n  static merge(from: Hooks, to: Hooks) {\n    for (const [name, callbacks] of from[kHookCollection]) {\n      for (const callback of callbacks) {\n        to.add(name, callback)\n      }\n    }\n  }\n\n  [kHookCollection] = new Map<string, Set<Callback>>()\n\n  add(name: string, callback: Callback) {\n    let hooks = this[kHookCollection].get(name)\n    if (!hooks) this[kHookCollection].set(name, (hooks = new Set()))\n    hooks.add(callback)\n    return () => this.remove(name, callback)\n  }\n\n  remove(name: string, callback: Callback) {\n    const hooks = this[kHookCollection].get(name)\n    if (hooks) hooks.delete(callback)\n  }\n\n  async call<T extends string | Hook>(\n    name: T,\n    options: { concurrent?: boolean; reverse?: boolean } | undefined,\n    ...args: T extends Hook ? Parameters<HookType[T]> : any[]\n  ) {\n    const { concurrent = true, reverse = false } = options ?? {}\n    const hooks = this[kHookCollection].get(name)\n    if (!hooks) return\n    const hooksArr = Array.from(hooks)\n    if (concurrent) {\n      await Promise.all(hooksArr.map((hook) => hook(...args)))\n    } else {\n      if (reverse) hooksArr.reverse()\n      for (const hook of hooksArr) await hook(...args)\n    }\n  }\n\n  clear() {\n    this[kHookCollection].clear()\n  }\n}\n\nexport const createErrForHook = (hook: Hook | (object & string)) =>\n  `Error during [${hook}] hook`\n"],"version":3,"file":"hooks.js"}
+{"mappings":"AACA,SAAS,uBAAuB,gBAAgB;AAuBhD,OAAO,MAAM,MAAM;CACjB,OAAO,MAAMA,MAAaC,IAAW;AACnC,OAAK,MAAM,CAAC,MAAM,UAAU,IAAI,KAAK,kBAAkB;AACrD,QAAK,MAAM,YAAY,WAAW;AAChC,OAAG,IAAI,MAAM,SAAS;GACvB;EACF;CACF;CAED,CAAC,mBAAmB,IAAI;CAExB,IAAIC,MAAcC,UAAoB;EACpC,IAAI,QAAQ,KAAK,iBAAiB,IAAI,KAAK;AAC3C,OAAK,MAAO,MAAK,iBAAiB,IAAI,MAAO,QAAQ,IAAI,MAAO;AAChE,QAAM,IAAI,SAAS;AACnB,SAAO,MAAM,KAAK,OAAO,MAAM,SAAS;CACzC;CAED,OAAOD,MAAcC,UAAoB;EACvC,MAAM,QAAQ,KAAK,iBAAiB,IAAI,KAAK;AAC7C,MAAI,MAAO,OAAM,OAAO,SAAS;CAClC;CAED,MAAM,KACJC,MACAC,SACA,GAAG,MACH;EACA,MAAM,EAAE,aAAa,MAAM,UAAU,OAAO,GAAG,WAAW,CAAE;EAC5D,MAAM,QAAQ,KAAK,iBAAiB,IAAI,KAAK;AAC7C,OAAK,MAAO;EACZ,MAAM,WAAW,MAAM,KAAK,MAAM;AAClC,MAAI,YAAY;AACd,SAAM,QAAQ,IAAI,SAAS,IAAI,CAAC,SAAS,KAAK,GAAG,KAAK,CAAC,CAAC;EACzD,OAAM;AACL,OAAI,QAAS,UAAS,SAAS;AAC/B,QAAK,MAAM,QAAQ,SAAU,OAAM,KAAK,GAAG,KAAK;EACjD;CACF;CAED,QAAQ;AACN,OAAK,iBAAiB,OAAO;CAC9B;AACF;AAED,OAAO,MAAM,mBAAmB,CAACC,UAC9B,gBAAgB,KAAK","names":["from: Hooks","to: Hooks","name: string","callback: Callback","name: T","options: { concurrent?: boolean; reverse?: boolean } | undefined","hook: Hook | (object & string)"],"sources":["../src/hooks.ts"],"sourcesContent":["import type { Callback } from '../../common/src/index.ts'\nimport { kHookCollection } from './constants.ts'\nimport type { Hook } from './enums.ts'\n\n// import type { HookType } from './types.ts'\n\nexport interface HookType {\n  [key: string]: (...args: any[]) => any\n  // [Hook.AfterInitialize]: () => any\n  // [Hook.BeforeStart]: () => any\n  // [Hook.AfterStart]: () => any\n  // [Hook.BeforeStop]: () => any\n  // [Hook.AfterStop]: () => any\n  // [Hook.BeforeTerminate]: () => any\n  // [Hook.AfterTerminate]: () => any\n  // [Hook.OnConnect]: (...args: any[]) => any\n  // [Hook.OnDisconnect]: (...args: any[]) => any\n}\n\nexport type CallHook<T extends string> = (\n  hook: T,\n  ...args: T extends keyof HookType ? Parameters<HookType[T]> : any[]\n) => Promise<void>\n\nexport class Hooks {\n  static merge(from: Hooks, to: Hooks) {\n    for (const [name, callbacks] of from[kHookCollection]) {\n      for (const callback of callbacks) {\n        to.add(name, callback)\n      }\n    }\n  }\n\n  [kHookCollection] = new Map<string, Set<Callback>>()\n\n  add(name: string, callback: Callback) {\n    let hooks = this[kHookCollection].get(name)\n    if (!hooks) this[kHookCollection].set(name, (hooks = new Set()))\n    hooks.add(callback)\n    return () => this.remove(name, callback)\n  }\n\n  remove(name: string, callback: Callback) {\n    const hooks = this[kHookCollection].get(name)\n    if (hooks) hooks.delete(callback)\n  }\n\n  async call<T extends string | Hook>(\n    name: T,\n    options: { concurrent?: boolean; reverse?: boolean } | undefined,\n    ...args: T extends Hook ? Parameters<HookType[T]> : any[]\n  ) {\n    const { concurrent = true, reverse = false } = options ?? {}\n    const hooks = this[kHookCollection].get(name)\n    if (!hooks) return\n    const hooksArr = Array.from(hooks)\n    if (concurrent) {\n      await Promise.all(hooksArr.map((hook) => hook(...args)))\n    } else {\n      if (reverse) hooksArr.reverse()\n      for (const hook of hooksArr) await hook(...args)\n    }\n  }\n\n  clear() {\n    this[kHookCollection].clear()\n  }\n}\n\nexport const createErrForHook = (hook: Hook | (object & string)) =>\n  `Error during [${hook}] hook`\n"],"version":3,"file":"hooks.js"}

package/dist/injectables.js

@@ -1,11 +1,12 @@
 import { tryCaptureStackTrace } from "@nmtjs/common";
-import { kClassInjectable, kFactoryInjectable, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable } from "./constants.js";
+import { kClassInjectable, kFactoryInjectable, kHookCollection, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable } from "./constants.js";
 import { Scope } from "./enums.js";
+import { Hooks } from "./hooks.js";
 const ScopeStrictness = {
-	[Scope.Global]: 0,
-	[Scope.Connection]: 1,
-	[Scope.Call]: 2,
-	[Scope.Transient]: 3
+	[Scope.Transient]: Number.NaN,
+	[Scope.Global]: 1,
+	[Scope.Connection]: 2,
+	[Scope.Call]: 3
 };
 export const isLazyInjectable = (injectable) => kLazyInjectable in injectable;
 export const isFactoryInjectable = (injectable) => kFactoryInjectable in injectable;
@@ -15,11 +16,12 @@ export const isInjectable = (injectable) => kInjectable in injectable;
 export const isOptionalInjectable = (injectable) => kOptionalDependency in injectable;
 export function getInjectableScope(injectable) {
 	let scope = injectable.scope;
-	const deps = Object.values(injectable.dependencies);
-	for (const dependency of deps) {
+	const deps = injectable.dependencies;
+	for (const key in deps) {
+		const dependency = deps[key];
 		const injectable = getDepedencencyInjectable(dependency);
 		const dependencyScope = getInjectableScope(injectable);
-		if (compareScope(dependencyScope, ">", scope)) {
+		if (dependencyScope !== Scope.Transient && scope !== Scope.Transient && compareScope(dependencyScope, ">", scope)) {
 			scope = dependencyScope;
 		}
 	}
@@ -32,10 +34,10 @@ export function getDepedencencyInjectable(dependency) {
 	return dependency;
 }
 export function createOptionalInjectable(injectable) {
-	return {
+	return Object.freeze({
 		[kOptionalDependency]: true,
 		injectable
-	};
+	});
 }
 export function createLazyInjectable(scope = Scope.Global, label, stackTraceDepth = 0) {
 	return Object.freeze({
@@ -72,15 +74,13 @@ export function createFactoryInjectable(paramsOrFactory, label, stackTraceDepth
 		[kInjectable]: true,
 		[kFactoryInjectable]: true
 	};
-	const actualScope = getInjectableScope(injectable);
-	if (!isFactory && params.scope && ScopeStrictness[actualScope] > ScopeStrictness[params.scope]) throw new Error(`Invalid scope ${params.scope} for factory injectable: dependencies have stricter scope - ${actualScope}`);
-	injectable.scope = actualScope;
+	injectable.scope = resolveInjectableScope(typeof params.scope === "undefined", injectable);
 	return Object.freeze(injectable);
 }
-export const createClassInjectable = (dependencies = {}, scope = Scope.Global, stackTraceDepth = 0) => {
-	const klass = class {
+export const createClassInjectable = (dependencies = {}, scope, stackTraceDepth = 0) => {
+	const InjectableClass = class {
 		static dependencies = dependencies;
-		static scope = scope;
+		static scope = scope ?? Scope.Global;
 		static stack = tryCaptureStackTrace(stackTraceDepth + 2);
 		static [kInjectable] = true;
 		static [kClassInjectable] = true;
@@ -93,18 +93,21 @@ export const createClassInjectable = (dependencies = {}, scope = Scope.Global, s
 		async $onCreate() {}
 		async $onDispose() {}
 	};
-	return klass;
+	InjectableClass.scope = resolveInjectableScope(typeof scope === "undefined", InjectableClass);
+	return InjectableClass;
 };
-export function createExtendableClassInjectable(baseClass, dependencies = {}, scope = Scope.Global, stackTraceDepth = 0) {
+export function createExtendableClassInjectable(baseClass, dependencies = {}, scope, stackTraceDepth = 0) {
 	if (isClassInjectable(baseClass)) {
-		dependencies = Object.assign({}, baseClass.dependencies, dependencies);
-		if (compareScope(scope, "<", baseClass.scope)) {
-			throw new Error("Invalid scope for injectable: base class has stricter scope");
+		if (scope && compareScope(baseClass.scope, ">", scope)) {
+			throw new Error(`Invalid scope ${scope} for an extendable class injectable: base class have stricter scope - ${baseClass.scope}`);
+		} else {
+			scope = scope ?? baseClass.scope;
 		}
+		dependencies = Object.assign({}, baseClass.dependencies, dependencies);
 	}
-	return class extends baseClass {
+	const InjectableClass = class extends baseClass {
 		static dependencies = dependencies;
-		static scope = scope;
+		static scope = scope ?? Scope.Global;
 		static stack = tryCaptureStackTrace(stackTraceDepth);
 		static [kInjectable] = true;
 		static [kClassInjectable] = true;
@@ -128,6 +131,8 @@ export function createExtendableClassInjectable(baseClass, dependencies = {}, sc
 			await super.$onDispose?.();
 		}
 	};
+	InjectableClass.scope = resolveInjectableScope(typeof scope === "undefined", InjectableClass);
+	return InjectableClass;
 }
 export function substitute(injectable, substitution, stackTraceDepth = 0) {
 	const dependencies = { ...injectable.dependencies };
@@ -166,9 +171,45 @@ export function compareScope(left, operator, right) {
 		default: throw new Error("Invalid operator");
 	}
 }
+const logger = createLazyInjectable(Scope.Global, "Logger");
+const registry = createLazyInjectable(Scope.Global, "Registry");
+const inject = createLazyInjectable(Scope.Global, "Inject function");
+const dispose = createLazyInjectable(Scope.Global, "Dispose function");
+const hook = createFactoryInjectable({
+	scope: Scope.Transient,
+	dependencies: { registry },
+	factory: ({ registry }) => {
+		const hooks = new Hooks();
+		const on = (name, callback) => {
+			hooks.add(name, callback);
+			return registry.hooks.add(name, callback);
+		};
+		return {
+			hooks,
+			on
+		};
+	},
+	pick: ({ on }) => on,
+	dispose: ({ hooks }, { registry }) => {
+		for (const [hook, callbacks] of hooks[kHookCollection].entries()) {
+			for (const callback of callbacks) {
+				registry.hooks.remove(hook, callback);
+			}
+		}
+		hooks.clear();
+	}
+});
+function resolveInjectableScope(isDefaultScope, injectable) {
+	const actualScope = getInjectableScope(injectable);
+	if (!isDefaultScope && compareScope(actualScope, ">", injectable.scope)) throw new Error(`Invalid scope ${injectable.scope} for an injectable: dependencies have stricter scope - ${actualScope}`);
+	return actualScope;
+}
 export const CoreInjectables = {
-	logger: createLazyInjectable(Scope.Global, "Logger"),
-	inject: createLazyInjectable(Scope.Global, "Inject function")
+	logger,
+	registry,
+	inject,
+	dispose,
+	hook
 };
 
 //# sourceMappingURL=injectables.js.map

package/dist/injectables.js.map

@@ -1 +1 @@
-{"mappings":"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","names":["injectable: any","injectable: AnyInjectable","dependency: Depedency","injectable: T","label?: string","value: T","paramsOrFactory:\n    | {\n        dependencies?: D\n        scope?: S\n        pick?: InjectablePickType<P, T>\n        factory: InjectableFactoryType<P, D>\n        dispose?: InjectableDisposeType<P, D>\n      }\n    | InjectableFactoryType<P, D>","instance: P","dependencies: D","scope: S","$context: DependencyContext<D>","baseClass: B","substitution: DependenciesSubstitution<T['dependencies']>","left: Scope","operator: '>' | '<' | '>=' | '<=' | '=' | '!='","right: Scope"],"sources":["../src/injectables.ts"],"sourcesContent":["import {\n  type Async,\n  type ClassConstructor,\n  type ClassConstructorArgs,\n  type ClassInstance,\n  tryCaptureStackTrace,\n} from '@nmtjs/common'\nimport {\n  kClassInjectable,\n  kFactoryInjectable,\n  kInjectable,\n  kLazyInjectable,\n  kOptionalDependency,\n  kValueInjectable,\n} from './constants.ts'\nimport type { InjectFn } from './container.ts'\nimport { Scope } from './enums.ts'\nimport type { Logger } from './logger.ts'\n\nconst ScopeStrictness = {\n  [Scope.Global]: 0,\n  [Scope.Connection]: 1,\n  [Scope.Call]: 2,\n  [Scope.Transient]: 3,\n}\n\nexport type DependencyOptional<T extends AnyInjectable = AnyInjectable> = {\n  [kOptionalDependency]: any\n  injectable: T\n}\n\nexport type Depedency = DependencyOptional | AnyInjectable\n\nexport type Dependencies = Record<string, Depedency>\n\nexport type ResolveInjectableType<T extends AnyInjectable> =\n  T extends Injectable<infer Type, any, any> ? Type : never\n\nexport interface Dependant<Deps extends Dependencies = Dependencies> {\n  dependencies: Deps\n  label?: string\n  stack?: string\n}\n\nexport type DependencyInjectable<T extends Depedency> = T extends AnyInjectable\n  ? T\n  : T extends DependencyOptional\n    ? T['injectable']\n    : never\n\nexport type DependencyContext<Deps extends Dependencies> = {\n  readonly [K in keyof Deps as Deps[K] extends AnyInjectable\n    ? K\n    : never]: Deps[K] extends AnyInjectable\n    ? ResolveInjectableType<Deps[K]>\n    : never\n} & {\n  readonly [K in keyof Deps as Deps[K] extends DependencyOptional\n    ? K\n    : never]?: Deps[K] extends DependencyOptional\n    ? ResolveInjectableType<Deps[K]['injectable']>\n    : never\n}\n\nexport type InjectableFactoryType<\n  InjectableType,\n  InjectableDeps extends Dependencies,\n> = (context: DependencyContext<InjectableDeps>) => Async<InjectableType>\n\nexport type InjectablePickType<Input, Output> = (injectable: Input) => Output\n\nexport type InjectableDisposeType<\n  InjectableType,\n  InjectableDeps extends Dependencies,\n> = (\n  instance: InjectableType,\n  context: DependencyContext<InjectableDeps>,\n) => any\n\nexport interface LazyInjectable<T, S extends Scope = Scope.Global>\n  extends Dependant<{}> {\n  scope: S\n  [kInjectable]: any\n  [kLazyInjectable]: T\n}\n\nexport interface ValueInjectable<T> extends Dependant<{}> {\n  scope: Scope.Global\n  value: T\n  [kInjectable]: any\n  [kValueInjectable]: any\n}\n\nexport interface FactoryInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  P = T,\n> extends Dependant<D> {\n  scope: S\n  factory: InjectableFactoryType<P, D>\n  pick: InjectablePickType<P, T>\n  dispose?: InjectableDisposeType<P, D>\n  [kInjectable]: any\n  [kFactoryInjectable]: any\n}\n\nexport interface BaseClassInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n> extends Dependant<D> {\n  new (...args: any[]): T\n  scope: S\n  [kInjectable]: any\n  [kClassInjectable]: any\n}\n\nexport interface ClassInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  A extends any[] = [],\n> extends Dependant<D> {\n  new (\n    $context: DependencyContext<D>,\n    ...args: A\n  ): T & {\n    $context: DependencyContext<D>\n  }\n  scope: S\n  [kInjectable]: any\n  [kClassInjectable]: any\n}\n\nexport type Injectable<\n  V = any,\n  D extends Dependencies = {},\n  S extends Scope = Scope,\n> =\n  | LazyInjectable<V, S>\n  | ValueInjectable<V>\n  | FactoryInjectable<V, D, S, any>\n  | BaseClassInjectable<V, D, S>\n\nexport type AnyInjectable<T = any, S extends Scope = Scope> = Injectable<\n  T,\n  any,\n  S\n>\n\nexport const isLazyInjectable = (\n  injectable: any,\n): injectable is LazyInjectable<any> => kLazyInjectable in injectable\nexport const isFactoryInjectable = (\n  injectable: any,\n): injectable is FactoryInjectable<any> => kFactoryInjectable in injectable\nexport const isClassInjectable = (\n  injectable: any,\n): injectable is ClassInjectable<any> => kClassInjectable in injectable\nexport const isValueInjectable = (\n  injectable: any,\n): injectable is ValueInjectable<any> => kValueInjectable in injectable\nexport const isInjectable = (\n  injectable: any,\n): injectable is AnyInjectable<any> => kInjectable in injectable\nexport const isOptionalInjectable = (\n  injectable: any,\n): injectable is DependencyOptional<any> => kOptionalDependency in injectable\n\nexport function getInjectableScope(injectable: AnyInjectable) {\n  let scope = injectable.scope\n  const deps = Object.values(injectable.dependencies as Dependencies)\n  for (const dependency of deps) {\n    const injectable = getDepedencencyInjectable(dependency)\n    const dependencyScope = getInjectableScope(injectable)\n    if (compareScope(dependencyScope, '>', scope)) {\n      scope = dependencyScope\n    }\n  }\n  return scope\n}\n\nexport function getDepedencencyInjectable(\n  dependency: Depedency,\n): AnyInjectable {\n  if (kOptionalDependency in dependency) {\n    return dependency.injectable\n  }\n  return dependency\n}\n\nexport function createOptionalInjectable<T extends AnyInjectable>(\n  injectable: T,\n) {\n  return {\n    [kOptionalDependency]: true,\n    injectable,\n  } as DependencyOptional<T>\n}\n\nexport function createLazyInjectable<T, S extends Scope = Scope.Global>(\n  scope = Scope.Global as S,\n  label?: string,\n  stackTraceDepth = 0,\n): LazyInjectable<T, S> {\n  return Object.freeze({\n    scope,\n    dependencies: {},\n    label,\n    stack: tryCaptureStackTrace(stackTraceDepth),\n    [kInjectable]: true,\n    [kLazyInjectable]: true as unknown as T,\n  })\n}\n\nexport function createValueInjectable<T>(\n  value: T,\n  label?: string,\n  stackTraceDepth = 0,\n): ValueInjectable<T> {\n  return Object.freeze({\n    value,\n    scope: Scope.Global,\n    dependencies: {},\n    label,\n    stack: tryCaptureStackTrace(stackTraceDepth),\n    [kInjectable]: true,\n    [kValueInjectable]: true,\n  })\n}\n\nexport function createFactoryInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  P = T,\n>(\n  paramsOrFactory:\n    | {\n        dependencies?: D\n        scope?: S\n        pick?: InjectablePickType<P, T>\n        factory: InjectableFactoryType<P, D>\n        dispose?: InjectableDisposeType<P, D>\n      }\n    | InjectableFactoryType<P, D>,\n  label?: string,\n  stackTraceDepth = 0,\n): FactoryInjectable<null extends T ? P : T, D, S, P> {\n  const isFactory = typeof paramsOrFactory === 'function'\n  const params = isFactory ? { factory: paramsOrFactory } : paramsOrFactory\n  const injectable = {\n    dependencies: (params.dependencies ?? {}) as D,\n    scope: (params.scope ?? Scope.Global) as S,\n    factory: params.factory,\n    dispose: params.dispose,\n    pick: params.pick ?? ((instance: P) => instance as unknown as T),\n    label,\n    stack: tryCaptureStackTrace(stackTraceDepth),\n    [kInjectable]: true,\n    [kFactoryInjectable]: true,\n  }\n  const actualScope = getInjectableScope(injectable)\n  if (\n    !isFactory &&\n    params.scope &&\n    ScopeStrictness[actualScope] > ScopeStrictness[params.scope]\n  )\n    throw new Error(\n      `Invalid scope ${params.scope} for factory injectable: dependencies have stricter scope - ${actualScope}`,\n    )\n  injectable.scope = actualScope as unknown as S\n  return Object.freeze(injectable) as any\n}\n\nexport const createClassInjectable = <\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n>(\n  dependencies: D = {} as D,\n  scope: S = Scope.Global as S,\n  stackTraceDepth = 0,\n): ClassInjectable<ClassInstance<typeof klass>, D, S> => {\n  const klass = class {\n    static dependencies = dependencies\n    static scope = scope\n    static stack = tryCaptureStackTrace(stackTraceDepth + 2)\n    static [kInjectable] = true\n    static [kClassInjectable] = true\n\n    static get label() {\n      // biome-ignore lint/complexity/noThisInStatic: ok\n      return this.name\n    }\n\n    constructor(public $context: DependencyContext<D>) {}\n\n    protected async $onCreate() {}\n    protected async $onDispose() {}\n  }\n  return klass\n}\n\nexport function createExtendableClassInjectable<\n  B extends ClassConstructor<any>,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n>(\n  baseClass: B,\n  dependencies: D = {} as D,\n  scope: S = Scope.Global as S,\n  stackTraceDepth = 0,\n): B extends ClassInjectable<any>\n  ? ClassInjectable<ClassInstance<B>, D, S>\n  : ClassInjectable<ClassInstance<B>, D, S, ClassConstructorArgs<B, []>> {\n  if (isClassInjectable(baseClass)) {\n    dependencies = Object.assign({}, baseClass.dependencies, dependencies)\n    if (compareScope(scope, '<', baseClass.scope)) {\n      throw new Error(\n        'Invalid scope for injectable: base class has stricter scope',\n      )\n    }\n  }\n  // @ts-expect-error\n  return class extends baseClass {\n    static dependencies = dependencies\n    static scope = scope\n    static stack = tryCaptureStackTrace(stackTraceDepth)\n    static [kInjectable] = true\n    static [kClassInjectable] = true\n\n    static get label() {\n      // biome-ignore lint/complexity/noThisInStatic: ok\n      return this.name\n    }\n\n    $context!: DependencyContext<D>\n\n    constructor(...args: any[]) {\n      const [$context, ...baseClassArgs] = args\n      if (isClassInjectable(baseClass)) {\n        super($context)\n      } else {\n        super(...baseClassArgs)\n      }\n      this.$context = $context\n    }\n\n    protected async $onCreate() {\n      await super.$onCreate?.()\n    }\n\n    protected async $onDispose() {\n      await super.$onDispose?.()\n    }\n  }\n}\n\nexport type DependenciesSubstitution<T extends Dependencies> = {\n  [K in keyof T]?: T[K] extends AnyInjectable<infer Type>\n    ? AnyInjectable<Type> | DependenciesSubstitution<T[K]['dependencies']>\n    : never\n}\n\nexport function substitute<\n  T extends\n    | FactoryInjectable<any, any, Scope>\n    | BaseClassInjectable<any, any, Scope>,\n>(\n  injectable: T,\n  substitution: DependenciesSubstitution<T['dependencies']>,\n  stackTraceDepth = 0,\n): T {\n  const dependencies = { ...injectable.dependencies }\n  const depth = stackTraceDepth + 1\n  for (const key in substitution) {\n    const value = substitution[key]!\n    if (key in dependencies) {\n      const original = dependencies[key]\n      if (isInjectable(value)) {\n        dependencies[key] = value\n      } else if (isClassInjectable(original) || isFactoryInjectable(original)) {\n        dependencies[key] = substitute(original, value, depth)\n      }\n    }\n  }\n\n  if (isClassInjectable(injectable)) {\n    // @ts-expect-error\n    return createExtendableClassInjectable(\n      injectable,\n      dependencies,\n      injectable.scope,\n      depth,\n    )\n  } else if (isFactoryInjectable(injectable)) {\n    // @ts-expect-error\n    return createFactoryInjectable(\n      {\n        ...injectable,\n        dependencies,\n      },\n      injectable.label,\n      depth,\n    )\n  }\n\n  throw new Error('Invalid injectable type')\n}\n\nexport function compareScope(\n  left: Scope,\n  operator: '>' | '<' | '>=' | '<=' | '=' | '!=',\n  right: Scope,\n) {\n  const leftScope = ScopeStrictness[left]\n  const rightScope = ScopeStrictness[right]\n  switch (operator) {\n    case '=':\n      return leftScope === rightScope\n    case '!=':\n      return leftScope !== rightScope\n    case '>':\n      return leftScope > rightScope\n    case '<':\n      return leftScope < rightScope\n    case '>=':\n      return leftScope >= rightScope\n    case '<=':\n      return leftScope <= rightScope\n    default:\n      throw new Error('Invalid operator')\n  }\n}\n\nexport const CoreInjectables = {\n  logger: createLazyInjectable<Logger>(Scope.Global, 'Logger'),\n  inject: createLazyInjectable<InjectFn>(Scope.Global, 'Inject function'),\n}\n"],"version":3,"file":"injectables.js"}
+{"mappings":"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","names":["injectable: any","injectable: AnyInjectable","dependency: Depedency","injectable: T","label?: string","value: T","paramsOrFactory:\n    | {\n        dependencies?: D\n        scope?: S\n        pick?: InjectablePickType<P, T>\n        factory: InjectableFactoryType<P, D>\n        dispose?: InjectableDisposeType<P, D>\n      }\n    | InjectableFactoryType<P, D>","instance: P","dependencies: D","scope?: S","$context: DependencyContext<D>","baseClass: B","substitution: DependenciesSubstitution<T['dependencies']>","left: Scope","operator: '>' | '<' | '>=' | '<=' | '=' | '!='","right: Scope","name: T","callback: HookType[T]","isDefaultScope: boolean"],"sources":["../src/injectables.ts"],"sourcesContent":["import {\n  type Async,\n  type Callback,\n  type ClassConstructor,\n  type ClassConstructorArgs,\n  type ClassInstance,\n  tryCaptureStackTrace,\n} from '@nmtjs/common'\nimport {\n  kClassInjectable,\n  kFactoryInjectable,\n  kHookCollection,\n  kInjectable,\n  kLazyInjectable,\n  kOptionalDependency,\n  kValueInjectable,\n} from './constants.ts'\nimport type { DisposeFn, InjectFn } from './container.ts'\nimport { type Hook, Scope } from './enums.ts'\nimport { Hooks, type HookType } from './hooks.ts'\nimport type { Logger } from './logger.ts'\nimport type { Registry } from './registry.ts'\n\nconst ScopeStrictness = {\n  [Scope.Transient]: Number.NaN, // this should make it always fail to compare with other scopes\n  [Scope.Global]: 1,\n  [Scope.Connection]: 2,\n  [Scope.Call]: 3,\n}\n\nexport type DependencyOptional<T extends AnyInjectable = AnyInjectable> = {\n  [kOptionalDependency]: any\n  injectable: T\n}\n\nexport type Depedency = DependencyOptional | AnyInjectable\n\nexport type Dependencies = Record<string, Depedency>\n\nexport type ResolveInjectableType<T extends AnyInjectable> =\n  T extends Injectable<infer Type, any, any> ? Type : never\n\nexport interface Dependant<Deps extends Dependencies = Dependencies> {\n  dependencies: Deps\n  label?: string\n  stack?: string\n}\n\nexport type DependencyInjectable<T extends Depedency> = T extends AnyInjectable\n  ? T\n  : T extends DependencyOptional\n    ? T['injectable']\n    : never\n\nexport type DependencyContext<Deps extends Dependencies> = {\n  readonly [K in keyof Deps as Deps[K] extends AnyInjectable\n    ? K\n    : never]: Deps[K] extends AnyInjectable\n    ? ResolveInjectableType<Deps[K]>\n    : never\n} & {\n  readonly [K in keyof Deps as Deps[K] extends DependencyOptional\n    ? K\n    : never]?: Deps[K] extends DependencyOptional\n    ? ResolveInjectableType<Deps[K]['injectable']>\n    : never\n}\n\nexport type InjectableFactoryType<\n  InjectableType,\n  InjectableDeps extends Dependencies,\n> = (context: DependencyContext<InjectableDeps>) => Async<InjectableType>\n\nexport type InjectablePickType<Input, Output> = (injectable: Input) => Output\n\nexport type InjectableDisposeType<\n  InjectableType,\n  InjectableDeps extends Dependencies,\n> = (\n  instance: InjectableType,\n  context: DependencyContext<InjectableDeps>,\n) => any\n\nexport interface LazyInjectable<T, S extends Scope = Scope.Global>\n  extends Dependant<{}> {\n  scope: S\n  [kInjectable]: any\n  [kLazyInjectable]: T\n}\n\nexport interface ValueInjectable<T> extends Dependant<{}> {\n  scope: Scope.Global\n  value: T\n  [kInjectable]: any\n  [kValueInjectable]: any\n}\n\nexport interface FactoryInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  P = T,\n> extends Dependant<D> {\n  scope: S\n  factory: InjectableFactoryType<P, D>\n  pick: InjectablePickType<P, T>\n  dispose?: InjectableDisposeType<P, D>\n  [kInjectable]: any\n  [kFactoryInjectable]: any\n}\n\nexport interface BaseClassInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n> extends Dependant<D> {\n  new (...args: any[]): T\n  scope: S\n  [kInjectable]: any\n  [kClassInjectable]: any\n}\n\nexport interface ClassInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  A extends any[] = [],\n> extends Dependant<D> {\n  new (\n    $context: DependencyContext<D>,\n    ...args: A\n  ): T & {\n    $context: DependencyContext<D>\n  }\n  scope: S\n  [kInjectable]: any\n  [kClassInjectable]: any\n}\n\nexport type Injectable<\n  V = any,\n  D extends Dependencies = {},\n  S extends Scope = Scope,\n> =\n  | LazyInjectable<V, S>\n  | ValueInjectable<V>\n  | FactoryInjectable<V, D, S, any>\n  | BaseClassInjectable<V, D, S>\n\nexport type AnyInjectable<T = any, S extends Scope = Scope> = Injectable<\n  T,\n  any,\n  S\n>\n\nexport const isLazyInjectable = (\n  injectable: any,\n): injectable is LazyInjectable<any> => kLazyInjectable in injectable\n\nexport const isFactoryInjectable = (\n  injectable: any,\n): injectable is FactoryInjectable<any> => kFactoryInjectable in injectable\n\nexport const isClassInjectable = (\n  injectable: any,\n): injectable is ClassInjectable<any> => kClassInjectable in injectable\n\nexport const isValueInjectable = (\n  injectable: any,\n): injectable is ValueInjectable<any> => kValueInjectable in injectable\n\nexport const isInjectable = (\n  injectable: any,\n): injectable is AnyInjectable<any> => kInjectable in injectable\n\nexport const isOptionalInjectable = (\n  injectable: any,\n): injectable is DependencyOptional<any> => kOptionalDependency in injectable\n\nexport function getInjectableScope(injectable: AnyInjectable) {\n  let scope = injectable.scope\n  const deps = injectable.dependencies as Dependencies\n  for (const key in deps) {\n    const dependency = deps[key]\n    const injectable = getDepedencencyInjectable(dependency)\n    const dependencyScope = getInjectableScope(injectable)\n    if (\n      dependencyScope !== Scope.Transient &&\n      scope !== Scope.Transient &&\n      compareScope(dependencyScope, '>', scope)\n    ) {\n      scope = dependencyScope\n    }\n  }\n  return scope\n}\n\nexport function getDepedencencyInjectable(\n  dependency: Depedency,\n): AnyInjectable {\n  if (kOptionalDependency in dependency) {\n    return dependency.injectable\n  }\n  return dependency\n}\n\nexport function createOptionalInjectable<T extends AnyInjectable>(\n  injectable: T,\n) {\n  return Object.freeze({\n    [kOptionalDependency]: true,\n    injectable,\n  }) as DependencyOptional<T>\n}\n\nexport function createLazyInjectable<T, S extends Scope = Scope.Global>(\n  scope = Scope.Global as S,\n  label?: string,\n  stackTraceDepth = 0,\n): LazyInjectable<T, S> {\n  return Object.freeze({\n    scope,\n    dependencies: {},\n    label,\n    stack: tryCaptureStackTrace(stackTraceDepth),\n    [kInjectable]: true,\n    [kLazyInjectable]: true as unknown as T,\n  })\n}\n\nexport function createValueInjectable<T>(\n  value: T,\n  label?: string,\n  stackTraceDepth = 0,\n): ValueInjectable<T> {\n  return Object.freeze({\n    value,\n    scope: Scope.Global,\n    dependencies: {},\n    label,\n    stack: tryCaptureStackTrace(stackTraceDepth),\n    [kInjectable]: true,\n    [kValueInjectable]: true,\n  })\n}\n\nexport function createFactoryInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  P = T,\n>(\n  paramsOrFactory:\n    | {\n        dependencies?: D\n        scope?: S\n        pick?: InjectablePickType<P, T>\n        factory: InjectableFactoryType<P, D>\n        dispose?: InjectableDisposeType<P, D>\n      }\n    | InjectableFactoryType<P, D>,\n  label?: string,\n  stackTraceDepth = 0,\n): FactoryInjectable<null extends T ? P : T, D, S, P> {\n  const isFactory = typeof paramsOrFactory === 'function'\n  const params = isFactory ? { factory: paramsOrFactory } : paramsOrFactory\n  const injectable = {\n    dependencies: (params.dependencies ?? {}) as D,\n    scope: (params.scope ?? Scope.Global) as S,\n    factory: params.factory,\n    dispose: params.dispose,\n    pick: params.pick ?? ((instance: P) => instance as unknown as T),\n    label,\n    stack: tryCaptureStackTrace(stackTraceDepth),\n    [kInjectable]: true,\n    [kFactoryInjectable]: true,\n  }\n  injectable.scope = resolveInjectableScope(\n    typeof params.scope === 'undefined',\n    injectable,\n  ) as S\n  return Object.freeze(injectable) as any\n}\n\nexport const createClassInjectable = <\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n>(\n  dependencies: D = {} as D,\n  scope?: S,\n  stackTraceDepth = 0,\n): ClassInjectable<ClassInstance<typeof InjectableClass>, D, S> => {\n  const InjectableClass = class {\n    static dependencies = dependencies\n    static scope = (scope ?? Scope.Global) as S\n    static stack = tryCaptureStackTrace(stackTraceDepth + 2)\n    static [kInjectable] = true\n    static [kClassInjectable] = true\n\n    static get label() {\n      // biome-ignore lint/complexity/noThisInStatic: ok\n      return this.name\n    }\n\n    constructor(public $context: DependencyContext<D>) {}\n\n    protected async $onCreate() {}\n    protected async $onDispose() {}\n  }\n\n  InjectableClass.scope = resolveInjectableScope(\n    typeof scope === 'undefined',\n    InjectableClass,\n  ) as S\n\n  return InjectableClass\n}\n\nexport function createExtendableClassInjectable<\n  B extends ClassConstructor<any>,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n>(\n  baseClass: B,\n  dependencies: D = {} as D,\n  scope?: S,\n  stackTraceDepth = 0,\n): B extends ClassInjectable<any>\n  ? ClassInjectable<ClassInstance<B>, D, S>\n  : ClassInjectable<ClassInstance<B>, D, S, ClassConstructorArgs<B, []>> {\n  if (isClassInjectable(baseClass)) {\n    if (scope && compareScope(baseClass.scope, '>', scope)) {\n      throw new Error(\n        `Invalid scope ${scope} for an extendable class injectable: base class have stricter scope - ${baseClass.scope}`,\n      )\n    } else {\n      scope = scope ?? (baseClass.scope as S)\n    }\n    dependencies = Object.assign({}, baseClass.dependencies, dependencies)\n  }\n\n  const InjectableClass = class extends baseClass {\n    static dependencies = dependencies\n    static scope = (scope ?? Scope.Global) as S\n    static stack = tryCaptureStackTrace(stackTraceDepth)\n    static [kInjectable] = true\n    static [kClassInjectable] = true\n\n    static get label() {\n      // biome-ignore lint/complexity/noThisInStatic: ok\n      return this.name\n    }\n\n    $context!: DependencyContext<D>\n\n    constructor(...args: any[]) {\n      const [$context, ...baseClassArgs] = args\n      if (isClassInjectable(baseClass)) {\n        super($context)\n      } else {\n        super(...baseClassArgs)\n      }\n      this.$context = $context\n    }\n\n    protected async $onCreate() {\n      await super.$onCreate?.()\n    }\n\n    protected async $onDispose() {\n      await super.$onDispose?.()\n    }\n  }\n\n  InjectableClass.scope = resolveInjectableScope(\n    typeof scope === 'undefined',\n    InjectableClass,\n  ) as S\n\n  // @ts-expect-error\n  return InjectableClass\n}\n\nexport type DependenciesSubstitution<T extends Dependencies> = {\n  [K in keyof T]?: T[K] extends AnyInjectable<infer Type>\n    ? AnyInjectable<Type> | DependenciesSubstitution<T[K]['dependencies']>\n    : never\n}\n\nexport function substitute<\n  T extends\n    | FactoryInjectable<any, any, Scope>\n    | BaseClassInjectable<any, any, Scope>,\n>(\n  injectable: T,\n  substitution: DependenciesSubstitution<T['dependencies']>,\n  stackTraceDepth = 0,\n): T {\n  const dependencies = { ...injectable.dependencies }\n  const depth = stackTraceDepth + 1\n  for (const key in substitution) {\n    const value = substitution[key]!\n    if (key in dependencies) {\n      const original = dependencies[key]\n      if (isInjectable(value)) {\n        dependencies[key] = value\n      } else if (isClassInjectable(original) || isFactoryInjectable(original)) {\n        dependencies[key] = substitute(original, value, depth)\n      }\n    }\n  }\n\n  if (isClassInjectable(injectable)) {\n    // @ts-expect-error\n    return createExtendableClassInjectable(\n      injectable,\n      dependencies,\n      injectable.scope,\n      depth,\n    )\n  } else if (isFactoryInjectable(injectable)) {\n    // @ts-expect-error\n    return createFactoryInjectable(\n      {\n        ...injectable,\n        dependencies,\n      },\n      injectable.label,\n      depth,\n    )\n  }\n\n  throw new Error('Invalid injectable type')\n}\n\nexport function compareScope(\n  left: Scope,\n  operator: '>' | '<' | '>=' | '<=' | '=' | '!=',\n  right: Scope,\n) {\n  const leftScope = ScopeStrictness[left]\n  const rightScope = ScopeStrictness[right]\n  switch (operator) {\n    case '=':\n      return leftScope === rightScope\n    case '!=':\n      return leftScope !== rightScope\n    case '>':\n      return leftScope > rightScope\n    case '<':\n      return leftScope < rightScope\n    case '>=':\n      return leftScope >= rightScope\n    case '<=':\n      return leftScope <= rightScope\n    default:\n      throw new Error('Invalid operator')\n  }\n}\n\nconst logger = createLazyInjectable<Logger>(Scope.Global, 'Logger')\nconst registry = createLazyInjectable<Registry>(Scope.Global, 'Registry')\nconst inject = createLazyInjectable<InjectFn>(Scope.Global, 'Inject function')\nconst dispose = createLazyInjectable<DisposeFn>(\n  Scope.Global,\n  'Dispose function',\n)\nconst hook = createFactoryInjectable({\n  scope: Scope.Transient,\n  dependencies: { registry },\n  factory: ({ registry }) => {\n    const hooks = new Hooks()\n    const on = <T extends Hook>(name: T, callback: HookType[T]) => {\n      hooks.add(name, callback as Callback)\n      return registry.hooks.add(name, callback)\n    }\n    return { hooks, on }\n  },\n  pick: ({ on }) => on,\n  dispose: ({ hooks }, { registry }) => {\n    for (const [hook, callbacks] of hooks[kHookCollection].entries()) {\n      for (const callback of callbacks) {\n        registry.hooks.remove(hook, callback)\n      }\n    }\n    hooks.clear()\n  },\n})\n\nfunction resolveInjectableScope(\n  isDefaultScope: boolean,\n  injectable: AnyInjectable,\n) {\n  const actualScope = getInjectableScope(injectable)\n  if (!isDefaultScope && compareScope(actualScope, '>', injectable.scope))\n    throw new Error(\n      `Invalid scope ${injectable.scope} for an injectable: dependencies have stricter scope - ${actualScope}`,\n    )\n  return actualScope\n}\n\nexport const CoreInjectables = {\n  logger,\n  registry,\n  inject,\n  dispose,\n  hook,\n}\n"],"version":3,"file":"injectables.js"}

package/package.json

@@ -10,15 +10,15 @@
   "peerDependencies": {
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.11.2",
-    "@nmtjs/type": "0.11.2"
+    "@nmtjs/common": "0.11.4",
+    "@nmtjs/type": "0.11.4"
   },
   "devDependencies": {
     "@types/node": "^20",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.11.2",
-    "@nmtjs/type": "0.11.2"
+    "@nmtjs/type": "0.11.4",
+    "@nmtjs/common": "0.11.4"
   },
   "files": [
     "src",
@@ -26,7 +26,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.11.2",
+  "version": "0.11.4",
   "scripts": {
     "build": "neemata-build --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"

package/src/container.ts

@@ -1,8 +1,11 @@
+import assert from 'node:assert'
+import { tryCaptureStackTrace } from '@nmtjs/common'
 import { Scope } from './enums.ts'
 import {
   type AnyInjectable,
   CoreInjectables,
   compareScope,
+  createExtendableClassInjectable,
   createValueInjectable,
   type Dependencies,
   type DependencyContext,
@@ -18,28 +21,32 @@ import {
 import type { Logger } from './logger.ts'
 import type { Registry } from './registry.ts'
 
+type InstanceWrapper = { private: any; public: any; context: any }
+
+type ContainerOptions = {
+  registry: Registry
+  logger: Logger
+}
+
 export class Container {
-  readonly instances = new Map<
-    AnyInjectable,
-    { instance: any; picked?: any; context?: any }
-  >()
+  readonly instances = new Map<AnyInjectable, InstanceWrapper[]>()
   private readonly resolvers = new Map<AnyInjectable, Promise<any>>()
   private readonly injectables = new Set<AnyInjectable>()
   private readonly dependants = new Map<AnyInjectable, Set<AnyInjectable>>()
+  // private readonly transients = new Map<any, any>()
   private disposing = false
 
   constructor(
-    private readonly application: {
-      registry: Registry
-      logger: Logger
-    },
+    private readonly application: ContainerOptions,
     public readonly scope: Exclude<Scope, Scope.Transient> = Scope.Global,
     private readonly parent?: Container,
   ) {
     if ((scope as any) === Scope.Transient) {
       throw new Error('Invalid scope')
     }
-    this.provide(CoreInjectables.inject, createInjectFunction(this))
+    this.provide(CoreInjectables.inject, this.createInjectFunction())
+    this.provide(CoreInjectables.dispose, this.createDisposeFunction())
+    this.provide(CoreInjectables.registry, application.registry)
   }
 
   async load() {
@@ -75,7 +82,9 @@ export class Container {
 
     // Dispose in the correct order
     for (const injectable of disposalOrder) {
-      await this.disposeInjectable(injectable)
+      if (this.instances.has(injectable)) {
+        await this.disposeInjectableInstances(injectable)
+      }
     }
 
     this.instances.clear()
@@ -98,8 +107,12 @@ export class Container {
   }
 
   get<T extends AnyInjectable>(injectable: T): ResolveInjectableType<T> {
+    if (injectable.scope === Scope.Transient) {
+      throw new Error('Cannot get transient injectable directly')
+    }
+
     if (this.instances.has(injectable)) {
-      return this.instances.get(injectable)!.instance
+      return this.instances.get(injectable)!.at(0)!.public
     }
 
     if (this.parent?.contains(injectable)) {
@@ -141,11 +154,14 @@ export class Container {
     if (compareScope(injectable.scope, '>', this.scope)) {
       throw new Error('Invalid scope') // TODO: more informative error
     }
-    this.instances.set(injectable, {
-      instance,
-      picked: instance,
-      context: undefined,
-    })
+
+    this.instances.set(injectable, [
+      {
+        private: instance,
+        public: instance,
+        context: undefined,
+      },
+    ])
   }
 
   satisfies(injectable: AnyInjectable) {
@@ -182,7 +198,7 @@ export class Container {
     ) {
       return this.parent.resolveInjectable(injectable, dependant)
     } else {
-      const { scope, dependencies, stack, label } = injectable
+      const { stack, label } = injectable
 
       if (dependant) {
         let dependants = this.dependants.get(injectable)
@@ -192,9 +208,11 @@ export class Container {
         dependants.add(dependant)
       }
 
-      if (this.instances.has(injectable)) {
-        return Promise.resolve(this.instances.get(injectable)!.picked)
-      } else if (this.resolvers.has(injectable)) {
+      const isTransient = injectable.scope === Scope.Transient
+
+      if (!isTransient && this.instances.has(injectable)) {
+        return Promise.resolve(this.instances.get(injectable)!.at(0)!.public)
+      } else if (!isTransient && this.resolvers.has(injectable)) {
         return this.resolvers.get(injectable)!
       } else {
         const isLazy = isLazyInjectable(injectable)
@@ -208,12 +226,10 @@ export class Container {
             ),
           )
         } else {
-          const resolution = this.createResolution(
-            injectable,
-            dependencies,
-            scope,
-          )
-          if (scope !== Scope.Transient) {
+          const resolution = this.createResolution(injectable).finally(() => {
+            this.resolvers.delete(injectable)
+          })
+          if (injectable.scope !== Scope.Transient) {
             this.resolvers.set(injectable, resolution)
           }
           return resolution
@@ -224,58 +240,122 @@ export class Container {
 
   private async createResolution<T extends AnyInjectable>(
     injectable: T,
-    dependencies: Dependencies,
-    scope: Scope,
   ): Promise<ResolveInjectableType<T>> {
-    try {
-      if (isFactoryInjectable(injectable)) {
-        const context = await this.createInjectableContext(
-          dependencies,
-          injectable,
-        )
-        const instance = await Promise.resolve(injectable.factory(context))
-        const picked = injectable.pick(instance)
+    const { dependencies } = injectable
+    const context = await this.createInjectableContext(dependencies, injectable)
+    const wrapper = {
+      private: null as any,
+      public: null as ResolveInjectableType<T>,
+      context,
+    }
+    if (isFactoryInjectable(injectable)) {
+      wrapper.private = await Promise.resolve(
+        injectable.factory(wrapper.context),
+      )
+      wrapper.public = injectable.pick(wrapper.private)
+    } else if (isClassInjectable(injectable)) {
+      wrapper.private = new injectable(context)
+      wrapper.public = wrapper.private
+      await wrapper.private.$onCreate()
+    } else {
+      throw new Error('Invalid injectable type')
+    }
 
-        if (compareScope(this.scope, '>=', scope)) {
-          this.instances.set(injectable, { instance, picked, context })
-        }
+    let instances = this.instances.get(injectable)
+
+    if (!instances) {
+      instances = []
+      this.instances.set(injectable, instances)
+    }
+    instances.push(wrapper)
+
+    return wrapper.public
+  }
+
+  private createInjectFunction() {
+    const inject = <T extends AnyInjectable>(
+      injectable: T,
+      context: InlineInjectionDependencies<T>,
+    ) => {
+      const dependencies: Dependencies = {
+        ...injectable.dependencies,
+      }
 
-        if (scope !== Scope.Transient) {
-          this.resolvers.delete(injectable)
+      for (const key in context) {
+        const dep = context[key]
+        if (isInjectable(dep) || isOptionalInjectable(dep)) {
+          dependencies[key] = dep
+        } else {
+          dependencies[key] = createValueInjectable(dep)
         }
+      }
+
+      const newInjectable = isClassInjectable(injectable)
+        ? createExtendableClassInjectable(
+            injectable,
+            dependencies,
+            Scope.Transient,
+            1,
+          )
+        : {
+            ...injectable,
+            dependencies,
+            scope: Scope.Transient,
+            stack: tryCaptureStackTrace(1),
+          }
+
+      return this.resolve(newInjectable) as Promise<ResolveInjectableType<T>>
+    }
 
-        return picked
-      } else if (isClassInjectable(injectable)) {
-        const context = await this.createInjectableContext(
-          dependencies,
-          injectable,
+    const explicit = async <T extends AnyInjectable>(
+      injectable: T,
+      context: InlineInjectionDependencies<T>,
+    ) => {
+      if ('asyncDispose' in Symbol === false) {
+        throw new Error(
+          'Symbol.asyncDispose is not supported in this environment',
         )
-        const instance = new injectable(context)
-        await instance.$onCreate()
-
-        if (compareScope(this.scope, '>=', scope)) {
-          this.instances.set(injectable, {
-            instance,
-            picked: instance,
-            context: undefined,
-          })
-        }
+      }
+      const instance = await inject(injectable, context)
+      const dispose = this.createDisposeFunction()
+      return Object.assign(instance, {
+        [Symbol.asyncDispose]: async () => {
+          await dispose(injectable, instance)
+        },
+      })
+    }
 
-        if (scope !== Scope.Transient) {
-          this.resolvers.delete(injectable)
-        }
+    return Object.assign(inject, { explicit })
+  }
+
+  private createDisposeFunction() {
+    return async <T extends AnyInjectable>(injectable: T, instance?: any) => {
+      if (injectable.scope === Scope.Transient) {
+        assert(
+          instance,
+          'Instance is required for transient injectable disposal',
+        )
+        const wrappers = this.instances.get(injectable)
+        if (wrappers) {
+          for (const wrapper of wrappers) {
+            if (wrapper.public === instance) {
+              await this.disposeInjectableInstance(
+                injectable,
+                wrapper.private,
+                wrapper.context,
+              )
+              const index = wrappers.indexOf(wrapper)
+              wrappers.splice(index, 1)
+            }
+          }
 
-        return instance
+          if (wrappers.length === 0) {
+            this.instances.delete(injectable)
+          }
+        }
       } else {
-        throw new Error('Invalid injectable type')
+        await this.disposeInjectableInstances(injectable)
       }
-    } catch (error) {
-      // Clean up on failure to prevent memory leaks
-      if (scope !== Scope.Transient) {
-        this.resolvers.delete(injectable)
-      }
-      this.instances.delete(injectable)
-      throw error
     }
   }
 
@@ -309,17 +389,19 @@ export class Container {
     return result
   }
 
-  private async disposeInjectable(injectable: AnyInjectable) {
+  private async disposeInjectableInstances(injectable: AnyInjectable) {
     try {
-      if (isFactoryInjectable(injectable)) {
-        const { dispose } = injectable
-        if (dispose) {
-          const { instance, context } = this.instances.get(injectable)!
-          await dispose(instance, context)
-        }
-      } else if (isClassInjectable(injectable)) {
-        const { instance } = this.instances.get(injectable)!
-        await instance.$onDispose()
+      if (this.instances.has(injectable)) {
+        const wrappers = this.instances.get(injectable)!
+        await Promise.all(
+          wrappers.map((wrapper) =>
+            this.disposeInjectableInstance(
+              injectable,
+              wrapper.private,
+              wrapper.context,
+            ),
+          ),
+        )
       }
     } catch (cause) {
       const error = new Error(
@@ -331,33 +413,18 @@ export class Container {
       this.instances.delete(injectable)
     }
   }
-}
-
-export function createInjectFunction(container: Container) {
-  return <T extends AnyInjectable>(
-    injectable: T,
-    context: InlineInjectionDependencies<T>,
-  ) => {
-    const dependencies: Dependencies = {
-      ...injectable.dependencies,
-    }
-
-    for (const key in context) {
-      const dep = context[key]
-      if (isInjectable(dep) || isOptionalInjectable(dep)) {
-        dependencies[key] = dep
-      } else {
-        dependencies[key] = createValueInjectable(dep)
-      }
-    }
 
-    const newInjectable = {
-      ...injectable,
-      dependencies,
-      scope: Scope.Transient,
+  private async disposeInjectableInstance(
+    injectable: AnyInjectable,
+    instance: any,
+    context: any,
+  ) {
+    if (isFactoryInjectable(injectable)) {
+      const { dispose } = injectable
+      if (dispose) await dispose(instance, context)
+    } else if (isClassInjectable(injectable)) {
+      await instance.$onDispose()
     }
-
-    return container.resolve(newInjectable)
   }
 }
 
@@ -367,4 +434,5 @@ type InlineInjectionDependencies<T extends AnyInjectable> = {
     | AnyInjectable<ResolveInjectableType<T['dependencies'][K]>>
 }
 
-export type InjectFn = ReturnType<typeof createInjectFunction>
+export type InjectFn = ReturnType<Container['createInjectFunction']>
+export type DisposeFn = ReturnType<Container['createDisposeFunction']>

package/src/hooks.ts

@@ -1,6 +1,7 @@
 import type { Callback } from '../../common/src/index.ts'
 import { kHookCollection } from './constants.ts'
 import type { Hook } from './enums.ts'
+
 // import type { HookType } from './types.ts'
 
 export interface HookType {

package/src/injectables.ts

@@ -1,5 +1,6 @@
 import {
   type Async,
+  type Callback,
   type ClassConstructor,
   type ClassConstructorArgs,
   type ClassInstance,
@@ -8,20 +9,23 @@ import {
 import {
   kClassInjectable,
   kFactoryInjectable,
+  kHookCollection,
   kInjectable,
   kLazyInjectable,
   kOptionalDependency,
   kValueInjectable,
 } from './constants.ts'
-import type { InjectFn } from './container.ts'
-import { Scope } from './enums.ts'
+import type { DisposeFn, InjectFn } from './container.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'
 
 const ScopeStrictness = {
-  [Scope.Global]: 0,
-  [Scope.Connection]: 1,
-  [Scope.Call]: 2,
-  [Scope.Transient]: 3,
+  [Scope.Transient]: Number.NaN, // this should make it always fail to compare with other scopes
+  [Scope.Global]: 1,
+  [Scope.Connection]: 2,
+  [Scope.Call]: 3,
 }
 
 export type DependencyOptional<T extends AnyInjectable = AnyInjectable> = {
@@ -152,29 +156,39 @@ export type AnyInjectable<T = any, S extends Scope = Scope> = Injectable<
 export const isLazyInjectable = (
   injectable: any,
 ): injectable is LazyInjectable<any> => kLazyInjectable in injectable
+
 export const isFactoryInjectable = (
   injectable: any,
 ): injectable is FactoryInjectable<any> => kFactoryInjectable in injectable
+
 export const isClassInjectable = (
   injectable: any,
 ): injectable is ClassInjectable<any> => kClassInjectable in injectable
+
 export const isValueInjectable = (
   injectable: any,
 ): injectable is ValueInjectable<any> => kValueInjectable in injectable
+
 export const isInjectable = (
   injectable: any,
 ): injectable is AnyInjectable<any> => kInjectable in injectable
+
 export const isOptionalInjectable = (
   injectable: any,
 ): injectable is DependencyOptional<any> => kOptionalDependency in injectable
 
 export function getInjectableScope(injectable: AnyInjectable) {
   let scope = injectable.scope
-  const deps = Object.values(injectable.dependencies as Dependencies)
-  for (const dependency of deps) {
+  const deps = injectable.dependencies as Dependencies
+  for (const key in deps) {
+    const dependency = deps[key]
     const injectable = getDepedencencyInjectable(dependency)
     const dependencyScope = getInjectableScope(injectable)
-    if (compareScope(dependencyScope, '>', scope)) {
+    if (
+      dependencyScope !== Scope.Transient &&
+      scope !== Scope.Transient &&
+      compareScope(dependencyScope, '>', scope)
+    ) {
       scope = dependencyScope
     }
   }
@@ -193,10 +207,10 @@ export function getDepedencencyInjectable(
 export function createOptionalInjectable<T extends AnyInjectable>(
   injectable: T,
 ) {
-  return {
+  return Object.freeze({
     [kOptionalDependency]: true,
     injectable,
-  } as DependencyOptional<T>
+  }) as DependencyOptional<T>
 }
 
 export function createLazyInjectable<T, S extends Scope = Scope.Global>(
@@ -261,16 +275,10 @@ export function createFactoryInjectable<
     [kInjectable]: true,
     [kFactoryInjectable]: true,
   }
-  const actualScope = getInjectableScope(injectable)
-  if (
-    !isFactory &&
-    params.scope &&
-    ScopeStrictness[actualScope] > ScopeStrictness[params.scope]
-  )
-    throw new Error(
-      `Invalid scope ${params.scope} for factory injectable: dependencies have stricter scope - ${actualScope}`,
-    )
-  injectable.scope = actualScope as unknown as S
+  injectable.scope = resolveInjectableScope(
+    typeof params.scope === 'undefined',
+    injectable,
+  ) as S
   return Object.freeze(injectable) as any
 }
 
@@ -279,12 +287,12 @@ export const createClassInjectable = <
   S extends Scope = Scope.Global,
 >(
   dependencies: D = {} as D,
-  scope: S = Scope.Global as S,
+  scope?: S,
   stackTraceDepth = 0,
-): ClassInjectable<ClassInstance<typeof klass>, D, S> => {
-  const klass = class {
+): ClassInjectable<ClassInstance<typeof InjectableClass>, D, S> => {
+  const InjectableClass = class {
     static dependencies = dependencies
-    static scope = scope
+    static scope = (scope ?? Scope.Global) as S
     static stack = tryCaptureStackTrace(stackTraceDepth + 2)
     static [kInjectable] = true
     static [kClassInjectable] = true
@@ -299,7 +307,13 @@ export const createClassInjectable = <
     protected async $onCreate() {}
     protected async $onDispose() {}
   }
-  return klass
+
+  InjectableClass.scope = resolveInjectableScope(
+    typeof scope === 'undefined',
+    InjectableClass,
+  ) as S
+
+  return InjectableClass
 }
 
 export function createExtendableClassInjectable<
@@ -309,23 +323,25 @@ export function createExtendableClassInjectable<
 >(
   baseClass: B,
   dependencies: D = {} as D,
-  scope: S = Scope.Global as S,
+  scope?: S,
   stackTraceDepth = 0,
 ): B extends ClassInjectable<any>
   ? ClassInjectable<ClassInstance<B>, D, S>
   : ClassInjectable<ClassInstance<B>, D, S, ClassConstructorArgs<B, []>> {
   if (isClassInjectable(baseClass)) {
-    dependencies = Object.assign({}, baseClass.dependencies, dependencies)
-    if (compareScope(scope, '<', baseClass.scope)) {
+    if (scope && compareScope(baseClass.scope, '>', scope)) {
       throw new Error(
-        'Invalid scope for injectable: base class has stricter scope',
+        `Invalid scope ${scope} for an extendable class injectable: base class have stricter scope - ${baseClass.scope}`,
       )
+    } else {
+      scope = scope ?? (baseClass.scope as S)
     }
+    dependencies = Object.assign({}, baseClass.dependencies, dependencies)
   }
-  // @ts-expect-error
-  return class extends baseClass {
+
+  const InjectableClass = class extends baseClass {
     static dependencies = dependencies
-    static scope = scope
+    static scope = (scope ?? Scope.Global) as S
     static stack = tryCaptureStackTrace(stackTraceDepth)
     static [kInjectable] = true
     static [kClassInjectable] = true
@@ -355,6 +371,14 @@ export function createExtendableClassInjectable<
       await super.$onDispose?.()
     }
   }
+
+  InjectableClass.scope = resolveInjectableScope(
+    typeof scope === 'undefined',
+    InjectableClass,
+  ) as S
+
+  // @ts-expect-error
+  return InjectableClass
 }
 
 export type DependenciesSubstitution<T extends Dependencies> = {
@@ -434,7 +458,51 @@ export function compareScope(
   }
 }
 
+const logger = createLazyInjectable<Logger>(Scope.Global, 'Logger')
+const registry = createLazyInjectable<Registry>(Scope.Global, 'Registry')
+const inject = createLazyInjectable<InjectFn>(Scope.Global, 'Inject function')
+const dispose = createLazyInjectable<DisposeFn>(
+  Scope.Global,
+  'Dispose function',
+)
+const hook = createFactoryInjectable({
+  scope: Scope.Transient,
+  dependencies: { registry },
+  factory: ({ registry }) => {
+    const hooks = new Hooks()
+    const on = <T extends Hook>(name: T, callback: HookType[T]) => {
+      hooks.add(name, callback as Callback)
+      return registry.hooks.add(name, callback)
+    }
+    return { hooks, on }
+  },
+  pick: ({ on }) => on,
+  dispose: ({ hooks }, { registry }) => {
+    for (const [hook, callbacks] of hooks[kHookCollection].entries()) {
+      for (const callback of callbacks) {
+        registry.hooks.remove(hook, callback)
+      }
+    }
+    hooks.clear()
+  },
+})
+
+function resolveInjectableScope(
+  isDefaultScope: boolean,
+  injectable: AnyInjectable,
+) {
+  const actualScope = getInjectableScope(injectable)
+  if (!isDefaultScope && compareScope(actualScope, '>', injectable.scope))
+    throw new Error(
+      `Invalid scope ${injectable.scope} for an injectable: dependencies have stricter scope - ${actualScope}`,
+    )
+  return actualScope
+}
+
 export const CoreInjectables = {
-  logger: createLazyInjectable<Logger>(Scope.Global, 'Logger'),
-  inject: createLazyInjectable<InjectFn>(Scope.Global, 'Inject function'),
+  logger,
+  registry,
+  inject,
+  dispose,
+  hook,
 }