katagami 2.3.0 → 3.0.1

package/dist/index.cjs

@@ -1,50 +1,107 @@
+"use strict";
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 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
-    });
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  createContainer: () => createContainer,
+var index_exports = {};
+__export(index_exports, {
+  Container: () => Container,
   ContainerError: () => ContainerError,
-  Container: () => Container
+  Scope: () => Scope,
+  createContainer: () => createContainer,
+  createScope: () => createScope
 });
-module.exports = __toCommonJS(exports_src);
+module.exports = __toCommonJS(index_exports);
+
+// src/internal.ts
+var INTERNALS = /* @__PURE__ */ Symbol.for("katagami.internals.v3");
+
+// src/container/index.ts
+function createContainer() {
+  return new Container();
+}
+var Container = class {
+  registrations;
+  singletonCache;
+  disposed = false;
+  /**
+   * Internal state accessor for extension modules (scope, disposable).
+   *
+   * @internal
+   */
+  [INTERNALS];
+  constructor() {
+    this.registrations = /* @__PURE__ */ new Map();
+    this.singletonCache = /* @__PURE__ */ new Map();
+    this[INTERNALS] = {
+      isDisposed: () => this.disposed,
+      markDisposed: () => {
+        this.disposed = true;
+      },
+      ownCache: this.singletonCache,
+      registrations: this.registrations,
+      singletonCache: this.singletonCache
+    };
+  }
+  registerSingleton(token, factory) {
+    return this.addRegistration(token, factory, "singleton");
+  }
+  registerTransient(token, factory) {
+    return this.addRegistration(token, factory, "transient");
+  }
+  registerScoped(token, factory) {
+    return this.addRegistration(token, factory, "scoped");
+  }
+  use(source) {
+    for (const [token, registrations] of source[INTERNALS].registrations) {
+      this.registrations.set(token, [...registrations]);
+    }
+    return this;
+  }
+  /**
+   * Add a registration entry. Accumulates registrations for the same token.
+   *
+   * @param token Token
+   * @param factory Factory function
+   * @param lifetime Lifetime of the registration
+   * @returns The container for method chaining
+   */
+  addRegistration(token, factory, lifetime) {
+    const existing = this.registrations.get(token);
+    if (existing !== void 0) {
+      existing.push({ factory, lifetime });
+    } else {
+      this.registrations.set(token, [{ factory, lifetime }]);
+    }
+    return this;
+  }
+};
 
 // src/error/index.ts
