@navios/di 0.7.0 → 0.8.0

package/lib/{container-BCv3XS6m.cjs → container-DENMeJ87.cjs}

@@ -104,6 +104,7 @@ var FactoryInjectionToken = class {
 //#endregion
 //#region src/token/registry.mts
 var Registry = class {
+	parent;
 	factories = /* @__PURE__ */ new Map();
 	constructor(parent) {
 		this.parent = parent;
@@ -132,6 +133,23 @@ var Registry = class {
 	delete(token) {
 		this.factories.delete(token.id);
 	}
+	/**
+	* Updates the scope of an already registered factory.
+	* This is useful when you need to dynamically change a service's scope
+	* (e.g., when a singleton controller has request-scoped dependencies).
+	*
+	* @param token The injection token to update
+	* @param scope The new scope to set
+	* @returns true if the scope was updated, false if the token was not found
+	*/ updateScope(token, scope) {
+		const factory = this.factories.get(token.id);
+		if (factory) {
+			factory.scope = scope;
+			return true;
+		}
+		if (this.parent) return this.parent.updateScope(token, scope);
+		return false;
+	}
 };
 const globalRegistry = new Registry();
 
@@ -491,9 +509,14 @@ let InstanceStatus = /* @__PURE__ */ function(InstanceStatus$1) {
 */ var BaseHolderManager = class BaseHolderManager {
 	logger;
 	_holders;
+	/**
+	* Reverse dependency index: maps a dependency name to the set of holder names that depend on it.
+	* This allows O(1) lookup of dependents instead of O(n) iteration.
+	*/ _dependents;
 	constructor(logger = null) {
 		this.logger = logger;
 		this._holders = /* @__PURE__ */ new Map();
+		this._dependents = /* @__PURE__ */ new Map();
 	}
 	/**
 	* Protected getter for accessing the holders map from subclasses.
@@ -501,23 +524,81 @@ let InstanceStatus = /* @__PURE__ */ function(InstanceStatus$1) {
 		return this._holders;
 	}
 	/**
-	* Deletes a holder by name.
+	* Deletes a holder by name and cleans up the reverse dependency index.
 	* @param name The name of the holder to delete
 	* @returns true if the holder was deleted, false if it didn't exist
 	*/ delete(name) {
+		const holder = this._holders.get(name);
+		if (holder) this.removeFromDependentsIndex(name, holder.deps);
 		return this._holders.delete(name);
 	}
 	/**
+	* Registers a holder's dependencies in the reverse index.
+	* Call this after creating a holder with dependencies.
+	* @param holderName The name of the holder that has dependencies
+	* @param deps The set of dependency names
+	*/ registerDependencies(holderName, deps) {
+		for (const dep of deps) {
+			let dependents = this._dependents.get(dep);
+			if (!dependents) {
+				dependents = /* @__PURE__ */ new Set();
+				this._dependents.set(dep, dependents);
+			}
+			dependents.add(holderName);
+		}
+	}
+	/**
+	* Removes a holder from the reverse dependency index.
+	* @param holderName The name of the holder to remove
+	* @param deps The set of dependency names to clean up
+	*/ removeFromDependentsIndex(holderName, deps) {
+		for (const dep of deps) {
+			const dependents = this._dependents.get(dep);
+			if (dependents) {
+				dependents.delete(holderName);
+				if (dependents.size === 0) this._dependents.delete(dep);
+			}
+		}
+	}
+	/**
+	* Gets all holder names that depend on the given instance name.
+	* O(1) lookup using the reverse dependency index.
+	* @param instanceName The instance name to find dependents for
+	* @returns Array of holder names that depend on this instance
+	*/ getDependents(instanceName) {
+		const dependents = this._dependents.get(instanceName);
+		return dependents ? Array.from(dependents) : [];
+	}
+	/**
 	* Filters holders based on a predicate function.
 	* @param predicate Function to test each holder
 	* @returns A new Map containing only the holders that match the predicate
+	* @deprecated Use forEachHolder() for iteration to avoid allocations
 	*/ filter(predicate) {
-		return new Map([...this._holders].filter(([key, value]) => predicate(value, key)));
+		const result = /* @__PURE__ */ new Map();
+		for (const [key, value] of this._holders) if (predicate(value, key)) result.set(key, value);
+		return result;
+	}
+	/**
+	* Iterates over holders with a callback. More efficient than filter() as it
+	* avoids creating intermediate arrays and Maps.
+	* @param callback Function called for each holder with (holder, name)
+	*/ forEachHolder(callback) {
+		for (const [name, holder] of this._holders) callback(holder, name);
 	}
 	/**
-	* Clears all holders from this manager.
+	* Finds the first holder matching a predicate. More efficient than filter()
+	* when only one result is needed.
+	* @param predicate Function to test each holder
+	* @returns The first matching holder or undefined
+	*/ findHolder(predicate) {
+		for (const [name, holder] of this._holders) if (predicate(holder, name)) return holder;
+	}
+	/**
+	* Clears all holders from this manager and the reverse dependency index.
 	*/ clear() {
 		this._holders.clear();
+		this._dependents.clear();
 	}
 	/**
 	* Gets the number of holders currently managed.
@@ -601,12 +682,14 @@ let InstanceStatus = /* @__PURE__ */ function(InstanceStatus$1) {
 				if (waiterHolder && getHolder) {
 					const cycle = CircularDetector.detectCycle(waiterHolder.name, holder.name, getHolder);
 					if (cycle) return [DIError.circularDependency(cycle)];
-					waiterHolder.waitingFor.add(holder.name);
+					if (process.env.NODE_ENV !== "production") waiterHolder.waitingFor.add(holder.name);
 				}
 				try {
 					await holder.creationPromise;
 				} finally {
-					if (waiterHolder) waiterHolder.waitingFor.delete(holder.name);
+					if (process.env.NODE_ENV !== "production") {
+						if (waiterHolder) waiterHolder.waitingFor.delete(holder.name);
+					}
 				}
 				return BaseHolderManager.waitForHolderReady(holder, waiterHolder, getHolder);
 			case InstanceStatus.Destroying: return [DIError.instanceDestroying(holder.name)];
@@ -733,10 +816,11 @@ var RequestStorage = class {
 		return null;
 	}
 	findDependents(instanceName) {
-		const dependents = [];
-		for (const [name, holder] of this.contextHolder.holders) if (holder.deps.has(instanceName)) dependents.push(name);
-		for (const [name, holder] of this.holderManager.filter(() => true)) if (holder.deps.has(instanceName)) dependents.push(name);
-		return dependents;
+		const requestDependents = this.contextHolder.getDependents(instanceName);
+		const singletonDependents = this.holderManager.getDependents(instanceName);
+		if (requestDependents.length === 0) return singletonDependents;
+		if (singletonDependents.length === 0) return requestDependents;
+		return [...requestDependents, ...singletonDependents];
 	}
 };
 
@@ -942,16 +1026,13 @@ var SingletonStorage = class {
 		return this.manager.getAllNames();
 	}
 	forEach(callback) {
-		for (const [name, holder] of this.manager.filter(() => true)) callback(name, holder);
+		this.manager.forEachHolder((holder, name) => callback(name, holder));
 	}
 	findByInstance(instance) {
-		for (const [, holder] of this.manager.filter((h) => h.instance === instance)) return holder;
-		return null;
+		return this.manager.findHolder((h) => h.instance === instance) ?? null;
 	}
 	findDependents(instanceName) {
-		const dependents = [];
-		for (const [name, holder] of this.manager.filter(() => true)) if (holder.deps.has(instanceName)) dependents.push(name);
-		return dependents;
+		return this.manager.getDependents(instanceName);
 	}
 };
 
@@ -1179,6 +1260,8 @@ var SingletonStorage = class {
 	*/ async handleInstantiationSuccess(instanceName, holder, ctx, deferred, instance, scopedContainer) {
 		holder.instance = instance;
 		holder.status = InstanceStatus.Created;
+		if (ctx.deps.size > 0) if (scopedContainer) scopedContainer.getRequestContextHolder().registerDependencies(instanceName, ctx.deps);
+		else this.manager.registerDependencies(instanceName, ctx.deps);
 		if (ctx.deps.size > 0) ctx.deps.forEach((dependency) => {
 			holder.destroyListeners.push(this.serviceLocator.getEventBus().on(dependency, "destroy", () => {
 				this.logger?.log(`[InstanceResolver] Dependency ${dependency} destroyed, invalidating ${instanceName}`);
@@ -1634,12 +1717,42 @@ var SingletonStorage = class {
 //#endregion
 //#region src/internal/core/token-processor.mts
 /**
+* Simple LRU cache for instance name generation.
+* Uses a Map which maintains insertion order for efficient LRU eviction.
+*/ var InstanceNameCache = class {
+	cache = /* @__PURE__ */ new Map();
+	maxSize;
+	constructor(maxSize = 1e3) {
+		this.maxSize = maxSize;
+	}
+	get(key) {
+		const value = this.cache.get(key);
+		if (value !== void 0) {
+			this.cache.delete(key);
+			this.cache.set(key, value);
+		}
+		return value;
+	}
+	set(key, value) {
+		if (this.cache.has(key)) this.cache.delete(key);
+		else if (this.cache.size >= this.maxSize) {
+			const firstKey = this.cache.keys().next().value;
+			if (firstKey !== void 0) this.cache.delete(firstKey);
+		}
+		this.cache.set(key, value);
+	}
+	clear() {
+		this.cache.clear();
+	}
+};
+/**
 * Handles token validation, normalization, and instance name generation.
 *
 * Provides utilities for resolving tokens to their underlying InjectionToken,
 * validating arguments against schemas, and generating unique instance identifiers.
 */ var TokenProcessor = class {
 	logger;
+	instanceNameCache = new InstanceNameCache();
 	constructor(logger = null) {
 		this.logger = logger;
 	}
@@ -1698,10 +1811,16 @@ var SingletonStorage = class {
 	}
 	/**
 	* Generates a unique instance name based on token and arguments.
+	* Results are cached using an LRU cache for performance.
 	*/ generateInstanceName(token, args) {
 		if (!args) return token.toString();
-		const formattedArgs = Object.entries(args).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => `${key}=${this.formatArgValue(value)}`).join(",");
-		return `${token.toString()}:${formattedArgs.replaceAll(/"/g, "").replaceAll(/:/g, "=")}`;
+		const tokenStr = token.toString();
+		const cacheKey = `${tokenStr}:${JSON.stringify(args)}`;
+		const cached = this.instanceNameCache.get(cacheKey);
+		if (cached !== void 0) return cached;
+		const result = `${tokenStr}:${Object.entries(args).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => `${key}=${this.formatArgValue(value)}`).join(",").replaceAll(/"/g, "").replaceAll(/:/g, "=")}`;
+		this.instanceNameCache.set(cacheKey, result);
+		return result;
 	}
 	/**
 	* Formats a single argument value for instance name generation.
@@ -2497,4 +2616,4 @@ Object.defineProperty(exports, 'wrapSyncInit', {
     return wrapSyncInit;
   }
 });
-//# sourceMappingURL=container-BCv3XS6m.cjs.map
+//# sourceMappingURL=container-DENMeJ87.cjs.map