@vercube/di 0.0.25 → 0.0.26

package/dist/index.d.mts

@@ -53,6 +53,7 @@ declare class ContainerEvents {
  * simpler and (probably) more performant on larger scales.
  */
 declare class Container {
+  protected fContext: string | undefined;
   protected fLocked: boolean;
   protected fDefaultParams: IOC.ContainerParams;
   protected fServices: Map<IOC.ServiceKey, IOC.ServiceDef>;
@@ -63,6 +64,7 @@ declare class Container {
   /**
    * Constructor for container.
    * @param params initial params for container
+   * @param context the context of the container
    */
   constructor(params?: Partial<IOC.ContainerParams>);
   /**
@@ -74,6 +76,11 @@ declare class Container {
    * Returns events handler.
    */
   get events(): ContainerEvents;
+  /**
+   * Returns the context of the container.
+   * @returns {string} the context of the container
+   */
+  get context(): string | undefined;
   /**
    * Binds particular key to container in singleton scope. Multiple queries/injects of this
    * service will always return the same instance.
@@ -210,7 +217,7 @@ declare namespace IOC {
    * This is a key that we use to identify service. Symbol is new way of doing it, however we
    * also keep standard/abstract classes for backward compatability.
    */
-  type ServiceKey<T = unknown> = symbol | Newable<T> | Abstract<T>;
+  type ServiceKey<T = unknown> = string | symbol | Newable<T> | Abstract<T>;
   /**
    * This type holds implementation that might be used in class.
    */
@@ -261,6 +268,7 @@ declare namespace IOC {
   interface ContainerParams {
     createLocked: boolean;
     injectMethod?: IOC.InjectMethod;
+    context?: string;
   }
   /**
    * Method for injecting dependencies.

package/dist/index.mjs

@@ -161,8 +161,12 @@ var ContainerEvents = class {
 * simpler and (probably) more performant on larger scales.
 */
 var Container = class Container {
+	fContext;
 	fLocked = false;
-	fDefaultParams = { createLocked: false };
+	fDefaultParams = {
+		context: void 0,
+		createLocked: false
+	};
 	fServices = /* @__PURE__ */ new Map();
 	fNewQueue = /* @__PURE__ */ new Map();
 	fSingletonInstances = /* @__PURE__ */ new Map();
@@ -171,8 +175,10 @@ var Container = class Container {
 	/**
 	* Constructor for container.
 	* @param params initial params for container
+	* @param context the context of the container
 	*/
 	constructor(params) {
+		this.fContext = params?.context ?? "default";
 		this.fLocked = params?.createLocked ?? false;
 		this.fDefaultParams = Object.assign(this.fDefaultParams, params);
 		this.fInjectMethod = params?.injectMethod ?? IOC.InjectMethod.STATIC;
@@ -192,6 +198,13 @@ var Container = class Container {
 		return this.fContainerEvents;
 	}
 	/**
+	* Returns the context of the container.
+	* @returns {string} the context of the container
+	*/
+	get context() {
+		return this.fContext;
+	}
+	/**
 	* Binds particular key to container in singleton scope. Multiple queries/injects of this
 	* service will always return the same instance.
 	*
@@ -501,8 +514,21 @@ let IOC;
 * container (<1ms).
 */
 const classMap = /* @__PURE__ */ new Map();
+globalThis.__IOCClassMap = globalThis.__IOCClassMap ?? classMap;
 const ROOT_PROTO = Object.getPrototypeOf({});
 /**
+* Retrieves the class dependency metadata map used for IOC injection purposes.
+*
+* This function checks for a global `classMap` property on `globalThis` (allowing for shared class metadata between
+* multiple contexts or modules, e.g., in hot-reloading environments), and falls back to the internal `classMap` instance
+* if one does not exist. The returned map associates class prototypes with their corresponding inject metadata entries.
+*
+* @returns {Map<IOC.Prototype, IClassMapEntry>} The map of class prototypes to injection metadata entries.
+*/
+function getMapper() {
+	return globalThis.__IOCClassMap;
+}
+/**
 * This method registers @Inject() in particular class.
 * @param prototype class prototype for which we register @Inject()
 * @param propertyName name of property that is inejcted
@@ -510,10 +536,10 @@ const ROOT_PROTO = Object.getPrototypeOf({});
 * @param type type of dependency (standard or optional dependency)
 */
 function registerInject(prototype, propertyName, dependency, type) {
-	let entry = classMap.get(prototype);
+	let entry = getMapper().get(prototype);
 	if (!entry) {
 		entry = { deps: [] };
-		classMap.set(prototype, entry);
+		getMapper().set(prototype, entry);
 	}
 	const newDep = {
 		propertyName,
@@ -528,7 +554,7 @@ function registerInject(prototype, propertyName, dependency, type) {
 * @returns class map entry or null if cannot be found
 */
 function getEntryForClass(classType) {
-	const entry = classMap.get(classType.prototype);
+	const entry = getMapper().get(classType.prototype);
 	return entry === void 0 ? null : entry;
 }
 /**
@@ -539,7 +565,7 @@ function getEntryForClass(classType) {
 function getDeps(instance) {
 	const prototype = Object.getPrototypeOf(instance);
 	if (!prototype) return [];
-	const entry = classMap.get(prototype);
+	const entry = getMapper().get(prototype);
 	return entry !== void 0 && entry.deps !== void 0 ? entry.deps : [];
 }
 /**
@@ -559,7 +585,7 @@ function injectDeps(container, instance, method) {
 	* So we will use "do" loop to iterate full prototype chain.
 	*/
 	do {
-		const entry = classMap.get(prototype);
+		const entry = getMapper().get(prototype);
 		if (entry) for (const iter of entry.deps) {
 			const propertyName = iter.propertyName;
 			const dependency = iter.dependency;

package/package.json

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