@khapu2906/treasure-chest 1.0.3 → 1.2.0

package/dist/types/Container.d.ts

@@ -0,0 +1,284 @@
+/**
+ * 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?;
+    /** 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;
+    /**
+     * 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":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAEV,WAAW,EACX,SAAS,EACT,SAAS,EACT,SAAS,EACV,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;;;;;;;;;GAUG;AACH,qBAAa,SAAS;IACpB,mDAAmD;IACnD,OAAO,CAAC,QAAQ,CAAgC;IAEhD,oCAAoC;IAEpC,OAAO,CAAC,SAAS,CAA0B;IAE3C,0CAA0C;IAC1C,OAAO,CAAC,OAAO,CAA6B;IAE5C,6DAA6D;IAC7D,OAAO,CAAC,YAAY,CAA8B;IAElD,wDAAwD;IACxD,OAAO,CAAC,cAAc,CAAC,CAAS;IAEhC,qCAAqC;IACrC,OAAO,CAAC,MAAM,CAAC,CAAY;IAE3B,2BAA2B;IAC3B,OAAO,CAAC,YAAY,CAAC,CAAQ;IAE7B,yDAAyD;IACzD,OAAO,CAAC,eAAe,CAAgB;IAEvC;;;OAGG;gBACS,MAAM,CAAC,EAAE,SAAS;IAI9B;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,WAAW;IAOnE;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,WAAW;IAOxE;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,SAAS;IAOjE;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,CAAC,EACJ,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EACrB,SAAS,GAAE,SAAuB;IAQpC;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAI3C;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,IAAI,SAAS;IAIxB;;;;;;;;;;;;;;;OAeG;IACH,WAAW,IAAI,KAAK;IAMpB;;;;;;;;;;;;;;;OAeG;IACG,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAS1E;;;;;;;;;OASG;IACH,OAAO,CAAC,WAAW;IA0CnB;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC;IA6C5C;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAcxB;;;OAGG;IACH,OAAO,CAAC,aAAa;IAgBrB;;;OAGG;IACH,OAAO,CAAC,WAAW;IAgBnB;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM;wBAEA,MAAM;4BAEJ,SAAS,CAAC,GAAG,CAAC;;;IAepC;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB;;;;;;;;;;OAUG;IACH,IAAI,IAAI,MAAM,EAAE;IAMhB;;;;;;;;;;;OAWG;IACH,KAAK;IAUL;;OAEG;IACG,OAAO;CAMd"}

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,64 @@
+/**
+ * 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;
+/**
+ * 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;;;;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"}

package/package.json

@@ -1,25 +1,64 @@
 {
   "name": "@khapu2906/treasure-chest",
-  "version": "1.0.3",
-  "description": "A container package for system utilities",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "version": "1.2.0",
+  "description": "A lightweight TypeScript dependency injection container for managing service dependencies",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
-    "build": "tsc",
-    "test": "vitest",
+    "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:types",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:types": "tsc -p tsconfig.types.json",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "test:ui": "vitest --ui",
-    "prepublishOnly": "npm run build && npm test"
+    "test:coverage": "vitest run --coverage",
+    "bench": "tsx benchmarks/performance.ts",
+    "example": "tsx",
+    "example:01": "tsx examples/01-basic-usage.ts",
+    "example:02": "tsx examples/02-dependency-injection.ts",
+    "example:03": "tsx examples/03-conditional-binding.ts",
+    "example:04": "tsx examples/04-contextual-binding.ts",
+    "example:05": "tsx examples/05-alias.ts",
+    "example:06": "tsx examples/06-scoped-lifecycle.ts",
+    "example:07": "tsx examples/07-lazy-loading.ts",
+    "example:08": "tsx examples/08-child-containers.ts",
+    "example:09": "tsx examples/09-circular-dependency.ts",
+    "examples": "npm run example:01 && npm run example:02 && npm run example:03 && npm run example:04 && npm run example:05 && npm run example:06 && npm run example:07 && npm run example:08 && npm run example:09",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "format": "prettier --write \"**/*.{ts,json,md}\"",
+    "format:check": "prettier --check \"**/*.{ts,json,md}\"",
+    "prepublishOnly": "npm run lint && npm run format:check && npm run build && npm test"
   },
   "keywords": [
     "container",
-    "system",
-    "utilities"
+    "dependency-injection",
+    "di",
+    "ioc",
+    "inversion-of-control",
+    "service-container",
+    "typescript",
+    "singleton",
+    "transient",
+    "contextual-binding"
   ],
   "author": "Kent Phung",
-  "license": "MIT",
+  "license": "DIB",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/khapu2906/treasure-chest.git"
@@ -30,10 +69,13 @@
   "homepage": "https://github.com/khapu2906/treasure-chest#readme",
   "devDependencies": {
     "@types/node": "^24.10.0",
-    "typescript": "^5.9.3"
-  },
-  "dependencies": {
-    "vitest": "^4.0.7",
-    "vittest": "^1.0.2"
+    "@typescript-eslint/eslint-plugin": "^8.20.0",
+    "@typescript-eslint/parser": "^8.20.0",
+    "@vitest/coverage-v8": "^4.0.7",
+    "eslint": "^9.17.0",
+    "prettier": "^3.4.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.7"
   }
-}
+}

package/dist/index.d.ts

@@ -1,53 +0,0 @@
-/**
- * Treasure Chest Service Container in TypeScript
- * Supports:
- *  - bind / singleton
- *  - conditional binding
- *  - contextual binding
- *  - alias
- *  - resolve
- */
-type FactoryFn<T> = (c: Container) => T;
-type ConditionFn = (c: Container) => boolean;
-export declare class Container {
-    private bindings;
-    private instances;
-    private aliases;
-    private currentContext?;
-    /**
-     * Bind a dependency (default: transient)
-     */
-    bind<T>(key: string, factory: FactoryFn<T>, condition?: ConditionFn): void;
-    /**
-     * Bind a dependency as singleton (only one instance created)
-     */
-    singleton<T>(key: string, factory: FactoryFn<T>, condition?: ConditionFn): void;
-    /**
-     * Add an alias for an existing key
-     */
-    alias(aliasKey: string, originalKey: string): void;
-    /**
-     * Internal: find correct binding based on key + condition + context
-     */
-    private findBinding;
-    /**
-     * Resolve an instance from the container
-     */
-    resolve<T>(key: string, context?: string): T;
-    /**
-     * Contextual binding:
-     * Example:
-     *   container.when('UserService').needs('UserRepo').give(...)
-     */
-    when(context: string): {
-        needs: (depKey: string) => {
-            give: (factory: FactoryFn<any>) => void;
-        };
-    };
-    /**
-     * Clear all bindings and instances (useful for testing)
-     */
-    reset(): void;
-}
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,SAAS,KAAK,CAAC,CAAC;AACxC,KAAK,WAAW,GAAG,CAAC,CAAC,EAAE,SAAS,KAAK,OAAO,CAAC;AAU7C,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,OAAO,CAA8B;IAC7C,OAAO,CAAC,cAAc,CAAC,CAAS;IAEhC;;OAEG;IACH,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,WAAW;IAInE;;OAEG;IACH,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,WAAW;IAIxE;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAI3C;;OAEG;IACH,OAAO,CAAC,WAAW;IAsBnB;;OAEG;IACH,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC;IA8B5C;;;;OAIG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM;wBAEA,MAAM;4BACJ,SAAS,CAAC,GAAG,CAAC;;;IAYpC;;OAEG;IACH,KAAK;CAMN"}