katagami 2.2.0 → 3.0.0

package/dist/scope/index.cjs

@@ -1,190 +0,0 @@
-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.singletonCache);
-}
-
-class Scope {
-  registrations;
-  singletonCache;
-  scopedCache;
-  resolvingTokens;
-  disposed = false;
-  [INTERNALS];
-  constructor(registrations, singletonCache) {
-    this.registrations = registrations;
-    this.singletonCache = singletonCache;
-    this.scopedCache = new Map;
-    this.resolvingTokens = 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);
-  }
-  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 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.scopedCache.get(registration);
-    if (scopedCached !== undefined) {
-      return scopedCached;
-    }
-    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.singletonCache.set(registration, instance);
-      } else if (registration.lifetime === "scoped") {
-        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);
-    }
-  }
-}

package/dist/scope/index.js

@@ -1,131 +0,0 @@
-import {
-  ContainerError,
-  buildCircularPath,
-  tokenToString
-} from "../index-g50fxds1.js";
-import {
-  INTERNALS
-} from "../index-jx8b52m0.js";
-
-// 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 Scope {
-  registrations;
-  singletonCache;
-  scopedCache;
-  resolvingTokens;
-  disposed = false;
-  [INTERNALS];
-  constructor(registrations, singletonCache) {
-    this.registrations = registrations;
-    this.singletonCache = singletonCache;
-    this.scopedCache = new Map;
-    this.resolvingTokens = 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);
-  }
-  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 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.scopedCache.get(registration);
-    if (scopedCached !== undefined) {
-      return scopedCached;
-    }
-    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.singletonCache.set(registration, instance);
-      } else if (registration.lifetime === "scoped") {
-        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,
-  Scope
-};