@aponiajs/core 0.3.17 → 0.3.19

package/dist/index.d.mts

@@ -31,6 +31,13 @@ declare class AponiaContainer {
   readonly graph: ModuleGraph;
   constructor(graph: ModuleGraph);
   get<T>(token: Token<T>): T;
+  /**
+   * Framework platform SPI for resolving a provider in its owning module.
+   * Application code should use get(), which enforces root-module visibility.
+   *
+   * @internal
+   */
+  resolveModuleProvider<T>(module: ModuleDefinition, token: Token<T>): T;
   initializeModule(module: ModuleDefinition): void;
   instantiateController<T>(module: ModuleDefinition, controller: ControllerDefinition): T;
 }

package/dist/index.mjs

@@ -4,10 +4,15 @@ var ModuleGraph = class {
 	root;
 	modules;
 	#moduleSet;
+	#providersByModule;
+	#exportsByModule;
+	#locationsByModule = /* @__PURE__ */ new Map();
 	constructor(root, modules) {
 		this.root = root;
 		this.modules = Object.freeze([...modules]);
 		this.#moduleSet = new Set(modules);
+		this.#providersByModule = new Map(modules.map((module) => [module, new Map(module.providers.map((provider) => [provider.provide, provider]))]));
+		this.#exportsByModule = new Map(modules.map((module) => [module, new Set(module.exports)]));
 	}
 	inspect() {
 		return Object.freeze({
@@ -26,42 +31,66 @@ var ModuleGraph = class {
 			module: module.id,
 			token: tokenName(token)
 		});
-		return this.#locate(module, token, /* @__PURE__ */ new Set());
+		const cached = this.#locationsByModule.get(module)?.get(token);
+		if (cached) return cached;
+		const location = this.#locate(module, token, /* @__PURE__ */ new Set());
+		this.#cacheLocation(module, token, location);
+		return location;
 	}
 	#locate(module, token, visited) {
-		const own = module.providers.find((provider) => provider.provide === token);
-		if (own) return {
-			module,
-			provider: own
-		};
+		const cached = this.#locationsByModule.get(module)?.get(token);
+		if (cached) return cached;
+		const own = this.#providersByModule.get(module)?.get(token);
+		if (own) {
+			const location = Object.freeze({
+				module,
+				provider: own
+			});
+			this.#cacheLocation(module, token, location);
+			return location;
+		}
 		if (visited.has(module)) throw missingProvider(module, token);
 		visited.add(module);
-		const candidates = /* @__PURE__ */ new Map();
-		for (const imported of module.imports) {
-			if (!imported.exports.includes(token)) continue;
-			const location = this.#locate(imported, token, new Set(visited));
-			candidates.set(location.provider, location);
+		try {
+			const candidates = /* @__PURE__ */ new Map();
+			for (const imported of module.imports) {
+				if (!this.#exportsByModule.get(imported)?.has(token)) continue;
+				const location = this.#locate(imported, token, visited);
+				candidates.set(location.module, location);
+			}
+			if (candidates.size === 0) throw missingProvider(module, token);
+			if (candidates.size > 1) throw new AponiaError("AMBIGUOUS_PROVIDER", `Token "${tokenName(token)}" is exported by multiple imports of module "${module.id}".`, {
+				module: module.id,
+				token: tokenName(token),
+				candidates: [...candidates.values()].map((item) => item.module.id)
+			});
+			const location = candidates.values().next().value;
+			if (!location) throw missingProvider(module, token);
+			this.#cacheLocation(module, token, location);
+			return location;
+		} finally {
+			visited.delete(module);
 		}
-		if (candidates.size === 0) throw missingProvider(module, token);
-		if (candidates.size > 1) throw new AponiaError("AMBIGUOUS_PROVIDER", `Token "${tokenName(token)}" is exported by multiple imports of module "${module.id}".`, {
-			module: module.id,
-			token: tokenName(token),
-			candidates: [...candidates.values()].map((item) => item.module.id)
-		});
-		const location = candidates.values().next().value;
-		if (!location) throw missingProvider(module, token);
-		return location;
+	}
+	#cacheLocation(module, token, location) {
+		let moduleLocations = this.#locationsByModule.get(module);
+		if (!moduleLocations) {
+			moduleLocations = /* @__PURE__ */ new Map();
+			this.#locationsByModule.set(module, moduleLocations);
+		}
+		moduleLocations.set(token, location);
 	}
 };
 function compileModuleGraph(root) {
 	const modules = [];
-	const modulesById = /* @__PURE__ */ new Map();
+	const modulesByIdentity = /* @__PURE__ */ new Map();
 	const visiting = [];
 	const visited = /* @__PURE__ */ new Set();
 	const visit = (module) => {
-		const registered = modulesById.get(module.id);
+		const identity = module.instanceId ?? module.id;
+		const registered = modulesByIdentity.get(identity);
 		if (registered && registered !== module) throw new AponiaError("DUPLICATE_MODULE", `Module id "${module.id}" belongs to more than one definition.`, { module: module.id });
-		modulesById.set(module.id, module);
+		modulesByIdentity.set(identity, module);
 		const cycleIndex = visiting.indexOf(module);
 		if (cycleIndex >= 0) {
 			const cycle = [...visiting.slice(cycleIndex), module].map((item) => item.id);
@@ -147,6 +176,16 @@ var AponiaContainer = class {
 		const location = this.graph.locate(this.graph.root, token);
 		return this.#resolve(location);
 	}
+	/**
+	* Framework platform SPI for resolving a provider in its owning module.
+	* Application code should use get(), which enforces root-module visibility.
+	*
+	* @internal
+	*/
+	resolveModuleProvider(module, token) {
+		const location = this.graph.locate(module, token);
+		return this.#resolve(location);
+	}
 	initializeModule(module) {
 		for (const provider of module.providers) this.#resolve({
 			module,
@@ -154,15 +193,17 @@ var AponiaContainer = class {
 		});
 	}
 	instantiateController(module, controller) {
-		if (this.#controllers.has(controller)) return this.#controllers.get(controller);
+		const moduleControllers = this.#controllers.get(module);
+		if (moduleControllers?.has(controller)) return moduleControllers.get(controller);
 		const dependencies = controller.inject.map((dependency) => this.#resolve(this.graph.locate(module, dependency)));
 		const instance = Reflect.construct(controller.useClass, dependencies);
-		this.#controllers.set(controller, instance);
+		this.#moduleCache(this.#controllers, module).set(controller, instance);
 		return instance;
 	}
 	#resolve(location) {
-		if (this.#instances.has(location.provider)) return this.#instances.get(location.provider);
-		const cycleIndex = this.#resolving.findIndex((item) => item.provider === location.provider);
+		const moduleInstances = this.#instances.get(location.module);
+		if (moduleInstances?.has(location.provider)) return moduleInstances.get(location.provider);
+		const cycleIndex = this.#resolving.findIndex((item) => item.module === location.module && item.provider === location.provider);
 		if (cycleIndex >= 0) {
 			const cycle = [...this.#resolving.slice(cycleIndex), location].map((item) => `${item.module.id}:${tokenName(item.provider.provide)}`);
 			throw new AponiaError("PROVIDER_CYCLE", `Provider dependency cycle detected: ${cycle.join(" -> ")}.`, { cycle });
@@ -171,12 +212,20 @@ var AponiaContainer = class {
 		try {
 			const dependencies = providerDependencies(location.provider).map((dependency) => this.#resolve(this.graph.locate(location.module, dependency)));
 			const instance = instantiate(location.provider, dependencies);
-			this.#instances.set(location.provider, instance);
+			this.#moduleCache(this.#instances, location.module).set(location.provider, instance);
 			return instance;
 		} finally {
 			this.#resolving.pop();
 		}
 	}
+	#moduleCache(cache, module) {
+		let moduleCache = cache.get(module);
+		if (!moduleCache) {
+			moduleCache = /* @__PURE__ */ new Map();
+			cache.set(module, moduleCache);
+		}
+		return moduleCache;
+	}
 };
 function createContainer(root) {
 	return new AponiaContainer(compileModuleGraph(root));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aponiajs/core",
-  "version": "0.3.17",
+  "version": "0.3.19",
   "description": "Module graph and dependency injection runtime for Aponia.",
   "homepage": "https://github.com/aponiajs/aponiajs#readme",
   "bugs": {
@@ -33,6 +33,6 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@aponiajs/common": "0.3.16"
+    "@aponiajs/common": "0.3.18"
   }
 }