@khapu2906/treasure-chest 1.0.4 → 1.3.0

package/dist/esm/Scope.js

@@ -0,0 +1,89 @@
+/**
+ * Scope management for scoped instances
+ *
+ * @module Scope
+ */
+/**
+ * Scope class for managing scoped instances
+ * A scope contains instances that live for a specific duration (e.g., per HTTP request)
+ *
+ * @example
+ * ```typescript
+ * const scope = container.createScope();
+ * const conn = container.resolve('dbConnection'); // Scoped instance
+ * await scope.dispose(); // Cleanup all scoped resources
+ * ```
+ */
+export class Scope {
+    constructor() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.instances = new Map();
+        this.disposables = [];
+    }
+    /**
+     * Get an instance from this scope
+     * @param key The service key
+     * @returns The instance or undefined
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get(key) {
+        return this.instances.get(key);
+    }
+    /**
+     * Set an instance in this scope with optional cleanup
+     * Auto-detects IDisposable instances
+     *
+     * @param key The service key
+     * @param value The instance to store
+     * @param dispose Optional disposal function
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    set(key, value, dispose) {
+        this.instances.set(key, value);
+        // Auto-detect IDisposable
+        if (!dispose && this.isDisposable(value)) {
+            dispose = () => value.dispose();
+        }
+        if (dispose) {
+            this.disposables.push(dispose);
+        }
+    }
+    /**
+     * Check if instance exists in scope
+     * @param key The service key
+     * @returns True if the instance exists
+     */
+    has(key) {
+        return this.instances.has(key);
+    }
+    /**
+     * Check if value implements IDisposable interface
+     * @private
+     * @param value The value to check
+     * @returns True if the value is disposable
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isDisposable(value) {
+        return (value !== null &&
+            value !== undefined &&
+            typeof value === 'object' &&
+            typeof value.dispose === 'function');
+    }
+    /**
+     * Dispose all instances in this scope
+     * Calls all registered disposal functions and clears the scope
+     *
+     * @example
+     * ```typescript
+     * await scope.dispose();
+     * ```
+     */
+    async dispose() {
+        for (const disposeFn of this.disposables) {
+            await disposeFn();
+        }
+        this.instances.clear();
+        this.disposables = [];
+    }
+}
+//# sourceMappingURL=Scope.js.map

package/dist/esm/Scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scope.js","sourceRoot":"","sources":["../../src/Scope.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;;;;;;;GAUG;AACH,MAAM,OAAO,KAAK;IAAlB;QACE,8DAA8D;QACtD,cAAS,GAAqB,IAAI,GAAG,EAAE,CAAC;QACxC,gBAAW,GAAgB,EAAE,CAAC;IA2ExC,CAAC;IAzEC;;;;OAIG;IACH,8DAA8D;IAC9D,GAAG,CAAC,GAAW;QACb,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IAED;;;;;;;OAOG;IACH,8DAA8D;IAC9D,GAAG,CAAC,GAAW,EAAE,KAAU,EAAE,OAAmB;QAC9C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAE/B,0BAA0B;QAC1B,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;YACzC,OAAO,GAAG,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAClC,CAAC;QAED,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,GAAG,CAAC,GAAW;QACb,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IAED;;;;;OAKG;IACH,8DAA8D;IACtD,YAAY,CAAC,KAAU;QAC7B,OAAO,CACL,KAAK,KAAK,IAAI;YACd,KAAK,KAAK,SAAS;YACnB,OAAO,KAAK,KAAK,QAAQ;YACzB,OAAO,KAAK,CAAC,OAAO,KAAK,UAAU,CACpC,CAAC;IACJ,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAO;QACX,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACzC,MAAM,SAAS,EAAE,CAAC;QACpB,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;IACxB,CAAC;CACF"}

package/dist/esm/index.js

@@ -0,0 +1,34 @@
+/**
+ * Treasure Chest - A lightweight TypeScript dependency injection container
+ *
+ * @module treasure-chest
+ * @author Kent Phung
+ * @license DIB
+ *
+ * Features:
+ *  - Transient, Singleton, and Scoped bindings
+ *  - Conditional binding based on runtime conditions
+ *  - Contextual binding for different implementations per context
+ *  - Alias support for service keys
+ *  - Nested dependency resolution
+ *  - Lazy loading with deferred initialization
+ *  - Child containers with hierarchy
+ *  - Circular dependency detection
+ *  - High-performance Map-based storage (v1.2.0)
+ *  - Auto-dispose for IDisposable instances (v1.2.0)
+ *  - Modular architecture (v1.2.0)
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@khapu2906/treasure-chest';
+ *
+ * const container = new Container();
+ * container.bind('logger', () => new Logger());
+ * const logger = container.resolve('logger');
+ * ```
+ */
+// Export main classes
+export { Container } from './Container';
+export { Lazy } from './Lazy';
+export { Scope } from './Scope';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,sBAAsB;AACtB,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC"}

