{
  "version": 3,
  "sources": ["../../src/errors.ts", "../../src/DependencyInjection.ts"],
  "sourcesContent": ["/**\r\n * Global error handling for Relaxjs.\r\n * Register a handler with `onError()` to intercept errors before they throw.\r\n * Call `ctx.suppress()` in the handler to prevent the error from being thrown.\r\n *\r\n * @example\r\n * import { onError } from 'relaxjs';\r\n *\r\n * onError((error, ctx) => {\r\n *     logToService(error.message, error.context);\r\n *     showToast(error.message);\r\n *     ctx.suppress();\r\n * });\r\n */\r\n\r\n/**\r\n * Passed to error handlers to control error behavior.\r\n * Call `suppress()` to prevent the error from being thrown.\r\n */\r\nexport interface ErrorContext {\r\n    suppress(): void;\r\n}\r\n\r\n/**\r\n * Error with structured context for debugging.\r\n * The `context` record contains details like route name, component tag, route data.\r\n *\r\n * @example\r\n * onError((error, ctx) => {\r\n *     console.log(error.context.route);\r\n *     console.log(error.context.componentTagName);\r\n * });\r\n */\r\nexport class RelaxError extends Error {\r\n    constructor(\r\n        message: string,\r\n        public context: Record<string, unknown>,\r\n    ) {\r\n        super(message);\r\n    }\r\n}\r\n\r\n/** @internal */\r\ntype ErrorHandler = (error: RelaxError, ctx: ErrorContext) => void;\r\n\r\nlet handler: ErrorHandler | null = null;\r\n\r\n/**\r\n * Registers a global error handler for Relaxjs errors.\r\n * The handler receives the error and an `ErrorContext`.\r\n * Call `ctx.suppress()` to prevent the error from being thrown.\r\n * Only one handler can be active at a time; subsequent calls replace the previous handler.\r\n *\r\n * @example\r\n * onError((error, ctx) => {\r\n *     if (error.context.route === 'optional-panel') {\r\n *         ctx.suppress();\r\n *         return;\r\n *     }\r\n *     showErrorDialog(error.message);\r\n * });\r\n */\r\nexport function onError(fn: ErrorHandler) {\r\n    handler = fn;\r\n}\r\n\r\n/**\r\n * Reports an error through the global handler.\r\n * Returns the `RelaxError` if it should be thrown, or `null` if the handler suppressed it.\r\n * The caller is responsible for throwing the returned error.\r\n *\r\n * @param message - Human-readable error description\r\n * @param context - Structured data for debugging (route, component, params, cause, etc.)\r\n * @returns The error to throw, or `null` if suppressed\r\n *\r\n * @example\r\n * const error = reportError('Failed to load route component', {\r\n *     route: 'user',\r\n *     componentTagName: 'user-profile',\r\n *     routeData: { id: 123 },\r\n * });\r\n * if (error) throw error;\r\n */\r\nexport function reportError(message: string, context: Record<string, unknown>): RelaxError | null {\r\n    const error = new RelaxError(message, context);\r\n    if (handler) {\r\n        let suppressed = false;\r\n        const ctx: ErrorContext = {\r\n            suppress() { suppressed = true; },\r\n        };\r\n        handler(error, ctx);\r\n        if (suppressed) {\r\n            return null;\r\n        }\r\n    }\r\n    return error;\r\n}\r\n\r\n/**\r\n * Wraps an async function into a synchronous callback suitable for addEventListener.\r\n * Catches promise rejections and reports them through the global error handler.\r\n *\r\n * @param fn - Async function to wrap\r\n * @returns Synchronous function that can be passed to addEventListener\r\n *\r\n * @example\r\n * button.addEventListener('click', asyncHandler(async (e) => {\r\n *     await saveData();\r\n * }));\r\n *\r\n * @example\r\n * form.addEventListener('submit', asyncHandler(async (e) => {\r\n *     e.preventDefault();\r\n *     await submitForm();\r\n * }));\r\n */\r\nexport function asyncHandler<TArgs extends unknown[]>(\r\n    fn: (...args: TArgs) => Promise<void>,\r\n): (...args: TArgs) => void {\r\n    return function (this: any, ...args: TArgs) {\r\n        fn.call(this, ...args).catch((cause: unknown) => {\r\n            const error = reportError('Async callback failed', { cause });\r\n            if (error) throw error;\r\n        });\r\n    };\r\n}\r\n", "import { reportError } from './errors';\r\n\r\n/**\r\n * Generic constructor type used for dependency registration and injection.\r\n * Represents any class constructor that can be used with the DI container.\r\n *\r\n * @template T - The type of object the constructor creates\r\n *\r\n * @example\r\n * // Use with service registration\r\n * class UserService {}\r\n * const ctor: Constructor<UserService> = UserService;\r\n * serviceCollection.registerByType(ctor, { inject: [] });\r\n */\r\nexport type Constructor<T extends object = object> = new (...args: any[]) => T;\r\n\r\n/**\r\n * Controls how service instances are shared across the container hierarchy.\r\n * Used when registering services to define their lifetime behavior.\r\n *\r\n * - `global`: Single instance shared everywhere (singleton pattern)\r\n * - `closest`: New instance per container scope (scoped lifetime)\r\n *\r\n * @example\r\n * // Singleton service - same instance everywhere\r\n * serviceCollection.register(LoggerService, { scope: 'global', inject: [] });\r\n *\r\n * // Scoped service - new instance per scope\r\n * serviceCollection.register(RequestContext, { scope: 'closest', inject: [] });\r\n */\r\nexport type ServiceScope = 'global' | 'closest';\r\n\r\n/**\r\n * Configuration options for registering a service in the DI container.\r\n * Controls identification, lifetime, and dependency resolution.\r\n *\r\n * @example\r\n * // Register with constructor injection\r\n * const options: RegistrationOptions = {\r\n *     scope: 'global',\r\n *     inject: [DatabaseConnection, ConfigService]\r\n * };\r\n * serviceCollection.register(UserRepository, options);\r\n *\r\n * @example\r\n * // Register with property injection\r\n * const options: RegistrationOptions = {\r\n *     inject: [],\r\n *     properties: { logger: Logger, config: 'appConfig' }\r\n * };\r\n *\r\n * @example\r\n * // Register with a pre-created instance\r\n * const options: RegistrationOptions = {\r\n *     inject: [],\r\n *     instance: existingService\r\n * };\r\n */\r\nexport interface RegistrationOptions {\r\n    /** Service lifetime - 'global' for singleton, 'closest' for scoped */\r\n    scope?: ServiceScope;\r\n    /** Optional string key for resolving by name instead of type */\r\n    key?: string;\r\n    /** Pre-existing instance to use instead of creating new one */\r\n    instance?: unknown;\r\n    /** Types or keys for constructor parameters, in order */\r\n    inject: (string | Constructor)[];\r\n    /** Map of property names to their injection types/keys */\r\n    properties?: Record<string, string | Constructor>;\r\n}\r\n\r\n/**\r\n * Field decorator that injects a service from the global DI container.\r\n * The service is resolved when the class instance is created (not at class definition time),\r\n * so services must be registered before the first instance is created.\r\n *\r\n * Works with web components regardless of how they are created:\r\n * - By the browser (HTML parsing): services are resolved during construction\r\n * - By application code (`document.createElement` or `new`): same behavior\r\n * - Injected fields are available in `connectedCallback` and all lifecycle methods\r\n *\r\n * @example\r\n * // Using `@Inject` in a web component\r\n * class UserPanel extends HTMLElement {\r\n *     @Inject(UserService)\r\n *     private userService!: UserService;\r\n *\r\n *     connectedCallback() {\r\n *         // userService is already resolved and ready to use\r\n *         const user = this.userService.getCurrentUser();\r\n *         this.render(user);\r\n *     }\r\n * }\r\n *\r\n * @example\r\n * // Services must be registered before components are created.\r\n * // In your app entry point (e.g. main.ts):\r\n * serviceCollection.registerByType(UserService, { inject: [ApiClient] });\r\n * serviceCollection.registerByType(ApiClient, { inject: [] });\r\n *\r\n * // Now components can be created (by browser or code)\r\n * customElements.define('user-panel', UserPanel);\r\n */\r\nexport function Inject<T extends object>(typeOrKey: Constructor<T> | string) {\r\n    return (_: undefined, context: ClassFieldDecoratorContext) => {\r\n        return function(this: any) {\r\n            return container.resolve(typeOrKey);\r\n        };\r\n    };\r\n}\r\n\r\n// Temporary collector of property injections - cleared after registration\r\n//const propertyCollector = new WeakMap<object, Record<string, string>>();\r\n\r\n/**\r\n * Class decorator that registers a service in the global DI container.\r\n * Registration happens at class definition time (when the module loads),\r\n * so import the module before creating instances that depend on this service.\r\n *\r\n * For web components: use `@ContainerService` on services, not on the\r\n * components themselves. Components use `@Inject` to consume services.\r\n *\r\n * @param options - Registration configuration including scope and dependencies\r\n *\r\n * @example\r\n * // Register a service that components can inject\r\n * @ContainerService({ inject: [ApiClient] })\r\n * class UserService {\r\n *     constructor(private api: ApiClient) {}\r\n *     getCurrentUser() { return this.api.get('/user'); }\r\n * }\r\n *\r\n * // Component consumes the service\r\n * class UserPanel extends HTMLElement {\r\n *     @Inject(UserService)\r\n *     private userService!: UserService;\r\n * }\r\n *\r\n * @example\r\n * // Service with custom key for named resolution\r\n * @ContainerService({ key: 'primaryCache', scope: 'global', inject: [] })\r\n * class CacheService {}\r\n *\r\n * // Later resolve by key\r\n * const cache = container.resolve('primaryCache');\r\n */\r\nexport function ContainerService<T extends object>(\r\n    options?: RegistrationOptions\r\n) {\r\n    return (target: Constructor<T>) => {\r\n        const opts = options ?? {inject: []};\r\n\r\n        if (opts.key) {\r\n            serviceCollection.register(target, opts);\r\n        } else {\r\n            serviceCollection.registerByType(target, opts);\r\n        }\r\n    };\r\n}\r\n\r\n/**\r\n * Internal class representing a registered service's metadata.\r\n * Holds all information needed to create and configure service instances.\r\n *\r\n * @internal This is an implementation detail and should not be used directly.\r\n */\r\nclass Registration {\r\n    /**\r\n     * Creates a new registration record.\r\n     *\r\n     * @param classConstructor - The class constructor function\r\n     * @param scope - Instance sharing behavior\r\n     * @param inject - Constructor parameter dependencies\r\n     * @param properties - Property injection mappings\r\n     * @param key - Optional string identifier\r\n     * @param instance - Optional pre-created instance\r\n     */\r\n    constructor(\r\n        public classConstructor: Constructor,\r\n        public scope: ServiceScope,\r\n        public inject: (string | Constructor)[],\r\n        public properties: Record<string, string | Constructor> = {},\r\n        public key?: string,\r\n        public instance?: unknown\r\n    ) {}\r\n}\r\n\r\n/**\r\n * Registry that stores service registration metadata.\r\n * Use this to register services before they can be resolved by a ServiceContainer.\r\n *\r\n * Typically you'll use the global `serviceCollection` instance rather than creating your own.\r\n *\r\n * @example\r\n * // Register a service by type\r\n * serviceCollection.registerByType(LoggerService, { inject: [] });\r\n *\r\n * // Register with a string key\r\n * serviceCollection.register(CacheService, { key: 'cache', inject: [] });\r\n *\r\n * // Check if service is registered\r\n * const reg = serviceCollection.tryGet(LoggerService);\r\n * if (reg) {\r\n *     console.log('Logger is registered');\r\n * }\r\n */\r\nexport class ServiceCollection {\r\n    private servicesByKey = new Map<string, Registration>();\r\n    private servicesByType = new Map<Constructor, Registration>();\r\n\r\n    /**\r\n     * Registers a service with full configuration options.\r\n     * The service will be resolvable by both its class name and optional key.\r\n     *\r\n     * @param constructor - The service class constructor\r\n     * @param options - Registration configuration\r\n     */\r\n    register<T extends object>(constructor: Constructor<T>, options: RegistrationOptions): void {\r\n        this.validateRegistration(constructor, options);\r\n\r\n        const reg = new Registration(\r\n            constructor,\r\n            options.scope ?? 'global',\r\n            options.inject,\r\n            options.properties ?? {},\r\n            options.key,\r\n            options.instance\r\n        );\r\n\r\n        if (options.key) {\r\n            this.servicesByKey.set(options.key, reg);\r\n        }\r\n        this.servicesByType.set(constructor, reg);\r\n    }\r\n\r\n    /**\r\n     * Registers a service by its class type.\r\n     * The service will be resolvable by its class constructor.\r\n     *\r\n     * @param constructor - The service class constructor\r\n     * @param options - Optional registration configuration\r\n     */\r\n    registerByType<T extends object>(\r\n        constructor: Constructor<T>,\r\n        options?: RegistrationOptions\r\n    ): void {\r\n        if (options) this.validateRegistration(constructor, options);\r\n\r\n        const reg = new Registration(constructor, options?.scope ?? 'global', options?.inject ?? [], options?.properties, options?.key, options?.instance);\r\n        if (options?.key) {\r\n            this.servicesByKey.set(options.key, reg);\r\n        }\r\n        this.servicesByType.set(constructor, reg);\r\n    }\r\n\r\n    private validateRegistration<T extends object>(constructor: Constructor<T>, options: RegistrationOptions): void {\r\n        if (options.key) {\r\n            const existingByKey = this.servicesByKey.get(options.key);\r\n            if (existingByKey && existingByKey.classConstructor !== constructor) {\r\n                const error = reportError('Service key already registered to a different class', {\r\n                    key: options.key,\r\n                    existingClass: existingByKey.classConstructor.name,\r\n                    newClass: constructor.name,\r\n                });\r\n                if (error) throw error;\r\n            }\r\n        }\r\n\r\n        if (options.instance && options.inject.length > 0) {\r\n            const error = reportError('Service has both instance and inject (inject will be ignored)', {\r\n                service: constructor.name,\r\n            });\r\n            if (error) throw error;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Attempts to retrieve a service registration.\r\n     * Returns undefined if the service is not registered.\r\n     *\r\n     * @param key - Either a string key or class constructor\r\n     * @returns The registration or undefined\r\n     */\r\n    tryGet<T extends object>(key: string | Constructor<T>): Registration | undefined {\r\n        if (typeof key === 'string') {\r\n            return this.servicesByKey.get(key);\r\n        }\r\n        return this.servicesByType.get(key);\r\n    }\r\n\r\n    /**\r\n     * Retrieves a service registration or throws if not found.\r\n     *\r\n     * @param key - Either a string key or class constructor\r\n     * @returns The registration\r\n     * @throws Error if the service is not registered\r\n     */\r\n    get<T extends object>(key: string | Constructor<T>): Registration {\r\n        const reg = this.tryGet(key);\r\n        if (!reg) {\r\n            const service = typeof key === 'string' ? key : key.name;\r\n            const error = reportError(`Failed to resolve service '${service}'`, {\r\n                service,\r\n                registeredTypes: Array.from(this.servicesByType.keys()).map(c => c.name),\r\n                registeredKeys: Array.from(this.servicesByKey.keys()),\r\n            });\r\n            if (error) throw error;\r\n        }\r\n        return reg!;\r\n    }\r\n}\r\n\r\n/**\r\n * Internal storage for tracking injected fields during service resolution.\r\n * @internal\r\n */\r\nconst injectedFields = new WeakMap<object, Map<string, string>>();\r\n\r\n/**\r\n * IoC container that resolves and manages service instances.\r\n * Creates instances based on registrations in a ServiceCollection,\r\n * handling constructor injection, property injection, and lifetime management.\r\n *\r\n * Typically you'll use the global `container` instance rather than creating your own.\r\n *\r\n * @example\r\n * // Resolve a service by class\r\n * const logger = container.resolve(LoggerService);\r\n *\r\n * // Resolve by string key\r\n * const cache = container.resolve<CacheService>('primaryCache');\r\n *\r\n * @example\r\n * // Full setup workflow\r\n * serviceCollection.register(UserService, {\r\n *     inject: [DatabaseConnection],\r\n *     scope: 'global'\r\n * });\r\n *\r\n * const userService = container.resolve(UserService);\r\n */\r\nexport class ServiceContainer {\r\n    private instances = new Map<string | Constructor, any>();\r\n\r\n    /**\r\n     * Creates a new container backed by the given service collection.\r\n     *\r\n     * @param serviceCollection - The registry containing service registrations\r\n     */\r\n    constructor(private serviceCollection: ServiceCollection) {}\r\n\r\n    /**\r\n     * Resolves a service instance by class type or string key.\r\n     * Creates the instance if not already cached (for global scope).\r\n     * Handles constructor and property injection automatically.\r\n     *\r\n     * @param keyOrType - Either a string key or class constructor\r\n     * @returns The resolved service instance\r\n     * @throws Error if the service is not registered\r\n     *\r\n     * @example\r\n     * const service = container.resolve(MyService);\r\n     */\r\n    resolve<T extends object>(keyOrType: string | Constructor<T>): T {\r\n        if (this.instances.has(keyOrType)) {\r\n            return this.instances.get(keyOrType);\r\n        }\r\n\r\n        const registration = this.serviceCollection.get(keyOrType);\r\n        if (!registration) {\r\n            const name = typeof keyOrType === 'string' ? keyOrType : keyOrType.name;\r\n            const error = reportError(`Failed to resolve service '${name}'`, { service: name });\r\n            if (error) throw error;\r\n            return undefined as unknown as T;\r\n        }\r\n\r\n        if (registration.instance) {\r\n            const inst = registration.instance as T;\r\n            this.injectFields(inst, registration);\r\n            this.instances.set(keyOrType, inst);\r\n            return inst;\r\n        }\r\n\r\n        const instance = this.createInstance<T>(registration);\r\n        if (registration.scope === 'global') {\r\n            this.instances.set(keyOrType, instance);\r\n        }\r\n        this.injectFields(instance, registration);\r\n\r\n        return instance;\r\n    }\r\n\r\n    /**\r\n     * Creates a new instance of a service, resolving all constructor dependencies.\r\n     */\r\n    private createInstance<T extends object>(registration: Registration): T {\r\n        const constructor = registration.classConstructor as Constructor<T>;\r\n\r\n        const dependencies = registration.inject.map(dep => this.resolve(dep));\r\n        return new constructor(...dependencies);\r\n    }\r\n\r\n    /**\r\n     * Injects dependencies into instance properties based on registration config.\r\n     */\r\n    private injectFields<T extends object>(instance: T, registration: Registration): void {\r\n        for (const [fieldName, keyOrType] of Object.entries(registration.properties)) {\r\n            (instance as any)[fieldName] = this.resolve(keyOrType);\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Global service collection instance for registering services.\r\n * Use this to register services that can later be resolved by the container.\r\n *\r\n * @example\r\n * import { serviceCollection } from 'relaxjs';\r\n *\r\n * serviceCollection.register(MyService, { inject: [Dependency] });\r\n */\r\nexport const serviceCollection = new ServiceCollection();\r\n\r\n/**\r\n * Global service container instance for resolving dependencies.\r\n * Use this to obtain service instances with all dependencies injected.\r\n *\r\n * @example\r\n * import { container } from 'relaxjs';\r\n *\r\n * const service = container.resolve(MyService);\r\n */\r\nexport const container = new ServiceContainer(serviceCollection);"],
  "mappings": "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",
  "names": ["RelaxError", "message", "context", "handler", "reportError", "message", "context", "error", "RelaxError", "handler", "suppressed", "Inject", "typeOrKey", "_", "context", "container", "ContainerService", "options", "target", "opts", "serviceCollection", "Registration", "classConstructor", "scope", "inject", "properties", "key", "instance", "ServiceCollection", "constructor", "reg", "existingByKey", "error", "reportError", "service", "c", "ServiceContainer", "serviceCollection", "keyOrType", "registration", "name", "error", "reportError", "inst", "instance", "constructor", "dependencies", "dep", "fieldName", "ServiceCollection", "container"]
}