@vercube/di 0.0.22 → 0.0.24

package/README.md

@@ -3,10 +3,10 @@
   <br>
   <br>
 
-  # Vercube
-  
-  Next generation HTTP framework
-  
+# Vercube
+
+Next generation HTTP framework
+
   <a href="https://www.npmjs.com/package/@vercube/cli">
     <img src="https://img.shields.io/npm/v/%40vercube%2Fdi?style=for-the-badge&logo=npm&color=%23767eff" alt="npm"/>
   </a>
@@ -16,6 +16,9 @@
   <a href="https://github.com/vercube/vercube/blob/main/LICENSE" target="_blank">
     <img src="https://img.shields.io/npm/l/%40vercube%2Fdi?style=for-the-badge&color=%23767eff" alt="License"/>
   </a>
+  <a href="https://codecov.io/gh/vercube/vercube" target="_blank">
+    <img src="https://img.shields.io/codecov/c/github/vercube/vercube?style=for-the-badge&color=%23767eff" alt="Coverage"/>
+  </a>
   <br/>
   <br/>
 </div>
@@ -23,8 +26,9 @@
 An ultra-efficient JavaScript server framework that runs anywhere - Node.js, Bun, or Deno - with unmatched flexibility and complete configurability for developers who refuse to sacrifice speed or control.
 
 ## <a name="module">Dependencie Injection Module</a>
-The Dependency Injection (DI) module provides a powerful and flexible dependency injection system for Vercube applications. It enables loose coupling between components and makes your application more maintainable and testable.
 
+The Dependency Injection (DI) module provides a powerful and flexible dependency injection system for Vercube applications. It enables loose coupling between components and makes your application more maintainable and testable.
 
 ## <a name="documentation">📖 Documentation</a>
