katagami 1.1.0 → 2.1.0

package/dist/index.cjs

@@ -30,7 +30,6 @@ var __export = (target, all) => {
 var exports_src = {};
 __export(exports_src, {
   createContainer: () => createContainer,
-  Scope: () => Scope,
   ContainerError: () => ContainerError,
   Container: () => Container
 });
@@ -44,6 +43,9 @@ class ContainerError extends Error {
   }
 }
 
+// src/internal.ts
+var INTERNALS = Symbol("katagami.internals");
+
 // src/resolver/index.ts
 function tokenToString(token) {
   if (typeof token === "function") {
@@ -69,97 +71,6 @@ function buildCircularPath(resolvingTokens, token) {
   return path.join(" -> ");
 }
 
-// src/scope/index.ts
-class Scope {
-  registrations;
-  singletonInstances;
-  scopedInstances;
-  resolvingTokens;
-  disposed = false;
-  constructor(registrations, singletonInstances) {
-    this.registrations = registrations;
-    this.singletonInstances = singletonInstances;
-    this.scopedInstances = new Map;
-    this.resolvingTokens = new Set;
-  }
-  resolve(token) {
-    return this.resolveToken(token, true);
-  }
-  tryResolve(token) {
-    return this.resolveToken(token, false);
-  }
-  resolveToken(token, required) {
-    if (this.disposed) {
-      throw new ContainerError("Cannot resolve from a disposed scope.");
-    }
-    const singletonCached = this.singletonInstances.get(token);
-    if (singletonCached !== undefined) {
-      return singletonCached;
-    }
-    const scopedCached = this.scopedInstances.get(token);
-    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)}`);
-    }
-    this.resolvingTokens.add(token);
-    try {
-      const instance = registration.factory(this);
-      if (registration.lifetime === "singleton") {
-        this.singletonInstances.set(token, instance);
-      } else if (registration.lifetime === "scoped") {
-        this.scopedInstances.set(token, instance);
-      }
-      return instance;
-    } finally {
-      this.resolvingTokens.delete(token);
-    }
-  }
-  createScope() {
-    if (this.disposed) {
-      throw new ContainerError("Cannot create a scope from a disposed scope.");
-    }
-    return new Scope(this.registrations, this.singletonInstances);
-  }
-  async[Symbol.asyncDispose]() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    const instances = [...this.scopedInstances.values()].reverse();
-    const errors = [];
-    for (const instance of instances) {
-      try {
-        let resolved = instance;
-        if (instance instanceof Promise) {
-          resolved = await instance;
-        }
-        if (resolved != null && typeof resolved === "object") {
-          if (Symbol.asyncDispose in resolved) {
-            await resolved[Symbol.asyncDispose]();
-          } else if (Symbol.dispose in resolved) {
-            resolved[Symbol.dispose]();
-          }
-        }
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-    this.scopedInstances.clear();
-    if (errors.length > 0) {
-      throw new AggregateError(errors, "One or more errors occurred during disposal.");
-    }
-  }
-}
-
 // src/container/index.ts
 function createContainer() {
   return new Container;
@@ -170,10 +81,20 @@ class Container {
   instances;
   resolvingTokens;
   disposed = false;
+  [INTERNALS];
   constructor() {
     this.registrations = new Map;
     this.instances = new Map;
     this.resolvingTokens = new Set;
+    this[INTERNALS] = {
+      instances: this.instances,
+      isDisposed: () => this.disposed,
+      markDisposed: () => {
+        this.disposed = true;
+      },
+      ownInstances: this.instances,
+      registrations: this.registrations
+    };
   }
   registerSingleton(token, factory) {
     return this.addRegistration(token, factory, "singleton");
@@ -184,11 +105,11 @@ class Container {
   registerScoped(token, factory) {
     return this.addRegistration(token, factory, "scoped");
   }
-  createScope() {
-    if (this.disposed) {
-      throw new ContainerError("Cannot create a scope from a disposed container.");
+  use(source) {
+    for (const [token, registration] of source[INTERNALS].registrations) {
+      this.registrations.set(token, registration);
     }
-    return new Scope(this.registrations, this.instances);
+    return this;
   }
   resolve(token) {
     return this.resolveToken(token, true);
@@ -228,35 +149,6 @@ class Container {
       this.resolvingTokens.delete(token);
     }
   }
-  async[Symbol.asyncDispose]() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    const instances = [...this.instances.values()].reverse();
-    const errors = [];
-    for (const instance of instances) {
-      try {
-        let resolved = instance;
-        if (instance instanceof Promise) {
-          resolved = await instance;
-        }
-        if (resolved != null && typeof resolved === "object") {
-          if (Symbol.asyncDispose in resolved) {
-            await resolved[Symbol.asyncDispose]();
-          } else if (Symbol.dispose in resolved) {
-            resolved[Symbol.dispose]();
-          }
-        }
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-    this.instances.clear();
-    if (errors.length > 0) {
-      throw new AggregateError(errors, "One or more errors occurred during disposal.");
-    }
-  }
   addRegistration(token, factory, lifetime) {
     this.registrations.set(token, { factory, lifetime });
     return this;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { Container, createContainer } from './container';
+export type { DisposableContainer, DisposableScope, disposable } from './disposable';
 export { ContainerError } from './error';
 export type { Resolver } from './resolver';
-export { Scope } from './scope';
+export type { createScope, Scope } from './scope';

package/dist/index.js

@@ -1,126 +1,11 @@
-// src/error/index.ts
-class ContainerError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ContainerError";
-  }
-}
-
-// src/resolver/index.ts
-function tokenToString(token) {
-  if (typeof token === "function") {
-    return token.name || "anonymous function";
-  }
-  if (typeof token === "symbol") {
-    return token.toString();
-  }
-  return String(token);
-}
-function buildCircularPath(resolvingTokens, token) {
-  const path = [];
-  let found = false;
-  for (const t of resolvingTokens) {
-    if (t === token) {
-      found = true;
-    }
-    if (found) {
-      path.push(tokenToString(t));
-    }
-  }
-  path.push(tokenToString(token));
-  return path.join(" -> ");
-}
-
-// src/scope/index.ts
-class Scope {
-  registrations;
-  singletonInstances;
-  scopedInstances;
-  resolvingTokens;
-  disposed = false;
-  constructor(registrations, singletonInstances) {
-    this.registrations = registrations;
-    this.singletonInstances = singletonInstances;
-    this.scopedInstances = new Map;
-    this.resolvingTokens = new Set;
-  }
-  resolve(token) {
-    return this.resolveToken(token, true);
-  }
-  tryResolve(token) {
-    return this.resolveToken(token, false);
-  }
-  resolveToken(token, required) {
-    if (this.disposed) {
-      throw new ContainerError("Cannot resolve from a disposed scope.");
-    }
-    const singletonCached = this.singletonInstances.get(token);
-    if (singletonCached !== undefined) {
-      return singletonCached;
-    }
-    const scopedCached = this.scopedInstances.get(token);
-    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)}`);
-    }
-    this.resolvingTokens.add(token);
-    try {
-      const instance = registration.factory(this);
-      if (registration.lifetime === "singleton") {
-        this.singletonInstances.set(token, instance);
-      } else if (registration.lifetime === "scoped") {
-        this.scopedInstances.set(token, instance);
-      }
-      return instance;
-    } finally {
-      this.resolvingTokens.delete(token);
-    }
-  }
-  createScope() {
-    if (this.disposed) {
-      throw new ContainerError("Cannot create a scope from a disposed scope.");
-    }
-    return new Scope(this.registrations, this.singletonInstances);
-  }
-  async[Symbol.asyncDispose]() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    const instances = [...this.scopedInstances.values()].reverse();
-    const errors = [];
-    for (const instance of instances) {
-      try {
-        let resolved = instance;
-        if (instance instanceof Promise) {
-          resolved = await instance;
-        }
-        if (resolved != null && typeof resolved === "object") {
-          if (Symbol.asyncDispose in resolved) {
-            await resolved[Symbol.asyncDispose]();
-          } else if (Symbol.dispose in resolved) {
-            resolved[Symbol.dispose]();
-          }
-        }
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-    this.scopedInstances.clear();
-    if (errors.length > 0) {
-      throw new AggregateError(errors, "One or more errors occurred during disposal.");
-    }
-  }
-}
+import {
+  ContainerError,
+  buildCircularPath,
+  tokenToString
+} from "./index-g50fxds1.js";
+import {
+  INTERNALS
+} from "./index-jx8b52m0.js";
 
 // src/container/index.ts
 function createContainer() {
@@ -132,10 +17,20 @@ class Container {
   instances;
   resolvingTokens;
   disposed = false;
+  [INTERNALS];
   constructor() {
     this.registrations = new Map;
     this.instances = new Map;
     this.resolvingTokens = new Set;
+    this[INTERNALS] = {
+      instances: this.instances,
+      isDisposed: () => this.disposed,
+      markDisposed: () => {
+        this.disposed = true;
+      },
+      ownInstances: this.instances,
+      registrations: this.registrations
+    };
   }
   registerSingleton(token, factory) {
     return this.addRegistration(token, factory, "singleton");
@@ -146,11 +41,11 @@ class Container {
   registerScoped(token, factory) {
     return this.addRegistration(token, factory, "scoped");
   }
-  createScope() {
-    if (this.disposed) {
-      throw new ContainerError("Cannot create a scope from a disposed container.");
+  use(source) {
+    for (const [token, registration] of source[INTERNALS].registrations) {
+      this.registrations.set(token, registration);
     }
-    return new Scope(this.registrations, this.instances);
+    return this;
   }
   resolve(token) {
     return this.resolveToken(token, true);
@@ -190,35 +85,6 @@ class Container {
       this.resolvingTokens.delete(token);
     }
   }
-  async[Symbol.asyncDispose]() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    const instances = [...this.instances.values()].reverse();
-    const errors = [];
-    for (const instance of instances) {
-      try {
-        let resolved = instance;
-        if (instance instanceof Promise) {
-          resolved = await instance;
-        }
-        if (resolved != null && typeof resolved === "object") {
-          if (Symbol.asyncDispose in resolved) {
-            await resolved[Symbol.asyncDispose]();
-          } else if (Symbol.dispose in resolved) {
-            resolved[Symbol.dispose]();
-          }
-        }
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-    this.instances.clear();
-    if (errors.length > 0) {
-      throw new AggregateError(errors, "One or more errors occurred during disposal.");
-    }
-  }
   addRegistration(token, factory, lifetime) {
     this.registrations.set(token, { factory, lifetime });
     return this;
@@ -226,7 +92,6 @@ class Container {
 }
 export {
   createContainer,
-  Scope,
   ContainerError,
   Container
 };

package/dist/internal.d.ts

@@ -0,0 +1,27 @@
+import type { Registration } from './resolver';
+/**
+ * Symbol used by extension modules (scope, disposable) to access container/scope internals.
+ *
+ * @internal
+ */
+export declare const INTERNALS: unique symbol;
+/**
+ * Internal state exposed via the INTERNALS symbol.
+ *
+ * Both Container and Scope implement this interface so that extension modules
+ * (scope, disposable) can operate on either without importing the concrete class.
+ *
+ * @internal
+ */
+export interface ContainerInternals {
+    /** All registrations (singleton / transient / scoped). */
+    readonly registrations: Map<unknown, Registration>;
+    /** Instance cache used during resolution (Container: singletons, Scope: singletonInstances). */
+    readonly instances: Map<unknown, unknown>;
+    /** Instances owned by this container / scope (disposal target). */
+    readonly ownInstances: Map<unknown, unknown>;
+    /** Whether this container / scope has been disposed. */
+    isDisposed(): boolean;
+    /** Mark this container / scope as disposed. */
+    markDisposed(): void;
+}

package/dist/scope/index.cjs

@@ -0,0 +1,145 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/scope/index.ts
+var exports_scope = {};
+__export(exports_scope, {
+  createScope: () => createScope,
+  Scope: () => Scope
+});
+module.exports = __toCommonJS(exports_scope);
+
+// src/error/index.ts
+class ContainerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ContainerError";
+  }
+}
+
+// src/internal.ts
+var INTERNALS = Symbol("katagami.internals");
+
+// src/resolver/index.ts
+function tokenToString(token) {
+  if (typeof token === "function") {
+    return token.name || "anonymous function";
+  }
+  if (typeof token === "symbol") {
+    return token.toString();
+  }
+  return String(token);
+}
+function buildCircularPath(resolvingTokens, token) {
+  const path = [];
+  let found = false;
+  for (const t of resolvingTokens) {
+    if (t === token) {
+      found = true;
+    }
+    if (found) {
+      path.push(tokenToString(t));
+    }
+  }
+  path.push(tokenToString(token));
+  return path.join(" -> ");
+}
+
+// src/scope/index.ts
+function createScope(source) {
+  const internals = source[INTERNALS];
+  if (internals.isDisposed()) {
+    throw new ContainerError("Cannot create a scope from a disposed container.");
+  }
+  return new Scope(internals.registrations, internals.instances);
+}
+
+class Scope {
+  registrations;
+  singletonInstances;
+  scopedInstances;
+  resolvingTokens;
+  disposed = false;
+  [INTERNALS];
+  constructor(registrations, singletonInstances) {
+    this.registrations = registrations;
+    this.singletonInstances = singletonInstances;
+    this.scopedInstances = new Map;
+    this.resolvingTokens = new Set;
+    this[INTERNALS] = {
+      instances: this.singletonInstances,
+      isDisposed: () => this.disposed,
+      markDisposed: () => {
+        this.disposed = true;
+      },
+      ownInstances: this.scopedInstances,
+      registrations: this.registrations
+    };
+  }
+  resolve(token) {
+    return this.resolveToken(token, true);
+  }
+  tryResolve(token) {
+    return this.resolveToken(token, false);
+  }
+  resolveToken(token, required) {
+    if (this.disposed) {
+      throw new ContainerError("Cannot resolve from a disposed scope.");
+    }
+    const singletonCached = this.singletonInstances.get(token);
+    if (singletonCached !== undefined) {
+      return singletonCached;
+    }
+    const scopedCached = this.scopedInstances.get(token);
+    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)}`);
+    }
+    this.resolvingTokens.add(token);
+    try {
+      const instance = registration.factory(this);
+      if (registration.lifetime === "singleton") {
+        this.singletonInstances.set(token, instance);
+      } else if (registration.lifetime === "scoped") {
+        this.scopedInstances.set(token, instance);
+      }
+      return instance;
+    } finally {
+      this.resolvingTokens.delete(token);
+    }
+  }
+}

package/dist/scope/index.d.ts

@@ -1,4 +1,21 @@
+import type { Container } from '../container';
+import type { DisposableContainer, DisposableScope } from '../disposable';
+import { type ContainerInternals, INTERNALS } from '../internal';
 import type { AbstractConstructor, Registration } from '../resolver';
+/**
+ * Create a new scope (child container) from a Container, Scope, or their disposable variants.
+ *
+ * The scope inherits all registrations from the source.
+ * Singleton instances are shared with the parent, while scoped instances are local to the scope.
+ *
+ * @param source A Container, Scope, DisposableContainer, or DisposableScope to create a child scope from
+ * @returns A new Scope instance
+ * @throws ContainerError if the source has been disposed
+ */
+export declare function createScope<T, Sync extends AbstractConstructor, Async extends AbstractConstructor, ScopedT, ScopedSync extends AbstractConstructor, ScopedAsync extends AbstractConstructor>(source: Container<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>): Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>;
+export declare function createScope<T, Sync extends AbstractConstructor, Async extends AbstractConstructor, ScopedT, ScopedSync extends AbstractConstructor, ScopedAsync extends AbstractConstructor>(source: Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>): Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>;
+export declare function createScope<T, Sync extends AbstractConstructor, Async extends AbstractConstructor, ScopedT, ScopedSync extends AbstractConstructor, ScopedAsync extends AbstractConstructor>(source: DisposableContainer<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>): Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>;
+export declare function createScope<T, Sync extends AbstractConstructor, Async extends AbstractConstructor, ScopedT, ScopedSync extends AbstractConstructor, ScopedAsync extends AbstractConstructor>(source: DisposableScope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>): Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>;
 /**
  * Scoped child container.
  *
@@ -13,12 +30,18 @@ import type { AbstractConstructor, Registration } from '../resolver';
  * @template ScopedSync Union of scoped sync class constructors
  * @template ScopedAsync Union of scoped async class constructors
  */
-export declare class Scope<T = Record<never, never>, Sync extends AbstractConstructor = never, Async extends AbstractConstructor = never, ScopedT = Record<never, never>, ScopedSync extends AbstractConstructor = never, ScopedAsync extends AbstractConstructor = never> implements AsyncDisposable {
+export declare class Scope<T = Record<never, never>, Sync extends AbstractConstructor = never, Async extends AbstractConstructor = never, ScopedT = Record<never, never>, ScopedSync extends AbstractConstructor = never, ScopedAsync extends AbstractConstructor = never> {
     private readonly registrations;
     private readonly singletonInstances;
     private readonly scopedInstances;
     private readonly resolvingTokens;
     private disposed;
+    /**
+     * Internal state accessor for extension modules (scope, disposable).
+     *
+     * @internal
+     */
+    readonly [INTERNALS]: ContainerInternals;
     constructor(registrations: Map<unknown, Registration>, singletonInstances: Map<unknown, unknown>);
     /**
      * Resolve an instance for the given token.
@@ -56,26 +79,4 @@ export declare class Scope<T = Record<never, never>, Sync extends AbstractConstr
      * @returns The resolved instance, or undefined if not registered and required is false
      */
     private resolveToken;
-    /**
-     * Create a nested scope.
-     *
-     * The nested scope shares singleton instances with the parent but has its own scoped instance cache.
-     *
-     * @returns A new Scope instance
-     * @throws ContainerError if the scope has been disposed
-     */
-    createScope(): Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>;
-    /**
-     * Dispose all scoped instances managed by this scope.
-     *
-     * Iterates through scoped instances in reverse creation order (LIFO) and calls
-     * `[Symbol.asyncDispose]()` or `[Symbol.dispose]()` on each instance that implements them.
-     * Singleton instances are not disposed as they are owned by the parent container.
-     *
-     * This method is idempotent — subsequent calls after the first are no-ops.
-     * After disposal, `resolve()` and `createScope()` will throw `ContainerError`.
-     *
-     * @throws AggregateError if one or more instances throw during disposal
-     */
-    [Symbol.asyncDispose](): Promise<void>;
 }