@codefast/di 0.5.0-canary.7 → 0.5.0-canary.9

package/src/resolution/scope.ts

@@ -1,24 +1,19 @@
+import type { Binding } from "#/binding";
+import { NO_INSTANCE } from "#/binding";
 import { MissingScopeContextError } from "#/errors";
 import type { BindingIdentifier } from "#/types";
 
-/**
- * Sentinel returned by {@link ScopeManager.peekSingleton} when nothing is cached —
- * lets hot paths read the cache with a single Map.get even for `undefined` values.
- *
- * @since 0.5.0-canary.7
- */
-export const SINGLETON_MISS: unique symbol = Symbol("di:singleton-miss");
-
 /**
  * @since 0.3.16-canary.0
  */
 export class ScopeManager {
-  // Singleton cache: bindingId -> instance
-  readonly #singletons = new Map<BindingIdentifier, unknown>();
-  // In-flight promises for async singleton creation
-  readonly #inflight = new Map<BindingIdentifier, Promise<unknown>>();
-  // Scoped cache (for child containers): bindingId -> instance
-  readonly #scoped = new Map<BindingIdentifier, unknown>();
+  // Instances live on their binding (see ARCHITECTURE.md); this list only lets disposal and
+  // `inspect()` enumerate them.
+  #singletonBindings: Array<Binding<unknown>> | undefined;
+  // In-flight promises for async singleton creation — only an async resolve ever needs it.
+  #inflight: Map<BindingIdentifier, Promise<unknown>> | undefined;
+  // Scoped cache — only a child container resolving a `scoped` binding ever needs it.
+  #scoped: Map<BindingIdentifier, unknown> | undefined;
 
   readonly isChild: boolean;
 
@@ -26,69 +21,85 @@ export class ScopeManager {
     this.isChild = isChild;
   }
 
-  hasSingleton(id: BindingIdentifier): boolean {
-    return this.#singletons.has(id);
-  }
-
-  getSingleton<Value>(id: BindingIdentifier): Value {
-    return this.#singletons.get(id) as Value;
-  }
-
-  /** Cached value, or {@link SINGLETON_MISS} — one Map.get on the hot path. */
-  peekSingleton(id: BindingIdentifier): unknown {
-    const value = this.#singletons.get(id);
-    if (value === undefined && !this.#singletons.has(id)) {
-      return SINGLETON_MISS;
+  setSingleton<const Value>(binding: Binding<Value>, instance: unknown): void {
+    if (binding.instance === NO_INSTANCE) {
+      (this.#singletonBindings ??= []).push(binding as Binding<unknown>);
     }
-    return value;
-  }
-
-  setSingleton(id: BindingIdentifier, instance: unknown): void {
-    this.#singletons.set(id, instance);
+    binding.instance = instance;
   }
 
-  deleteSingleton(id: BindingIdentifier): boolean {
-    return this.#singletons.delete(id);
+  /** Every binding in this container holding a cached singleton. */
+  cachedSingletons(): ReadonlyArray<Binding<unknown>> {
+    return this.#singletonBindings ?? EMPTY_BINDINGS;
   }
 
-  getAllSingletons(): ReadonlyMap<BindingIdentifier, unknown> {
-    return this.#singletons;
+  deleteSingleton<const Value>(binding: Binding<Value>): boolean {
+    if (binding.instance === NO_INSTANCE) {
+      return false;
+    }
+    binding.instance = NO_INSTANCE;
+    const tracked = this.#singletonBindings;
+    if (tracked !== undefined) {
+      const index = tracked.indexOf(binding as Binding<unknown>);
+      if (index !== -1) {
+        tracked.splice(index, 1);
+      }
+    }
+    return true;
   }
 
   getInflight(id: BindingIdentifier): Promise<unknown> | undefined {
-    return this.#inflight.get(id);
+    return this.#inflight?.get(id);
   }
 
   setInflight(id: BindingIdentifier, p: Promise<unknown>): void {
-    this.#inflight.set(id, p);
+    (this.#inflight ??= new Map()).set(id, p);
   }
 
   clearInflight(id: BindingIdentifier): void {
-    this.#inflight.delete(id);
+    this.#inflight?.delete(id);
   }
 
   hasScoped(id: BindingIdentifier): boolean {
-    return this.#scoped.has(id);
+    return this.#scoped !== undefined && this.#scoped.has(id);
   }
 
   getScoped<Value>(id: BindingIdentifier): Value {
-    return this.#scoped.get(id) as Value;
+    return this.#scoped?.get(id) as Value;
   }
 
   setScoped(id: BindingIdentifier, instance: unknown): void {
     if (!this.isChild) {
       throw new MissingScopeContextError("(unknown)");
     }
-    this.#scoped.set(id, instance);
+    (this.#scoped ??= new Map()).set(id, instance);
+  }
+
+  /** Releases a removed binding's scoped instance — no deactivation, per SPEC §5.2. */
+  deleteScoped(id: BindingIdentifier): void {
+    this.#scoped?.delete(id);
   }
 
-  getAllScoped(): ReadonlyMap<BindingIdentifier, unknown> {
-    return this.#scoped;
+  /** Scoped instances currently cached — a structural count for diagnostics. */
+  get scopedCount(): number {
+    return this.#scoped?.size ?? 0;
   }
 
   clearAll(): void {
-    this.#singletons.clear();
-    this.#inflight.clear();
-    this.#scoped.clear();
+    const tracked = this.#singletonBindings;
+    if (tracked !== undefined) {
+      for (const binding of tracked) {
+        binding.instance = NO_INSTANCE;
+      }
+      tracked.length = 0;
+    }
+    this.#inflight?.clear();
+    this.#scoped?.clear();
+  }
+  /** Whether the deferred table behind `#scoped` has had to be built. */
+  get isBuilt(): boolean {
+    return this.#scoped !== undefined;
   }
 }
+
+const EMPTY_BINDINGS: ReadonlyArray<Binding<unknown>> = [];