-Comprehensive documentation is available at [vercube.dev](https://vercube.dev). There you'll find detailed module descriptions, project information, guides, and everything else you need to know about Vercube.
+
+Comprehensive documentation is available at [vercube.dev](https://vercube.dev). There you'll find detailed module descriptions, project information, guides, and everything else you need to know about Vercube.

package/dist/index.mjs

@@ -28,241 +28,6 @@ var BaseDecorator = class {
 	destroyed() {}
 };
 
-//#endregion
-//#region src/Types/IOCTypes.ts
-let IOC;
-(function(_IOC) {
-	let ServiceFactoryType = /* @__PURE__ */ function(ServiceFactoryType$1) {
-		ServiceFactoryType$1["CLASS"] = "CLASS";
-		ServiceFactoryType$1["CLASS_SINGLETON"] = "CLASS_SINGLETON";
-		ServiceFactoryType$1["INSTANCE"] = "INSTANCE";
-		return ServiceFactoryType$1;
-	}({});
-	_IOC.ServiceFactoryType = ServiceFactoryType;
-	let InjectMethod = /* @__PURE__ */ function(InjectMethod$1) {
-		InjectMethod$1["LAZY"] = "LAZY";
-		InjectMethod$1["STATIC"] = "STATIC";
-		return InjectMethod$1;
-	}({});
-	_IOC.InjectMethod = InjectMethod;
-	let DependencyType = /* @__PURE__ */ function(DependencyType$1) {
-		DependencyType$1[DependencyType$1["STANDARD"] = 0] = "STANDARD";
-		DependencyType$1[DependencyType$1["OPTIONAL"] = 1] = "OPTIONAL";
-		return DependencyType$1;
-	}({});
-	_IOC.DependencyType = DependencyType;
-})(IOC || (IOC = {}));
-
-//#endregion
-//#region src/Domain/Engine.ts
-/**
-* This map holds metadata for ALL classes in system along with their dependencies. Original idea was
-* to store those informations in object prototype, but accessing this map is blazing fast with Map
-* container (<1ms).
-*/
-const classMap = /* @__PURE__ */ new Map();
-const ROOT_PROTO = Object.getPrototypeOf({});
-/**
-* This method registers @Inject() in particular class.
-* @param prototype class prototype for which we register @Inject()
-* @param propertyName name of property that is inejcted
-* @param dependency what we should inject there
-* @param type type of dependency (standard or optional dependency)
-*/
-function registerInject(prototype, propertyName, dependency, type) {
-	let entry = classMap.get(prototype);
-	if (!entry) {
-		const newEntry = { deps: [] };
-		entry = newEntry;
-		classMap.set(prototype, entry);
-	}
-	const newDep = {
-		propertyName,
-		dependency,
-		type
-	};
-	entry.deps.push(newDep);
-}
-/**
-* Returns classmap entry for particular class. It holds information about @Injects for this particular class.
-* @param classType type of class to check
-* @returns class map entry or null if cannot be found
-*/
-function getEntryForClass(classType) {
-	const entry = classMap.get(classType.prototype);
-	return entry === void 0 ? null : entry;
-}
-/**
-* Returns array of dependencies for particular class instance.
-* @param instance class instance
-* @returns array of @Inject dependencies defined for this class
-*/
-function getDeps(instance) {
-	const prototype = Object.getPrototypeOf(instance);
-	if (!prototype) return [];
-	const entry = classMap.get(prototype);
-	return entry !== void 0 && entry.deps !== void 0 ? entry.deps : [];
-}
-/**
-* This method injects stuff into class, using container passed as first argument. We need container as
-* inject execution is always context based.
-* @param container container instance that is providing dependencies
-* @param instance class instance to inject
-* @param method inject method, "lazy" queries dep during property access while "static" injects during class creation
-*/
-function injectDeps(container, instance, method) {
-	let prototype = Object.getPrototypeOf(instance);
-	if (!prototype) return;
-	/**
-	* Here we will traverse through prototype chain until we hit dead end (ROOT_PROTO). This is because we
-	* must process inject for current class and also for every base class.
-	*
-	* So we will use "do" loop to iterate full prototype chain.
-	*/
-	do {
-		const entry = classMap.get(prototype);
-		if (entry) for (const iter of entry.deps) {
-			const propertyName = iter.propertyName;
-			const dependency = iter.dependency;
-			const type = iter.type;
-			if (Object.prototype.hasOwnProperty.call(instance, propertyName) && instance[propertyName] !== void 0) continue;
-			if (type === IOC.DependencyType.OPTIONAL) {
-				Object.defineProperty(instance, propertyName, { get: function() {
-					return container.getOptional(dependency);
-				} });
-				continue;
-			}
-			switch (method) {
-				case IOC.InjectMethod.LAZY:
-					Object.defineProperty(instance, propertyName, { get: function() {
-						return container.get(dependency);
-					} });
-					break;
-				case IOC.InjectMethod.STATIC:
-					instance[propertyName] = container.get(dependency);
-					break;
-				default: throw new Error(`IOCEngine.injectDeps() - invalid inject method ${method}`);
-			}
-		}
-		prototype = Object.getPrototypeOf(prototype);
-	} while (prototype && prototype !== ROOT_PROTO);
-}
-const IOCEngine = {
-	registerInject,
-	getEntryForClass,
-	injectDeps,
-	getDeps
-};
-
-//#endregion
-//#region src/Decorators/Inject.ts
-/**
-* Injects a dependency with particular key to service.
-* @param key key to inject
-* @returns decorator
-*/
-function Inject(key) {
-	return (target, propertyName) => {
-		IOCEngine.registerInject(target, propertyName, key, IOC.DependencyType.STANDARD);
-	};
-}
-
-//#endregion
-//#region src/Decorators/InjectOptional.ts
-/**
-* Injects a dependency with particular key to service.
-* @param key key to inject
-* @returns decorator
-*/
-function InjectOptional(key) {
-	return (target, propertyName) => {
-		IOCEngine.registerInject(target, propertyName, key, IOC.DependencyType.OPTIONAL);
-	};
-}
-
-//#endregion
-//#region src/Decorators/Init.ts
-/**
-* This decorator fires the decorated function as soon as decorators are injected. You
-* can use this for initialization logic in runtime-loaded container deps.
-*/
-var InitDecorator = class extends BaseDecorator {
-	/**
-	* Called when decorator is initialized.
-	*/
-	created() {
-		if (typeof this.instance[this.propertyName] === "function") this.instance[this.propertyName]();
-	}
-};
-/**
-* Decorator that automatically executes the decorated method when dependencies are injected.
-* Use this decorator to run initialization logic for runtime-loaded container dependencies.
-* @returns {Function} Decorator function that creates an InitDecorator instance
-*/
-function Init() {
-	return createDecorator(InitDecorator, {});
-}
-
-//#endregion
-//#region src/Decorators/Destroy.ts
-/**
-* Decorator that handles cleanup tasks when a service or component is destroyed.
-* This decorator class extends BaseDecorator and executes the decorated method
-* during the destruction phase.
-*/
-var DestroyDecorator = class extends BaseDecorator {
-	/**
-	* Called when decorator is destroyed. Executes the decorated method if it exists
-	* as a function on the instance. Used for cleanup tasks like unregistering 
-	* listeners or clearing timers.
-	*/
-	destroyed() {
-		if (typeof this.instance[this.propertyName] === "function") this.instance[this.propertyName]();
-	}
-};
-/**
-* Decorator that automatically executes the decorated method when the service or component
-* is destroyed. Use this decorator to run cleanup logic like unregistering event listeners
-* or clearing timers.
-* 
-* @example
-* ```typescript
-* class MyService {
-*   @Destroy()
-*   cleanup() {
-*     // Cleanup logic here
-*   }
-* }
-* ```
-* @returns {Function} Decorator function that creates a DestroyDecorator instance
-*/
-function Destroy() {
-	return createDecorator(DestroyDecorator, {});
-}
-
-//#endregion
-//#region src/Domain/ContainerEvents.ts
-/**
-* This class allows for container to listen on various IOC events.
-*/
-var ContainerEvents = class {
-	fOnExpanded = [];
-	/**
-	* Registers to container "onExpanded" event.
-	* @param handler event handler
-	*/
-	onExpanded(handler) {
-		this.fOnExpanded.push(handler);
-	}
-	/**
-	* Calls on expanded event.
-	* @param serviceKeys key of service we have installed
-	*/
-	callOnExpanded(serviceKeys) {
-		for (const handler of this.fOnExpanded) handler(serviceKeys);
-	}
-};
-
 //#endregion
 //#region src/Utils/Utils.ts
 /**
@@ -366,6 +131,29 @@ function destroyContainer(container) {
 	containerMap.delete(container);
 }
 
+//#endregion
+//#region src/Domain/ContainerEvents.ts
+/**
+* This class allows for container to listen on various IOC events.
+*/
+var ContainerEvents = class {
+	fOnExpanded = [];
+	/**
+	* Registers to container "onExpanded" event.
+	* @param handler event handler
+	*/
+	onExpanded(handler) {
+		this.fOnExpanded.push(handler);
+	}
+	/**
+	* Calls on expanded event.
+	* @param serviceKeys key of service we have installed
+	*/
+	callOnExpanded(serviceKeys) {
+		for (const handler of this.fOnExpanded) handler(serviceKeys);
+	}
+};
+
 //#endregion
 //#region src/Domain/Container.ts
 /**
@@ -684,5 +472,213 @@ var Container = class Container {
 	}
 };
 
+//#endregion
+//#region src/Types/IOCTypes.ts
+let IOC;
+(function(_IOC) {
+	_IOC.ServiceFactoryType = /* @__PURE__ */ function(ServiceFactoryType) {
+		ServiceFactoryType["CLASS"] = "CLASS";
+		ServiceFactoryType["CLASS_SINGLETON"] = "CLASS_SINGLETON";
+		ServiceFactoryType["INSTANCE"] = "INSTANCE";
+		return ServiceFactoryType;
+	}({});
+	_IOC.InjectMethod = /* @__PURE__ */ function(InjectMethod) {
+		InjectMethod["LAZY"] = "LAZY";
+		InjectMethod["STATIC"] = "STATIC";
+		return InjectMethod;
+	}({});
+	_IOC.DependencyType = /* @__PURE__ */ function(DependencyType) {
+		DependencyType[DependencyType["STANDARD"] = 0] = "STANDARD";
+		DependencyType[DependencyType["OPTIONAL"] = 1] = "OPTIONAL";
+		return DependencyType;
+	}({});
+})(IOC || (IOC = {}));
+
+//#endregion
+//#region src/Domain/Engine.ts
+/**
+* This map holds metadata for ALL classes in system along with their dependencies. Original idea was
+* to store those informations in object prototype, but accessing this map is blazing fast with Map
+* container (<1ms).
+*/
+const classMap = /* @__PURE__ */ new Map();
+const ROOT_PROTO = Object.getPrototypeOf({});
+/**
+* This method registers @Inject() in particular class.
+* @param prototype class prototype for which we register @Inject()
+* @param propertyName name of property that is inejcted
+* @param dependency what we should inject there
+* @param type type of dependency (standard or optional dependency)
+*/
+function registerInject(prototype, propertyName, dependency, type) {
+	let entry = classMap.get(prototype);
+	if (!entry) {
+		entry = { deps: [] };
+		classMap.set(prototype, entry);
+	}
+	const newDep = {
+		propertyName,
+		dependency,
+		type
+	};
+	entry.deps.push(newDep);
+}
+/**
+* Returns classmap entry for particular class. It holds information about @Injects for this particular class.
+* @param classType type of class to check
+* @returns class map entry or null if cannot be found
+*/
+function getEntryForClass(classType) {
+	const entry = classMap.get(classType.prototype);
+	return entry === void 0 ? null : entry;
+}
+/**
+* Returns array of dependencies for particular class instance.
+* @param instance class instance
+* @returns array of @Inject dependencies defined for this class
+*/
+function getDeps(instance) {
+	const prototype = Object.getPrototypeOf(instance);
+	if (!prototype) return [];
+	const entry = classMap.get(prototype);
+	return entry !== void 0 && entry.deps !== void 0 ? entry.deps : [];
+}
+/**
+* This method injects stuff into class, using container passed as first argument. We need container as
+* inject execution is always context based.
+* @param container container instance that is providing dependencies
+* @param instance class instance to inject
+* @param method inject method, "lazy" queries dep during property access while "static" injects during class creation
+*/
+function injectDeps(container, instance, method) {
+	let prototype = Object.getPrototypeOf(instance);
+	if (!prototype) return;
+	/**
+	* Here we will traverse through prototype chain until we hit dead end (ROOT_PROTO). This is because we
+	* must process inject for current class and also for every base class.
+	*
+	* So we will use "do" loop to iterate full prototype chain.
+	*/
+	do {
+		const entry = classMap.get(prototype);
+		if (entry) for (const iter of entry.deps) {
+			const propertyName = iter.propertyName;
+			const dependency = iter.dependency;
+			const type = iter.type;
+			if (Object.prototype.hasOwnProperty.call(instance, propertyName) && instance[propertyName] !== void 0) continue;
+			if (type === IOC.DependencyType.OPTIONAL) {
+				Object.defineProperty(instance, propertyName, { get: function() {
+					return container.getOptional(dependency);
+				} });
+				continue;
+			}
+			switch (method) {
+				case IOC.InjectMethod.LAZY:
+					Object.defineProperty(instance, propertyName, { get: function() {
+						return container.get(dependency);
+					} });
+					break;
+				case IOC.InjectMethod.STATIC:
+					instance[propertyName] = container.get(dependency);
+					break;
+				default: throw new Error(`IOCEngine.injectDeps() - invalid inject method ${method}`);
+			}
+		}
+		prototype = Object.getPrototypeOf(prototype);
+	} while (prototype && prototype !== ROOT_PROTO);
+}
+const IOCEngine = {
+	registerInject,
+	getEntryForClass,
+	injectDeps,
+	getDeps
+};
+
+//#endregion
+//#region src/Decorators/Inject.ts
+/**
+* Injects a dependency with particular key to service.
+* @param key key to inject
+* @returns decorator
+*/
+function Inject(key) {
+	return (target, propertyName) => {
+		IOCEngine.registerInject(target, propertyName, key, IOC.DependencyType.STANDARD);
+	};
+}
+
+//#endregion
+//#region src/Decorators/InjectOptional.ts
+/**
+* Injects a dependency with particular key to service.
+* @param key key to inject
+* @returns decorator
+*/
+function InjectOptional(key) {
+	return (target, propertyName) => {
+		IOCEngine.registerInject(target, propertyName, key, IOC.DependencyType.OPTIONAL);
+	};
+}
+
+//#endregion
+//#region src/Decorators/Init.ts
+/**
+* This decorator fires the decorated function as soon as decorators are injected. You
+* can use this for initialization logic in runtime-loaded container deps.
+*/
+var InitDecorator = class extends BaseDecorator {
+	/**
+	* Called when decorator is initialized.
+	*/
+	created() {
+		if (typeof this.instance[this.propertyName] === "function") this.instance[this.propertyName]();
+	}
+};
+/**
+* Decorator that automatically executes the decorated method when dependencies are injected.
+* Use this decorator to run initialization logic for runtime-loaded container dependencies.
+* @returns {Function} Decorator function that creates an InitDecorator instance
+*/
+function Init() {
+	return createDecorator(InitDecorator, {});
+}
+
+//#endregion
+//#region src/Decorators/Destroy.ts
+/**
+* Decorator that handles cleanup tasks when a service or component is destroyed.
+* This decorator class extends BaseDecorator and executes the decorated method
+* during the destruction phase.
+*/
+var DestroyDecorator = class extends BaseDecorator {
+	/**
+	* Called when decorator is destroyed. Executes the decorated method if it exists
+	* as a function on the instance. Used for cleanup tasks like unregistering
+	* listeners or clearing timers.
+	*/
+	destroyed() {
+		if (typeof this.instance[this.propertyName] === "function") this.instance[this.propertyName]();
+	}
+};
+/**
+* Decorator that automatically executes the decorated method when the service or component
+* is destroyed. Use this decorator to run cleanup logic like unregistering event listeners
+* or clearing timers.
+*
+* @example
+* ```typescript
+* class MyService {
+*   @Destroy()
+*   cleanup() {
+*     // Cleanup logic here
+*   }
+* }
+* ```
+* @returns {Function} Decorator function that creates a DestroyDecorator instance
+*/
+function Destroy() {
+	return createDecorator(DestroyDecorator, {});
+}
+
 //#endregion
 export { BaseDecorator, Container, Destroy, IOC, Identity, Init, Inject, InjectOptional, createDecorator, destroyContainer, destroyDecorators, initializeContainer, initializeDecorators };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercube/di",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "Dependencie Injection  module for Vercube framework",
   "repository": {
     "type": "git",