katagami 2.0.0 → 2.2.0

package/dist/scope/index.js

@@ -13,29 +13,29 @@ function createScope(source) {
   if (internals.isDisposed()) {
     throw new ContainerError("Cannot create a scope from a disposed container.");
   }
-  return new Scope(internals.registrations, internals.instances);
+  return new Scope(internals.registrations, internals.singletonCache);
 }
 
 class Scope {
   registrations;
-  singletonInstances;
-  scopedInstances;
+  singletonCache;
+  scopedCache;
   resolvingTokens;
   disposed = false;
   [INTERNALS];
-  constructor(registrations, singletonInstances) {
+  constructor(registrations, singletonCache) {
     this.registrations = registrations;
-    this.singletonInstances = singletonInstances;
-    this.scopedInstances = new Map;
+    this.singletonCache = singletonCache;
+    this.scopedCache = new Map;
     this.resolvingTokens = new Set;
     this[INTERNALS] = {
-      instances: this.singletonInstances,
       isDisposed: () => this.disposed,
       markDisposed: () => {
         this.disposed = true;
       },
-      ownInstances: this.scopedInstances,
-      registrations: this.registrations
+      ownCache: this.scopedCache,
+      registrations: this.registrations,
+      singletonCache: this.singletonCache
     };
   }
   resolve(token) {
@@ -44,25 +44,32 @@ class Scope {
   tryResolve(token) {
     return this.resolveToken(token, false);
   }
+  resolveAll(token) {
+    return this.resolveAllTokens(token, true);
+  }
+  tryResolveAll(token) {
+    return this.resolveAllTokens(token, false);
+  }
   resolveToken(token, required) {
     if (this.disposed) {
       throw new ContainerError("Cannot resolve from a disposed scope.");
     }
-    const singletonCached = this.singletonInstances.get(token);
+    const registrations = this.registrations.get(token);
+    if (registrations === undefined || registrations.length === 0) {
+      if (required) {
+        throw new ContainerError(`Token "${tokenToString(token)}" is not registered.`);
+      }
+      return;
+    }
+    const registration = registrations[registrations.length - 1];
+    const singletonCached = this.singletonCache.get(registration);
     if (singletonCached !== undefined) {
       return singletonCached;
     }
-    const scopedCached = this.scopedInstances.get(token);
+    const scopedCached = this.scopedCache.get(registration);
     if (scopedCached !== undefined) {
       return scopedCached;
     }
-    const registration = this.registrations.get(token);
-    if (registration === undefined) {
-      if (required) {
-        throw new ContainerError(`Token "${tokenToString(token)}" is not registered.`);
-      }
-      return;
-    }
     if (this.resolvingTokens.has(token)) {
       throw new ContainerError(`Circular dependency detected: ${buildCircularPath(this.resolvingTokens, token)}`);
     }
@@ -70,15 +77,53 @@ class Scope {
     try {
       const instance = registration.factory(this);
       if (registration.lifetime === "singleton") {
-        this.singletonInstances.set(token, instance);
+        this.singletonCache.set(registration, instance);
       } else if (registration.lifetime === "scoped") {
-        this.scopedInstances.set(token, instance);
+        this.scopedCache.set(registration, instance);
       }
       return instance;
     } finally {
       this.resolvingTokens.delete(token);
     }
   }
+  resolveAllTokens(token, required) {
+    if (this.disposed) {
+      throw new ContainerError("Cannot resolve from a disposed scope.");
+    }
+    const registrations = this.registrations.get(token);
+    if (registrations === undefined || registrations.length === 0) {
+      if (required) {
+        throw new ContainerError(`Token "${tokenToString(token)}" is not registered.`);
+      }
+      return;
+    }
+    if (this.resolvingTokens.has(token)) {
+      throw new ContainerError(`Circular dependency detected: ${buildCircularPath(this.resolvingTokens, token)}`);
+    }
+    this.resolvingTokens.add(token);
+    try {
+      return registrations.map((registration) => {
+        const reg = registration;
+        const singletonCached = this.singletonCache.get(registration);
+        if (singletonCached !== undefined) {
+          return singletonCached;
+        }
+        const scopedCached = this.scopedCache.get(registration);
+        if (scopedCached !== undefined) {
+          return scopedCached;
+        }
+        const instance = reg.factory(this);
+        if (reg.lifetime === "singleton") {
+          this.singletonCache.set(registration, instance);
+        } else if (reg.lifetime === "scoped") {
+          this.scopedCache.set(registration, instance);
+        }
+        return instance;
+      });
+    } finally {
+      this.resolvingTokens.delete(token);
+    }
+  }
 }
 export {
   createScope,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "katagami",
-	"version": "2.0.0",
+	"version": "2.2.0",
 	"description": "Lightweight DI container for TypeScript and JavaScript — full type inference, no decorators, no reflect-metadata, hybrid class & PropertyKey tokens.",
 	"license": "MIT",
 	"type": "module",
@@ -20,6 +20,11 @@
 			"types": "./dist/disposable/index.d.ts",
 			"import": "./dist/disposable/index.js",
 			"require": "./dist/disposable/index.cjs"
+		},
+		"./lazy": {
+			"types": "./dist/lazy/index.d.ts",
+			"import": "./dist/lazy/index.js",
+			"require": "./dist/lazy/index.cjs"
 		}
 	},
 	"main": "./dist/index.cjs",
@@ -45,14 +50,13 @@
 		"clean": "rm -rf dist",
 		"build": "bun run clean && bun run build:types && bun run build:esm && bun run build:cjs",
 		"build:types": "tsc -p tsconfig.build.json",
-		"build:esm": "bun build ./src/index.ts ./src/scope/index.ts ./src/disposable/index.ts --outdir dist --format esm --splitting",
-		"build:cjs": "bun build ./src/index.ts --outfile dist/index.cjs --format cjs && bun build ./src/scope/index.ts --outfile dist/scope/index.cjs --format cjs && bun build ./src/disposable/index.ts --outfile dist/disposable/index.cjs --format cjs",
-		"test": "bun test --coverage --dots",
+		"build:esm": "bun build ./src/index.ts ./src/scope/index.ts ./src/disposable/index.ts ./src/lazy/index.ts --outdir dist --format esm --splitting",
+		"build:cjs": "bun build ./src/index.ts --outfile dist/index.cjs --format cjs && bun build ./src/scope/index.ts --outfile dist/scope/index.cjs --format cjs && bun build ./src/disposable/index.ts --outfile dist/disposable/index.cjs --format cjs && bun build ./src/lazy/index.ts --outfile dist/lazy/index.cjs --format cjs",
 		"prepublishOnly": "bun run build",
 		"check": "bun run format",
 		"lint": "biome lint .",
 		"format": "biome check --write .",
-		"verify": "bun run build:types && bun run check && bun run test"
+		"verify": "bun run build:types && bun run check && bun test"
 	},
 	"dependencies": {
 		"@types/bun": "^1.3.8"