-class ContainerError extends Error {
+var ContainerError = class extends Error {
+  /**
+   * @param message Error message
+   */
   constructor(message) {
     super(message);
     this.name = "ContainerError";
   }
-}
-
-// src/internal.ts
-var INTERNALS = Symbol("katagami.internals");
+};
 
 // src/resolver/index.ts
 function tokenToString(token) {
@@ -71,46 +128,42 @@ function buildCircularPath(resolvingTokens, token) {
   return path.join(" -> ");
 }
 
-// src/container/index.ts
-function createContainer() {
-  return new Container;
+// 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.singletonCache);
 }
-
-class Container {
+var Scope = class {
   registrations;
   singletonCache;
+  scopedCache;
   resolvingTokens;
+  singletonDepth = 0;
   disposed = false;
+  /**
+   * Internal state accessor for extension modules (scope, disposable).
+   *
+   * @internal
+   */
   [INTERNALS];
-  constructor() {
-    this.registrations = new Map;
-    this.singletonCache = new Map;
-    this.resolvingTokens = new Set;
+  constructor(registrations, singletonCache) {
+    this.registrations = registrations;
+    this.singletonCache = singletonCache;
+    this.scopedCache = /* @__PURE__ */ new Map();
+    this.resolvingTokens = /* @__PURE__ */ new Set();
     this[INTERNALS] = {
       isDisposed: () => this.disposed,
       markDisposed: () => {
         this.disposed = true;
       },
-      ownCache: this.singletonCache,
+      ownCache: this.scopedCache,
       registrations: this.registrations,
       singletonCache: this.singletonCache
     };
   }
-  registerSingleton(token, factory) {
-    return this.addRegistration(token, factory, "singleton");
-  }
-  registerTransient(token, factory) {
-    return this.addRegistration(token, factory, "transient");
-  }
-  registerScoped(token, factory) {
-    return this.addRegistration(token, factory, "scoped");
-  }
-  use(source) {
-    for (const [token, registrations] of source[INTERNALS].registrations) {
-      this.registrations.set(token, [...registrations]);
-    }
-    return this;
-  }
   resolve(token) {
     return this.resolveToken(token, true);
   }
@@ -123,49 +176,81 @@ class Container {
   tryResolveAll(token) {
     return this.resolveAllTokens(token, false);
   }
+  /**
+   * Internal resolution logic shared by resolve and tryResolve.
+   * Resolves the last registered factory for the token.
+   *
+   * @param token Token to resolve
+   * @param required If true, throws when the token is not registered. If false, returns undefined.
+   * @returns The resolved instance, or undefined if not registered and required is false
+   */
   resolveToken(token, required) {
     if (this.disposed) {
-      throw new ContainerError("Cannot resolve from a disposed container.");
+      throw new ContainerError("Cannot resolve from a disposed scope.");
     }
     const registrations = this.registrations.get(token);
-    if (registrations === undefined || registrations.length === 0) {
+    if (registrations === void 0 || registrations.length === 0) {
       if (required) {
         throw new ContainerError(`Token "${tokenToString(token)}" is not registered.`);
       }
-      return;
+      return void 0;
     }
     const registration = registrations[registrations.length - 1];
-    const cached = this.singletonCache.get(registration);
-    if (cached !== undefined) {
-      return cached;
+    const singletonCached = this.singletonCache.get(registration);
+    if (singletonCached !== void 0) {
+      return singletonCached;
+    }
+    if (registration.lifetime === "scoped" && this.singletonDepth > 0) {
+      throw new ContainerError(
+        `Captive dependency detected: scoped token "${tokenToString(token)}" cannot be resolved inside a singleton factory. Scoped instances must not be captured by singletons.`
+      );
     }
-    if (registration.lifetime === "scoped") {
-      throw new ContainerError(`Cannot resolve scoped token "${tokenToString(token)}" from the root container. Use createScope() to create a scope first.`);
+    const scopedCached = this.scopedCache.get(registration);
+    if (scopedCached !== void 0) {
+      return scopedCached;
     }
     if (this.resolvingTokens.has(token)) {
       throw new ContainerError(`Circular dependency detected: ${buildCircularPath(this.resolvingTokens, token)}`);
     }
     this.resolvingTokens.add(token);
+    if (registration.lifetime === "singleton") {
+      this.singletonDepth++;
+    }
     try {
-      const instance = registration.factory(this);
+      const instance = registration.factory(
+        this
+      );
       if (registration.lifetime === "singleton") {
         this.singletonCache.set(registration, instance);
+      } else if (registration.lifetime === "scoped") {
+        this.scopedCache.set(registration, instance);
       }
       return instance;
     } finally {
+      if (registration.lifetime === "singleton") {
+        this.singletonDepth--;
+      }
       this.resolvingTokens.delete(token);
     }
   }
+  /**
+   * Internal resolution logic shared by resolveAll and tryResolveAll.
+   * Resolves all registered factories for the token.
+   *
+   * @param token Token to resolve
+   * @param required If true, throws when the token is not registered. If false, returns undefined.
+   * @returns An array of resolved instances, or undefined if not registered and required is false
+   */
   resolveAllTokens(token, required) {
     if (this.disposed) {
-      throw new ContainerError("Cannot resolve from a disposed container.");
+      throw new ContainerError("Cannot resolve from a disposed scope.");
     }
     const registrations = this.registrations.get(token);
-    if (registrations === undefined || registrations.length === 0) {
+    if (registrations === void 0 || registrations.length === 0) {
       if (required) {
         throw new ContainerError(`Token "${tokenToString(token)}" is not registered.`);
       }
-      return;
+      return void 0;
     }
     if (this.resolvingTokens.has(token)) {
       throw new ContainerError(`Circular dependency detected: ${buildCircularPath(this.resolvingTokens, token)}`);
@@ -174,30 +259,40 @@ class Container {
     try {
       return registrations.map((registration) => {
         const reg = registration;
-        const cached = this.singletonCache.get(registration);
-        if (cached !== undefined) {
-          return cached;
+        const singletonCached = this.singletonCache.get(registration);
+        if (singletonCached !== void 0) {
+          return singletonCached;
+        }
+        if (reg.lifetime === "scoped" && this.singletonDepth > 0) {
+          throw new ContainerError(
+            `Captive dependency detected: scoped token "${tokenToString(token)}" cannot be resolved inside a singleton factory. Scoped instances must not be captured by singletons.`
+          );
         }
-        if (reg.lifetime === "scoped") {
-          throw new ContainerError(`Cannot resolve scoped token "${tokenToString(token)}" from the root container. Use createScope() to create a scope first.`);
+        const scopedCached = this.scopedCache.get(registration);
+        if (scopedCached !== void 0) {
+          return scopedCached;
         }
-        const instance = reg.factory(this);
         if (reg.lifetime === "singleton") {
-          this.singletonCache.set(registration, instance);
+          this.singletonDepth++;
+        }
+        try {
+          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 {
+          if (reg.lifetime === "singleton") {
+            this.singletonDepth--;
+          }
         }
-        return instance;
       });
     } finally {
       this.resolvingTokens.delete(token);
     }
   }
-  addRegistration(token, factory, lifetime) {
-    const existing = this.registrations.get(token);
-    if (existing !== undefined) {
-      existing.push({ factory, lifetime });
-    } else {
-      this.registrations.set(token, [{ factory, lifetime }]);
-    }
-    return this;
-  }
-}
+};

package/dist/index.d.cts

@@ -0,0 +1,6 @@
+export { Container, createContainer } from './container/index.cjs';
+export type { DisposableContainer, DisposableScope, disposable } from './disposable/index.cjs';
+export { ContainerError } from './error/index.cjs';
+export type { lazy } from './lazy/index.cjs';
+export type { Resolver } from './resolver/index.cjs';
+export { createScope, Scope } from './scope/index.cjs';

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,27 +1,24 @@
-import {
-  ContainerError,
-  buildCircularPath,
-  tokenToString
-} from "./index-g50fxds1.js";
 import {
   INTERNALS
-} from "./index-jx8b52m0.js";
+} from "./chunk-J2NYR3SH.js";
 
 // src/container/index.ts
 function createContainer() {
-  return new Container;
+  return new Container();
 }
-
-class Container {
+var Container = class {
   registrations;
   singletonCache;
-  resolvingTokens;
   disposed = false;
+  /**
+   * Internal state accessor for extension modules (scope, disposable).
+   *
+   * @internal
+   */
   [INTERNALS];
   constructor() {
-    this.registrations = new Map;
-    this.singletonCache = new Map;
-    this.resolvingTokens = new Set;
+    this.registrations = /* @__PURE__ */ new Map();
+    this.singletonCache = /* @__PURE__ */ new Map();
     this[INTERNALS] = {
       isDisposed: () => this.disposed,
       markDisposed: () => {
@@ -47,6 +44,97 @@ class Container {
     }
     return this;
   }
+  /**
+   * Add a registration entry. Accumulates registrations for the same token.
+   *
+   * @param token Token
+   * @param factory Factory function
+   * @param lifetime Lifetime of the registration
+   * @returns The container for method chaining
+   */
+  addRegistration(token, factory, lifetime) {
+    const existing = this.registrations.get(token);
+    if (existing !== void 0) {
+      existing.push({ factory, lifetime });
+    } else {
+      this.registrations.set(token, [{ factory, lifetime }]);
+    }
+    return this;
+  }
+};
+
+// src/error/index.ts
+var ContainerError = class extends Error {
+  /**
+   * @param message Error message
+   */
+  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
+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.singletonCache);
+}
+var Scope = class {
+  registrations;
+  singletonCache;
+  scopedCache;
+  resolvingTokens;
+  singletonDepth = 0;
+  disposed = false;
+  /**
+   * Internal state accessor for extension modules (scope, disposable).
+   *
+   * @internal
+   */
+  [INTERNALS];
+  constructor(registrations, singletonCache) {
+    this.registrations = registrations;
+    this.singletonCache = singletonCache;
+    this.scopedCache = /* @__PURE__ */ new Map();
+    this.resolvingTokens = /* @__PURE__ */ new Set();
+    this[INTERNALS] = {
+      isDisposed: () => this.disposed,
+      markDisposed: () => {
+        this.disposed = true;
+      },
+      ownCache: this.scopedCache,
+      registrations: this.registrations,
+      singletonCache: this.singletonCache
+    };
+  }
   resolve(token) {
     return this.resolveToken(token, true);
   }
@@ -59,49 +147,81 @@ class Container {
   tryResolveAll(token) {
     return this.resolveAllTokens(token, false);
   }
+  /**
+   * Internal resolution logic shared by resolve and tryResolve.
+   * Resolves the last registered factory for the token.
+   *
+   * @param token Token to resolve
+   * @param required If true, throws when the token is not registered. If false, returns undefined.
+   * @returns The resolved instance, or undefined if not registered and required is false
+   */
   resolveToken(token, required) {
     if (this.disposed) {
-      throw new ContainerError("Cannot resolve from a disposed container.");
+      throw new ContainerError("Cannot resolve from a disposed scope.");
     }
     const registrations = this.registrations.get(token);
-    if (registrations === undefined || registrations.length === 0) {
+    if (registrations === void 0 || registrations.length === 0) {
       if (required) {
         throw new ContainerError(`Token "${tokenToString(token)}" is not registered.`);
       }
-      return;
+      return void 0;
     }
     const registration = registrations[registrations.length - 1];
-    const cached = this.singletonCache.get(registration);
-    if (cached !== undefined) {
-      return cached;
+    const singletonCached = this.singletonCache.get(registration);
+    if (singletonCached !== void 0) {
+      return singletonCached;
+    }
+    if (registration.lifetime === "scoped" && this.singletonDepth > 0) {
+      throw new ContainerError(
+        `Captive dependency detected: scoped token "${tokenToString(token)}" cannot be resolved inside a singleton factory. Scoped instances must not be captured by singletons.`
+      );
     }
-    if (registration.lifetime === "scoped") {
-      throw new ContainerError(`Cannot resolve scoped token "${tokenToString(token)}" from the root container. Use createScope() to create a scope first.`);
+    const scopedCached = this.scopedCache.get(registration);
+    if (scopedCached !== void 0) {
+      return scopedCached;
     }
     if (this.resolvingTokens.has(token)) {
       throw new ContainerError(`Circular dependency detected: ${buildCircularPath(this.resolvingTokens, token)}`);
     }
     this.resolvingTokens.add(token);
+    if (registration.lifetime === "singleton") {
+      this.singletonDepth++;
+    }
     try {
-      const instance = registration.factory(this);
+      const instance = registration.factory(
+        this
+      );
       if (registration.lifetime === "singleton") {
         this.singletonCache.set(registration, instance);
+      } else if (registration.lifetime === "scoped") {
+        this.scopedCache.set(registration, instance);
       }
       return instance;
     } finally {
+      if (registration.lifetime === "singleton") {
+        this.singletonDepth--;
+      }
       this.resolvingTokens.delete(token);
     }
   }
+  /**
+   * Internal resolution logic shared by resolveAll and tryResolveAll.
+   * Resolves all registered factories for the token.
+   *
+   * @param token Token to resolve
+   * @param required If true, throws when the token is not registered. If false, returns undefined.
+   * @returns An array of resolved instances, or undefined if not registered and required is false
+   */
   resolveAllTokens(token, required) {
     if (this.disposed) {
-      throw new ContainerError("Cannot resolve from a disposed container.");
+      throw new ContainerError("Cannot resolve from a disposed scope.");
     }
     const registrations = this.registrations.get(token);
-    if (registrations === undefined || registrations.length === 0) {
+    if (registrations === void 0 || registrations.length === 0) {
       if (required) {
         throw new ContainerError(`Token "${tokenToString(token)}" is not registered.`);
       }
-      return;
+      return void 0;
     }
     if (this.resolvingTokens.has(token)) {
       throw new ContainerError(`Circular dependency detected: ${buildCircularPath(this.resolvingTokens, token)}`);
@@ -110,35 +230,47 @@ class Container {
     try {
       return registrations.map((registration) => {
         const reg = registration;
-        const cached = this.singletonCache.get(registration);
-        if (cached !== undefined) {
-          return cached;
+        const singletonCached = this.singletonCache.get(registration);
+        if (singletonCached !== void 0) {
+          return singletonCached;
         }
-        if (reg.lifetime === "scoped") {
-          throw new ContainerError(`Cannot resolve scoped token "${tokenToString(token)}" from the root container. Use createScope() to create a scope first.`);
+        if (reg.lifetime === "scoped" && this.singletonDepth > 0) {
+          throw new ContainerError(
+            `Captive dependency detected: scoped token "${tokenToString(token)}" cannot be resolved inside a singleton factory. Scoped instances must not be captured by singletons.`
+          );
+        }
+        const scopedCached = this.scopedCache.get(registration);
+        if (scopedCached !== void 0) {
+          return scopedCached;
         }
-        const instance = reg.factory(this);
         if (reg.lifetime === "singleton") {
-          this.singletonCache.set(registration, instance);
+          this.singletonDepth++;
+        }
+        try {
+          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 {
+          if (reg.lifetime === "singleton") {
+            this.singletonDepth--;
+          }
         }
-        return instance;
       });
     } finally {
       this.resolvingTokens.delete(token);
     }
   }
-  addRegistration(token, factory, lifetime) {
-    const existing = this.registrations.get(token);
-    if (existing !== undefined) {
-      existing.push({ factory, lifetime });
-    } else {
-      this.registrations.set(token, [{ factory, lifetime }]);
-    }
-    return this;
-  }
-}
+};
 export {
-  createContainer,
+  Container,
   ContainerError,
-  Container
+  Scope,
+  createContainer,
+  createScope
 };