smart-lifecycle 0.1.1

package/dist/providers/adapters/tsyringe-adapter.d.ts

@@ -0,0 +1,139 @@
+import type { IServiceRegistry, ServiceToken } from '../service-provider.interface.js';
+interface TsyringeContainer {
+    register<T>(token: ServiceToken<T>, options: {
+        useFactory: () => T;
+    }): void;
+    registerInstance<T>(token: ServiceToken<T>, instance: T): void;
+    resolve<T>(token: ServiceToken<T>): T;
+    isRegistered(token: ServiceToken): boolean;
+    clearInstances(): void;
+}
+/**
+ * Defines the responsibility of providing a bridge to TSyringe DI container.
+ *
+ * @description
+ * Adapter for TSyringe DI container. Bridges SmartComponents IServiceRegistry
+ * with TSyringe's DependencyContainer. Allows using TSyringe decorators
+ * (@injectable, @inject) in your services.
+ *
+ * @architecture
+ * **Design Decisions:**
+ * - Adapter pattern for external DI integration
+ * - Supports TSyringe's decorator-based DI
+ * - Preserves type safety with generics
+ * - Lazy vs eager registration via factory functions
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import 'reflect-metadata';
+ * import { container, injectable, inject } from 'tsyringe';
+ * import { Services } from '@smartcomponents/core';
+ * import { TSyringeAdapter } from '@smartcomponents/core/adapters';
+ *
+ * // Use TSyringe as DI container
+ * Services.useImplementation(new TSyringeAdapter(container));
+ *
+ * // Now your services can use @injectable
+ * @injectable()
+ * class TodoService {
+ *   constructor(@inject('ILogger') private logger: ILogger) {}
+ * }
+ *
+ * // Lifecycle managers with TSyringe DI
+ * @injectable()
+ * class TodoListLifecycleManager extends SmartLifecycleManager<TodoList> {
+ *   constructor(
+ *     private todoService: TodoService,
+ *     @inject('ILogger') private logger: ILogger
+ *   ) {
+ *     super();
+ *   }
+ *
+ *   protected onComponentReady(component: TodoList): void {
+ *     const host = component.hostElementRef;
+ *     this.logger.info('TodoList initialized');
+ *     // Use todoService
+ *   }
+ * }
+ *
+ * // Component
+ * @SmartRender({
+ *   selector: 'todo-list',
+ *   template: '...',
+ *   lifecycle: TodoListLifecycleManager  // TSyringe resolves automatically
+ * })
+ * class TodoList extends SmartComponent {}
+ * ```
+ */
+export declare class TSyringeAdapter implements IServiceRegistry {
+    private readonly container;
+    /**
+     * Initializes a new instance of TSyringeAdapter.
+     *
+     * @param container - TSyringe DependencyContainer instance
+     * @throws Error if container is null or undefined
+     */
+    constructor(container: TsyringeContainer);
+    /**
+     * Registers a service in TSyringe container.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @param instanceOrFactory - Instance or factory function
+     * @throws Error if token is null or undefined
+     *
+     * @example
+     * ```typescript
+     * // Register with factory
+     * adapter.register('ILogger', () => new ConsoleLogger());
+     *
+     * // Register singleton instance
+     * adapter.register(ConfigService, new ConfigService({ api: '/api' }));
+     * ```
+     */
+    register<T>(token: ServiceToken<T>, instanceOrFactory: T | (() => T)): void;
+    /**
+     * Resolves a service from TSyringe container.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @returns Service instance
+     * @throws Error if service is not registered
+     *
+     * @example
+     * ```typescript
+     * const logger = adapter.get<ILogger>('ILogger');
+     * logger.info('Service resolved');
+     * ```
+     */
+    get<T>(token: ServiceToken<T>): T;
+    /**
+     * Checks if a service is registered in TSyringe container.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @returns true if service is registered, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (adapter.has('ILogger')) {
+     *   const logger = adapter.get<ILogger>('ILogger');
+     * }
+     * ```
+     */
+    has(token: ServiceToken): boolean;
+    /**
+     * Clears all registered instances in TSyringe container.
+     *
+     * @description
+     * Clears singleton instances but preserves registrations.
+     * Useful for testing or resetting application state.
+     *
+     * @example
+     * ```typescript
+     * // Clear all instances
+     * adapter.clear();
+     * ```
+     */
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=tsyringe-adapter.d.ts.map

package/dist/providers/adapters/tsyringe-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsyringe-adapter.d.ts","sourceRoot":"","sources":["../../../src/providers/adapters/tsyringe-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAEvF,UAAU,iBAAiB;IACzB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC;IAC5E,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC;IAC/D,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACtC,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC;IAC3C,cAAc,IAAI,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,qBAAa,eAAgB,YAAW,gBAAgB;IAO1C,OAAO,CAAC,QAAQ,CAAC,SAAS;IANtC;;;;;OAKG;gBAC0B,SAAS,EAAE,iBAAiB;IAMzD;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI;IAc3E;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC;IAIjC;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO;IAIjC;;;;;;;;;;;;OAYG;IACH,KAAK,IAAI,IAAI;CAGd"}

package/dist/providers/adapters/tsyringe-adapter.js

@@ -0,0 +1,151 @@
+/**
+ * Defines the responsibility of providing a bridge to TSyringe DI container.
+ *
+ * @description
+ * Adapter for TSyringe DI container. Bridges SmartComponents IServiceRegistry
+ * with TSyringe's DependencyContainer. Allows using TSyringe decorators
+ * (@injectable, @inject) in your services.
+ *
+ * @architecture
+ * **Design Decisions:**
+ * - Adapter pattern for external DI integration
+ * - Supports TSyringe's decorator-based DI
+ * - Preserves type safety with generics
+ * - Lazy vs eager registration via factory functions
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import 'reflect-metadata';
+ * import { container, injectable, inject } from 'tsyringe';
+ * import { Services } from '@smartcomponents/core';
+ * import { TSyringeAdapter } from '@smartcomponents/core/adapters';
+ *
+ * // Use TSyringe as DI container
+ * Services.useImplementation(new TSyringeAdapter(container));
+ *
+ * // Now your services can use @injectable
+ * @injectable()
+ * class TodoService {
+ *   constructor(@inject('ILogger') private logger: ILogger) {}
+ * }
+ *
+ * // Lifecycle managers with TSyringe DI
+ * @injectable()
+ * class TodoListLifecycleManager extends SmartLifecycleManager<TodoList> {
+ *   constructor(
+ *     private todoService: TodoService,
+ *     @inject('ILogger') private logger: ILogger
+ *   ) {
+ *     super();
+ *   }
+ *
+ *   protected onComponentReady(component: TodoList): void {
+ *     const host = component.hostElementRef;
+ *     this.logger.info('TodoList initialized');
+ *     // Use todoService
+ *   }
+ * }
+ *
+ * // Component
+ * @SmartRender({
+ *   selector: 'todo-list',
+ *   template: '...',
+ *   lifecycle: TodoListLifecycleManager  // TSyringe resolves automatically
+ * })
+ * class TodoList extends SmartComponent {}
+ * ```
+ */
+export class TSyringeAdapter {
+    container;
+    /**
+     * Initializes a new instance of TSyringeAdapter.
+     *
+     * @param container - TSyringe DependencyContainer instance
+     * @throws Error if container is null or undefined
+     */
+    constructor(container) {
+        this.container = container;
+        if (!container) {
+            throw new Error('TSyringe DependencyContainer is required');
+        }
+    }
+    /**
+     * Registers a service in TSyringe container.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @param instanceOrFactory - Instance or factory function
+     * @throws Error if token is null or undefined
+     *
+     * @example
+     * ```typescript
+     * // Register with factory
+     * adapter.register('ILogger', () => new ConsoleLogger());
+     *
+     * // Register singleton instance
+     * adapter.register(ConfigService, new ConfigService({ api: '/api' }));
+     * ```
+     */
+    register(token, instanceOrFactory) {
+        if (!token) {
+            throw new Error('Service token is required');
+        }
+        if (typeof instanceOrFactory === 'function') {
+            // Register as factory (lazy)
+            this.container.register(token, { useFactory: instanceOrFactory });
+        }
+        else {
+            // Register as singleton instance (eager)
+            this.container.registerInstance(token, instanceOrFactory);
+        }
+    }
+    /**
+     * Resolves a service from TSyringe container.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @returns Service instance
+     * @throws Error if service is not registered
+     *
+     * @example
+     * ```typescript
+     * const logger = adapter.get<ILogger>('ILogger');
+     * logger.info('Service resolved');
+     * ```
+     */
+    get(token) {
+        return this.container.resolve(token);
+    }
+    /**
+     * Checks if a service is registered in TSyringe container.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @returns true if service is registered, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (adapter.has('ILogger')) {
+     *   const logger = adapter.get<ILogger>('ILogger');
+     * }
+     * ```
+     */
+    has(token) {
+        return this.container.isRegistered(token);
+    }
+    /**
+     * Clears all registered instances in TSyringe container.
+     *
+     * @description
+     * Clears singleton instances but preserves registrations.
+     * Useful for testing or resetting application state.
+     *
+     * @example
+     * ```typescript
+     * // Clear all instances
+     * adapter.clear();
+     * ```
+     */
+    clear() {
+        this.container.clearInstances();
+    }
+}
+//# sourceMappingURL=tsyringe-adapter.js.map

package/dist/providers/adapters/tsyringe-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsyringe-adapter.js","sourceRoot":"","sources":["../../../src/providers/adapters/tsyringe-adapter.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,MAAM,OAAO,eAAe;IAOG;IAN7B;;;;;OAKG;IACH,YAA6B,SAA4B;QAA5B,cAAS,GAAT,SAAS,CAAmB;QACvD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAI,KAAsB,EAAE,iBAAgC;QAClE,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC/C,CAAC;QAED,IAAI,OAAO,iBAAiB,KAAK,UAAU,EAAE,CAAC;YAC5C,6BAA6B;YAC7B,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,UAAU,EAAE,iBAA4B,EAAE,CAAC,CAAC;QAC/E,CAAC;aAAM,CAAC;YACN,yCAAyC;YACzC,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,GAAG,CAAI,KAAsB;QAC3B,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,KAAmB;QACrB,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,KAAK;QACH,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;IAClC,CAAC;CACF"}

package/dist/providers/app-services.d.ts

@@ -0,0 +1,131 @@
+import type { ServiceToken } from './service-provider.interface.js';
+export type { ServiceToken } from './service-provider.interface.js';
+/**
+ * Defines the responsibility of providing a simplified facade for application services.
+ *
+ * @description
+ * Application Services Facade for developers without external DI containers.
+ * Framework services use internal Services registry, application services use this facade.
+ *
+ * @architecture
+ * **Design Decisions:**
+ * - Facade pattern over Services for simplified developer API
+ * - Auto-instantiation for classes without factory
+ * - Singleton support for eager initialization
+ * - Type-safe token resolution (class, string, symbol)
+ *
+ * @example
+ * ```typescript
+ * // Simple service registration
+ * AppServices.provide(TodoService);
+ *
+ * // Service with dependencies
+ * AppServices.provide(TodoService, () => {
+ *   const http = AppServices.get(HttpService);
+ *   return new TodoService(http);
+ * });
+ *
+ * // Singleton instance
+ * AppServices.provideSingleton(ConfigService, new ConfigService({ api: '/api' }));
+ * ```
+ */
+declare class AppServicesFacade {
+    /**
+     * Registers a service for your application.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @param factory - Optional factory function for creating instances
+     * @throws Error if token is null or undefined
+     *
+     * @example
+     * ```typescript
+     * // Auto-instantiate with no-args constructor
+     * AppServices.provide(LoggerService);
+     *
+     * // Custom factory with dependencies
+     * AppServices.provide(TodoService, () => {
+     *   const logger = AppServices.get(LoggerService);
+     *   const http = AppServices.get(HttpService);
+     *   return new TodoService(logger, http);
+     * });
+     *
+     * // Using string token
+     * AppServices.provide('ILogger', () => new ConsoleLogger());
+     * ```
+     */
+    provide<T>(token: ServiceToken, factory?: () => T): void;
+    /**
+     * Registers a singleton instance (created immediately).
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @param instance - Pre-created instance
+     * @throws Error if token or instance is null or undefined
+     *
+     * @example
+     * ```typescript
+     * const config = new ConfigService({ api: '/api' });
+     * AppServices.provideSingleton(ConfigService, config);
+     *
+     * // Using string token
+     * AppServices.provideSingleton('IConfig', config);
+     * ```
+     */
+    provideSingleton<T>(token: ServiceToken, instance: T): void;
+    /**
+     * Retrieves a service instance.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @returns Service instance
+     * @throws Error if service is not registered
+     *
+     * @example
+     * ```typescript
+     * const logger = AppServices.get(LoggerService);
+     * logger.info('Application started');
+     *
+     * // Using string token
+     * const logger = AppServices.get<ILogger>('ILogger');
+     * ```
+     */
+    get<T>(token: ServiceToken<T>): T;
+    /**
+     * Checks if a service is registered.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @returns true if service is registered, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (AppServices.has(LoggerService)) {
+     *   const logger = AppServices.get(LoggerService);
+     *   logger.info('Logger available');
+     * }
+     * ```
+     */
+    has(token: ServiceToken): boolean;
+}
+/**
+ * Application Services facade instance.
+ * Use this for registering and resolving application services.
+ *
+ * @example
+ * ```typescript
+ * // composition-root.ts
+ * import { AppServices } from '@smartcomponents/core';
+ *
+ * // Register services
+ * AppServices.provide(LoggerService);
+ * AppServices.provide(TodoService, () => {
+ *   const logger = AppServices.get(LoggerService);
+ *   return new TodoService(logger);
+ * });
+ *
+ * // Use in components
+ * @SmartRender({ selector: 'todo-list' })
+ * class TodoList extends SmartComponent {
+ *   private todoService = AppServices.get(TodoService);
+ * }
+ * ```
+ */
+export declare const AppServices: AppServicesFacade;
+//# sourceMappingURL=app-services.d.ts.map

package/dist/providers/app-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-services.d.ts","sourceRoot":"","sources":["../../src/providers/app-services.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AACpE,YAAY,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,cAAM,iBAAiB;IACrB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,OAAO,CAAC,CAAC,EACP,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,MAAM,CAAC,GAChB,IAAI;IA0BP;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI;IAe3D;;;;;;;;;;;;;;;OAeG;IACH,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC;IASjC;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO;CAQlC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,mBAA0B,CAAC"}

package/dist/providers/app-services.js

@@ -0,0 +1,174 @@
+import { Services } from './service-provider.js';
+/**
+ * Defines the responsibility of providing a simplified facade for application services.
+ *
+ * @description
+ * Application Services Facade for developers without external DI containers.
+ * Framework services use internal Services registry, application services use this facade.
+ *
+ * @architecture
+ * **Design Decisions:**
+ * - Facade pattern over Services for simplified developer API
+ * - Auto-instantiation for classes without factory
+ * - Singleton support for eager initialization
+ * - Type-safe token resolution (class, string, symbol)
+ *
+ * @example
+ * ```typescript
+ * // Simple service registration
+ * AppServices.provide(TodoService);
+ *
+ * // Service with dependencies
+ * AppServices.provide(TodoService, () => {
+ *   const http = AppServices.get(HttpService);
+ *   return new TodoService(http);
+ * });
+ *
+ * // Singleton instance
+ * AppServices.provideSingleton(ConfigService, new ConfigService({ api: '/api' }));
+ * ```
+ */
+class AppServicesFacade {
+    /**
+     * Registers a service for your application.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @param factory - Optional factory function for creating instances
+     * @throws Error if token is null or undefined
+     *
+     * @example
+     * ```typescript
+     * // Auto-instantiate with no-args constructor
+     * AppServices.provide(LoggerService);
+     *
+     * // Custom factory with dependencies
+     * AppServices.provide(TodoService, () => {
+     *   const logger = AppServices.get(LoggerService);
+     *   const http = AppServices.get(HttpService);
+     *   return new TodoService(logger, http);
+     * });
+     *
+     * // Using string token
+     * AppServices.provide('ILogger', () => new ConsoleLogger());
+     * ```
+     */
+    provide(token, factory) {
+        if (!token) {
+            throw new Error('Service token is required');
+        }
+        let resolvedFactory = factory;
+        // Auto-instantiate with no-args constructor if token is a class
+        if (!resolvedFactory && typeof token === 'function') {
+            resolvedFactory = () => new token();
+        }
+        if (!resolvedFactory) {
+            throw new Error(`[AppServices] Factory function is required for token '${String(token)}' ` +
+                `unless token is a class constructor`);
+        }
+        // Only string/symbol tokens are supported by Services.register for now
+        if (typeof token !== 'string' && typeof token !== 'symbol') {
+            throw new Error('Service registration requires string or symbol tokens, not constructor types');
+        }
+        Services.register(token, resolvedFactory);
+    }
+    /**
+     * Registers a singleton instance (created immediately).
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @param instance - Pre-created instance
+     * @throws Error if token or instance is null or undefined
+     *
+     * @example
+     * ```typescript
+     * const config = new ConfigService({ api: '/api' });
+     * AppServices.provideSingleton(ConfigService, config);
+     *
+     * // Using string token
+     * AppServices.provideSingleton('IConfig', config);
+     * ```
+     */
+    provideSingleton(token, instance) {
+        if (!token) {
+            throw new Error('Service token is required');
+        }
+        if (!instance) {
+            throw new Error('Service instance is required');
+        }
+        // Cast to string|symbol for Services.register (constructor tokens are not supported for singleton instances)
+        if (typeof token !== 'string' && typeof token !== 'symbol') {
+            throw new Error('Singleton instances require string or symbol tokens, not constructor types');
+        }
+        Services.register(token, instance);
+    }
+    /**
+     * Retrieves a service instance.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @returns Service instance
+     * @throws Error if service is not registered
+     *
+     * @example
+     * ```typescript
+     * const logger = AppServices.get(LoggerService);
+     * logger.info('Application started');
+     *
+     * // Using string token
+     * const logger = AppServices.get<ILogger>('ILogger');
+     * ```
+     */
+    get(token) {
+        if (typeof token !== 'string' && typeof token !== 'symbol') {
+            // Support constructor tokens by converting to string representation
+            const tokenName = typeof token === 'function' ? token.name : String(token);
+            return Services.get(tokenName);
+        }
+        return Services.get(token);
+    }
+    /**
+     * Checks if a service is registered.
+     *
+     * @param token - Service token (class, string, or symbol)
+     * @returns true if service is registered, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (AppServices.has(LoggerService)) {
+     *   const logger = AppServices.get(LoggerService);
+     *   logger.info('Logger available');
+     * }
+     * ```
+     */
+    has(token) {
+        if (typeof token !== 'string' && typeof token !== 'symbol') {
+            // Support constructor tokens by converting to string representation
+            const tokenName = typeof token === 'function' ? token.name : String(token);
+            return Services.has(tokenName);
+        }
+        return Services.has(token);
+    }
+}
+/**
+ * Application Services facade instance.
+ * Use this for registering and resolving application services.
+ *
+ * @example
+ * ```typescript
+ * // composition-root.ts
+ * import { AppServices } from '@smartcomponents/core';
+ *
+ * // Register services
+ * AppServices.provide(LoggerService);
+ * AppServices.provide(TodoService, () => {
+ *   const logger = AppServices.get(LoggerService);
+ *   return new TodoService(logger);
+ * });
+ *
+ * // Use in components
+ * @SmartRender({ selector: 'todo-list' })
+ * class TodoList extends SmartComponent {
+ *   private todoService = AppServices.get(TodoService);
+ * }
+ * ```
+ */
+export const AppServices = new AppServicesFacade();
+//# sourceMappingURL=app-services.js.map

package/dist/providers/app-services.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-services.js","sourceRoot":"","sources":["../../src/providers/app-services.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,iBAAiB;IACrB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,OAAO,CACL,KAAmB,EACnB,OAAiB;QAEjB,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC/C,CAAC;QAED,IAAI,eAAe,GAAG,OAAO,CAAC;QAE9B,gEAAgE;QAChE,IAAI,CAAC,eAAe,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;YACpD,eAAe,GAAG,GAAG,EAAE,CAAC,IAAK,KAAqB,EAAE,CAAC;QACvD,CAAC;QAED,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CACb,yDAAyD,MAAM,CAAC,KAAK,CAAC,IAAI;gBAC1E,qCAAqC,CACtC,CAAC;QACJ,CAAC;QAED,uEAAuE;QACvE,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC3D,MAAM,IAAI,KAAK,CAAC,8EAA8E,CAAC,CAAC;QAClG,CAAC;QACD,QAAQ,CAAC,QAAQ,CAAC,KAAgC,EAAE,eAAe,CAAC,CAAC;IACvE,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAI,KAAmB,EAAE,QAAW;QAClD,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;QAED,6GAA6G;QAC7G,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC3D,MAAM,IAAI,KAAK,CAAC,4EAA4E,CAAC,CAAC;QAChG,CAAC;QACD,QAAQ,CAAC,QAAQ,CAAC,KAAgC,EAAE,QAAQ,CAAC,CAAC;IAChE,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,GAAG,CAAI,KAAsB;QAC3B,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC3D,oEAAoE;YACpE,MAAM,SAAS,GAAG,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAE,KAAqC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC5G,OAAO,QAAQ,CAAC,GAAG,CAAI,SAAuC,CAAC,CAAC;QAClE,CAAC;QACD,OAAO,QAAQ,CAAC,GAAG,CAAI,KAAmC,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,KAAmB;QACrB,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC3D,oEAAoE;YACpE,MAAM,SAAS,GAAG,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAE,KAAqC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC5G,OAAO,QAAQ,CAAC,GAAG,CAAC,SAAoC,CAAC,CAAC;QAC5D,CAAC;QACD,OAAO,QAAQ,CAAC,GAAG,CAAC,KAAgC,CAAC,CAAC;IACxD,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,IAAI,iBAAiB,EAAE,CAAC"}

package/dist/providers/default-service-provider.d.ts

@@ -0,0 +1,57 @@
+import { IServiceRegistry, type ServiceToken } from "./service-provider.interface.js";
+/**
+ * Default Service Registry implementation.
+ *
+ * @description
+ * Simple Map-based registry for Composition Root pattern.
+ * Supports both direct instances and factory functions for lazy instantiation.
+ * Zero-dependency implementation.
+ *
+ * @remarks
+ * Factory functions enable:
+ * - Lazy instantiation (created on first access)
+ * - Circular dependency resolution
+ * - Dynamic dependency resolution
+ */
+export declare class DefaultServiceRegistry implements IServiceRegistry {
+    private services;
+    /**
+     * Registers a service instance or factory function
+     *
+     * @param token - Service identifier (class constructor or string)
+     * @param instanceOrFactory - Service instance or factory function
+     *
+     * @example
+     * ```typescript
+     * // Direct instance
+     * registry.register(TodoService, new TodoService());
+     *
+     * // Factory function (lazy)
+     * registry.register(TodoService, () => new TodoService());
+     *
+     * // With dependencies
+     * registry.register(TodoService, () => {
+     *   const http = registry.get(HttpService);
+     *   return new TodoService(http);
+     * });
+     * ```
+     */
+    register<T>(token: ServiceToken<T>, instanceOrFactory: T | (() => T)): void;
+    /**
+     * Retrieves a service instance by token
+     *
+     * @description
+     * If the registered value is a factory function, it will be invoked
+     * and the result returned. Otherwise, returns the instance directly.
+     *
+     * @param token - Service identifier
+     * @returns Service instance
+     * @throws Error if service is not registered
+     */
+    get<T>(token: ServiceToken<T>): T;
+    has(token: ServiceToken): boolean;
+    clear(): void;
+    get size(): number;
+    private getTokenName;
+}
+//# sourceMappingURL=default-service-provider.d.ts.map

package/dist/providers/default-service-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-service-provider.d.ts","sourceRoot":"","sources":["../../src/providers/default-service-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,KAAK,YAAY,EAClB,MAAM,iCAAiC,CAAC;AAEzC;;;;;;;;;;;;;GAaG;AACH,qBAAa,sBAAuB,YAAW,gBAAgB;IAC7D,OAAO,CAAC,QAAQ,CAA6C;IAE7D;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI;IAS3E;;;;;;;;;;OAUG;IACH,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC;IAqBjC,GAAG,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO;IAIjC,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,OAAO,CAAC,YAAY;CAWrB"}