package/dist/esm/types.js

@@ -0,0 +1,7 @@
+/**
+ * Type definitions for Treasure Chest DI Container
+ *
+ * @module types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/types/Container.d.ts

@@ -0,0 +1,299 @@
+/**
+ * Container class for dependency injection
+ *
+ * @module Container
+ */
+import type { ConditionFn, DisposeFn, FactoryFn, Lifecycle } from './types';
+import { Scope } from './Scope';
+/**
+ * Container class for dependency injection
+ * Manages service bindings, instances, and resolution logic
+ *
+ * @example
+ * ```typescript
+ * const container = new Container();
+ * container.bind('logger', () => new Logger());
+ * const logger = container.resolve<Logger>('logger');
+ * ```
+ */
+export declare class Container {
+    /** Map-based storage for bindings - O(1) lookup */
+    private bindings;
+    /** Cache for singleton instances */
+    private instances;
+    /** Mapping of aliases to original keys */
+    private aliases;
+    /** Cache for resolved bindings - performance optimization */
+    private bindingCache;
+    /** Current resolution context for contextual binding */
+    private currentContext?;
+    /** Parent container for hierarchy */
+    private parent?;
+    /** Composed containers for composition pattern */
+    private composedContainers;
+    /** Current active scope */
+    private currentScope?;
+    /** Resolution stack for circular dependency detection */
+    private resolutionStack;
+    /**
+     * Create a new container
+     * @param parent Optional parent container for hierarchy
+     */
+    constructor(parent?: Container);
+    /**
+     * Register a transient binding (new instance on each resolve)
+     *
+     * @template T The type of service being bound
+     * @param key The unique identifier for this service
+     * @param factory Factory function that creates the service instance
+     * @param condition Optional condition function for conditional binding
+     *
+     * @example
+     * ```typescript
+     * container.bind('database', (c) => new Database());
+     * container.bind('cache', (c) => new Cache(), (c) => process.env.CACHE_ENABLED === 'true');
+     * ```
+     */
+    bind<T>(key: string, factory: FactoryFn<T>, condition?: ConditionFn): void;
+    /**
+     * Register a singleton binding (single instance shared across all resolves)
+     *
+     * @template T The type of service being bound
+     * @param key The unique identifier for this service
+     * @param factory Factory function that creates the service instance
+     * @param condition Optional condition function for conditional binding
+     *
+     * @example
+     * ```typescript
+     * container.singleton('config', (c) => new Config());
+     * ```
+     */
+    singleton<T>(key: string, factory: FactoryFn<T>, condition?: ConditionFn): void;
+    /**
+     * Register a scoped binding (single instance per scope)
+     *
+     * @template T The type of service being bound
+     * @param key The unique identifier for this service
+     * @param factory Factory function that creates the service instance
+     * @param dispose Optional disposal function for cleanup
+     *
+     * @example
+     * ```typescript
+     * container.scoped('dbConnection', (c) => new DbConnection(), () => {
+     *   console.log('Closing connection');
+     * });
+     * ```
+     */
+    scoped<T>(key: string, factory: FactoryFn<T>, dispose?: DisposeFn): void;
+    /**
+     * Register a lazy binding (deferred initialization)
+     *
+     * @template T The type of service being bound
+     * @param key The unique identifier for this service
+     * @param factory Factory function that creates the service instance
+     * @param lifecycle The lifecycle type (default: singleton)
+     *
+     * @example
+     * ```typescript
+     * container.lazy('heavyService', (c) => new HeavyService());
+     * const lazy = container.resolve<Lazy<HeavyService>>('heavyService');
+     * // Not initialized yet
+     * const service = lazy.value; // Initialized now
+     * ```
+     */
+    lazy<T>(key: string, factory: FactoryFn<T>, lifecycle?: Lifecycle): void;
+    /**
+     * Create an alias for an existing service key
+     *
+     * @param aliasKey The new alias name
+     * @param originalKey The original service key to alias
+     *
+     * @example
+     * ```typescript
+     * container.bind('UserRepository', () => new UserRepo());
+     * container.alias('UserRepo', 'UserRepository');
+     * // Both keys now resolve to the same binding
+     * ```
+     */
+    alias(aliasKey: string, originalKey: string): void;
+    /**
+     * Create a child container that inherits from this container
+     *
+     * @returns A new child container
+     *
+     * @example
+     * ```typescript
+     * const parent = new Container();
+     * parent.singleton('config', () => new Config());
+     *
+     * const child = parent.createChild();
+     * child.bind('logger', () => new Logger());
+     *
+     * // Child can resolve both parent and own bindings
+     * const config = child.resolve('config'); // From parent
+     * const logger = child.resolve('logger'); // From child
+     * ```
+     */
+    createChild(): Container;
+    /**
+     * Create a new scope for scoped instances
+     *
+     * @returns A new scope
+     *
+     * @example
+     * ```typescript
+     * const scope = container.createScope();
+     * container.scoped('request', () => new Request());
+     *
+     * const req1 = container.resolve('request'); // Same instance within scope
+     * const req2 = container.resolve('request'); // Same as req1
+     *
+     * await scope.dispose(); // Clean up scoped instances
+     * ```
+     */
+    createScope(): Scope;
+    /**
+     * Execute a callback with a temporary scope
+     * Auto-disposes the scope when done (like C# using statement)
+     *
+     * @param callback Function to execute within the scope
+     * @returns The result of the callback
+     *
+     * @example
+     * ```typescript
+     * await container.withScope(async (scope) => {
+     *   const db = container.resolve('dbConnection');
+     *   await db.query('...');
+     *   // Auto-disposed when callback completes
+     * });
+     * ```
+     */
+    withScope<T>(callback: (scope: Scope) => T | Promise<T>): Promise<T>;
+    /**
+     * Find the appropriate binding for a given key and context
+     * Searches in current container and parent containers
+     * Uses cached result when possible for performance
+     *
+     * @private
+     * @param key The service key to find
+     * @param context Optional context for contextual binding
+     * @returns The matching binding or undefined
+     */
+    private findBinding;
+    /**
+     * Resolve a service instance from the container
+     * Handles transient, singleton, scoped, and lazy bindings
+     *
+     * @template T The expected type of the resolved service
+     * @param key The service key to resolve
+     * @param context Optional context for contextual resolution
+     * @returns The resolved service instance
+     * @throws Error if no binding exists for the key
+     * @throws Error if circular dependency is detected
+     *
+     * @example
+     * ```typescript
+     * const logger = container.resolve<Logger>('logger');
+     * const userRepo = container.resolve('UserRepo', 'UserService');
+     * ```
+     */
+    resolve<T>(key: string, context?: string): T;
+    /**
+     * Resolve a transient instance
+     * @private
+     */
+    private resolveTransient;
+    /**
+     * Resolve a singleton instance
+     * @private
+     */
+    private resolveSingleton;
+    /**
+     * Resolve a scoped instance
+     * @private
+     */
+    private resolveScoped;
+    /**
+     * Resolve a lazy instance
+     * @private
+     */
+    private resolveLazy;
+    /**
+     * Create a contextual binding (different implementations based on context)
+     * Provides a fluent API for defining context-specific dependencies
+     *
+     * @param context The context identifier (usually a service name)
+     * @returns A fluent API object with needs() method
+     *
+     * @example
+     * ```typescript
+     * // UserService will receive MockUserRepo
+     * container.when('UserService').needs('UserRepo').give(() => new MockUserRepo());
+     *
+     * // OrderService will receive RealUserRepo
+     * container.when('OrderService').needs('UserRepo').give(() => new RealUserRepo());
+     * ```
+     */
+    when(context: string): {
+        needs: (depKey: string) => {
+            give: (factory: FactoryFn<any>) => void;
+        };
+    };
+    /**
+     * Check if a binding exists for a key
+     *
+     * @param key The service key to check
+     * @returns True if binding exists
+     *
+     * @example
+     * ```typescript
+     * if (container.has('logger')) {
+     *   const logger = container.resolve('logger');
+     * }
+     * ```
+     */
+    has(key: string): boolean;
+    /**
+     * Get all registered service keys
+     *
+     * @returns Array of service keys
+     *
+     * @example
+     * ```typescript
+     * const keys = container.keys();
+     * console.log('Registered services:', keys);
+     * ```
+     */
+    keys(): string[];
+    /**
+     * Reset the container to its initial state
+     * Clears all bindings, instances, aliases, and context
+     * Useful for testing scenarios
+     *
+     * @example
+     * ```typescript
+     * afterEach(() => {
+     *   container.reset();
+     * });
+     * ```
+     */
+    reset(): void;
+    /**
+     * Compose multiple containers into a new container
+     * This allows mixing services from different domains without inheritance
+     *
+     * @param containers Array of containers to compose
+     * @returns New composed container
+     */
+    static compose(containers: Container[]): Container;
+    /**
+     * Resolve a service from composed containers
+     * @private
+     */
+    private resolveFromComposition;
+    /**
+     * Dispose the container and all its scoped instances
+     */
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=Container.d.ts.map

package/dist/types/Container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Container.d.ts","sourceRoot":"","sources":["../../src/Container.ts"],"names":[],"mappings":"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"}

package/dist/types/Lazy.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Lazy wrapper for deferred initialization
+ *
+ * @module Lazy
+ */
+/**
+ * Lazy wrapper for deferred initialization
+ * Delays the creation of an instance until it's actually accessed
+ *
+ * @template T The type of the lazy value
+ *
+ * @example
+ * ```typescript
+ * const lazy = new Lazy(() => new ExpensiveService());
+ * console.log(lazy.isInitialized); // false
+ * const service = lazy.value; // NOW it's created
+ * console.log(lazy.isInitialized); // true
+ * ```
+ */
+export declare class Lazy<T> {
+    private factory;
+    private _value?;
+    private _initialized;
+    constructor(factory: () => T);
+    /**
+     * Get the lazy value, initializing it if necessary
+     */
+    get value(): T;
+    /**
+     * Check if the lazy value has been initialized
+     */
+    get isInitialized(): boolean;
+}
+//# sourceMappingURL=Lazy.d.ts.map

package/dist/types/Lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Lazy.d.ts","sourceRoot":"","sources":["../../src/Lazy.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;GAaG;AACH,qBAAa,IAAI,CAAC,CAAC;IAIL,OAAO,CAAC,OAAO;IAH3B,OAAO,CAAC,MAAM,CAAC,CAAI;IACnB,OAAO,CAAC,YAAY,CAAS;gBAET,OAAO,EAAE,MAAM,CAAC;IAEpC;;OAEG;IACH,IAAI,KAAK,IAAI,CAAC,CAMb;IAED;;OAEG;IACH,IAAI,aAAa,IAAI,OAAO,CAE3B;CACF"}

package/dist/types/Scope.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Scope management for scoped instances
+ *
+ * @module Scope
+ */
+import type { DisposeFn } from './types';
+/**
+ * Scope class for managing scoped instances
+ * A scope contains instances that live for a specific duration (e.g., per HTTP request)
+ *
+ * @example
+ * ```typescript
+ * const scope = container.createScope();
+ * const conn = container.resolve('dbConnection'); // Scoped instance
+ * await scope.dispose(); // Cleanup all scoped resources
+ * ```
+ */
+export declare class Scope {
+    private instances;
+    private disposables;
+    /**
+     * Get an instance from this scope
+     * @param key The service key
+     * @returns The instance or undefined
+     */
+    get(key: string): any;
+    /**
+     * Set an instance in this scope with optional cleanup
+     * Auto-detects IDisposable instances
+     *
+     * @param key The service key
+     * @param value The instance to store
+     * @param dispose Optional disposal function
+     */
+    set(key: string, value: any, dispose?: DisposeFn): void;
+    /**
+     * Check if instance exists in scope
+     * @param key The service key
+     * @returns True if the instance exists
+     */
+    has(key: string): boolean;
+    /**
+     * Check if value implements IDisposable interface
+     * @private
+     * @param value The value to check
+     * @returns True if the value is disposable
+     */
+    private isDisposable;
+    /**
+     * Dispose all instances in this scope
+     * Calls all registered disposal functions and clears the scope
+     *
+     * @example
+     * ```typescript
+     * await scope.dispose();
+     * ```
+     */
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=Scope.d.ts.map

package/dist/types/Scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scope.d.ts","sourceRoot":"","sources":["../../src/Scope.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,SAAS,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,qBAAa,KAAK;IAEhB,OAAO,CAAC,SAAS,CAA+B;IAChD,OAAO,CAAC,WAAW,CAAmB;IAEtC;;;;OAIG;IAEH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG;IAIrB;;;;;;;OAOG;IAEH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,SAAS;IAahD;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB;;;;;OAKG;IAEH,OAAO,CAAC,YAAY;IASpB;;;;;;;;OAQG;IACG,OAAO;CAOd"}

package/dist/types/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Treasure Chest - A lightweight TypeScript dependency injection container
+ *
+ * @module treasure-chest
+ * @author Kent Phung
+ * @license DIB
+ *
+ * Features:
+ *  - Transient, Singleton, and Scoped bindings
+ *  - Conditional binding based on runtime conditions
+ *  - Contextual binding for different implementations per context
+ *  - Alias support for service keys
+ *  - Nested dependency resolution
+ *  - Lazy loading with deferred initialization
+ *  - Child containers with hierarchy
+ *  - Circular dependency detection
+ *  - High-performance Map-based storage (v1.2.0)
+ *  - Auto-dispose for IDisposable instances (v1.2.0)
+ *  - Modular architecture (v1.2.0)
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@khapu2906/treasure-chest';
+ *
+ * const container = new Container();
+ * container.bind('logger', () => new Logger());
+ * const logger = container.resolve('logger');
+ * ```
+ */
+export { Container } from './Container';
+export { Lazy } from './Lazy';
+export { Scope } from './Scope';
+export type { Lifecycle, IDisposable, DisposeFn } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhC,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC"}

package/dist/types/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Type definitions for Treasure Chest DI Container
+ *
+ * @module types
+ */
+/**
+ * Lifecycle type for service bindings
+ */
+export type Lifecycle = 'transient' | 'singleton' | 'scoped';
+/**
+ * Interface for disposable resources
+ * Implement this interface to enable auto-cleanup
+ *
+ * @example
+ * ```typescript
+ * class DbConnection implements IDisposable {
+ *   async dispose() {
+ *     await this.close();
+ *   }
+ * }
+ * ```
+ */
+export interface IDisposable {
+    dispose(): void | Promise<void>;
+}
+/**
+ * Disposal function for cleaning up resources
+ */
+export type DisposeFn = () => void | Promise<void>;
+/**
+ * Factory function type that creates instances of type T
+ * @template T The type of instance to create
+ * @param _c The container instance for resolving dependencies
+ * @returns An instance of type T
+ */
+export type FactoryFn<T> = (_c: any) => T;
+/**
+ * Condition function type for conditional bindings
+ * @param _c The container instance
+ * @returns True if the binding should be used
+ */
+export type ConditionFn = (_c: any) => boolean;
+/**
+ * Options for container composition
+ */
+export interface ComposeOptions {
+    /** How to handle binding conflicts between containers */
+    conflictResolution?: 'first-wins' | 'last-wins' | 'throw-error';
+    /** Whether to prefix binding keys to avoid conflicts */
+    prefixBindings?: boolean;
+    /** Separator for prefixed binding keys */
+    prefixSeparator?: string;
+    /** Whether to inherit lifecycles from composed containers */
+    inheritLifecycles?: boolean;
+}
+/**
+ * Internal binding interface representing a service registration
+ * @template T The type of service being bound
+ * @internal
+ */
+export interface Binding<T = any> {
+    /** The service key identifier */
+    key: string;
+    /** Factory function to create the service instance */
+    factory: FactoryFn<T>;
+    /** Lifecycle type: transient, singleton, or scoped */
+    lifecycle: Lifecycle;
+    /** Optional condition for conditional binding */
+    condition?: ConditionFn;
+    /** Optional context for contextual binding */
+    context?: string;
+    /** Whether this is a lazy binding */
+    lazy?: boolean;
+    /** Optional disposal function */
+    dispose?: DisposeFn;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,QAAQ,CAAC;AAE7D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnD;;;;;GAKG;AAEH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,KAAK,CAAC,CAAC;AAE1C;;;;GAIG;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,OAAO,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,yDAAyD;IACzD,kBAAkB,CAAC,EAAE,YAAY,GAAG,WAAW,GAAG,aAAa,CAAC;IAChE,wDAAwD;IACxD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,0CAA0C;IAC1C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,6DAA6D;IAC7D,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;GAIG;AAEH,MAAM,WAAW,OAAO,CAAC,CAAC,GAAG,GAAG;IAC9B,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,sDAAsD;IACtD,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACtB,sDAAsD;IACtD,SAAS,EAAE,SAAS,CAAC;IACrB,iDAAiD;IACjD,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,iCAAiC;IACjC,OAAO,CAAC,EAAE,SAAS,CAAC;CACrB"}