di-craft 0.0.17 → 0.0.18

package/README.md

@@ -30,6 +30,7 @@
 - [Core concepts](#core-concepts)
   - [Tokens](#tokens)
   - [Providers](#providers)
+  - [Annotation-based class providers](#annotation-based-class-providers)
   - [Optional dependencies](#optional-dependencies)
   - [Container](#container)
   - [Scopes](#scopes)
@@ -80,14 +81,17 @@ const users = container.get(USERS); // UserService, fully typed
 
 ## Philosophy
 
-Dependency injection without the magic — no decorators, no `reflect-metadata`, no
-framework coupling. You work with just **tokens**, **providers**, a **container**,
-**scopes**, and **cycle detection**.
+Dependency injection without hidden magic — no `reflect-metadata`, no runtime
+type guessing, and no framework coupling. You work with just **tokens**,
+**providers**, a **container**, **scopes**, and **cycle detection**. Standard
+JavaScript decorators are available as optional sugar for class providers, but
+they still use explicit tokens.
 
 ## Features
 
 - Zero runtime dependencies
 - Type-safe tokens and factories
+- Optional `@Injectable` annotation for class providers
 - Optional dependencies via `optional()`
 - Singleton, transient, and scoped lifetimes
 - Hierarchical child containers
@@ -147,6 +151,63 @@ provideFactory(HTTP, {
 The keys in `deps` become the keys of the object passed to `useFactory`, each
 resolved to its token's type.
 
+### Annotation-based class providers
+
+If you write services as classes, you can attach provider metadata to the class
+with standard JavaScript decorators, then turn the class into a normal provider
+with `provideInjectable`.
+
+`@Injectable(options)` marks a class as a provider for `options.token`.
+`deps` is an ordered list of constructor dependencies. `scope` and
+`onDispose` behave exactly like they do in `provideFactory`.
+
+```ts
+import {
+  Injectable,
+  Scopes,
+  createContainer,
+  createToken,
+  optional,
+  provideInjectable,
+  provideValue,
+} from "di-craft";
+
+const CONFIG = createToken<Config>("config");
+const LOGGER = createToken<Logger>("logger");
+const USERS = createToken<UserService>("users");
+
+@Injectable({
+  token: USERS,
+  deps: [LOGGER, optional(CONFIG)],
+  scope: Scopes.Scoped,
+})
+class UserService {
+  private readonly logger: Logger;
+  private readonly config: Config | undefined;
+
+  constructor(logger: Logger, config: Config | undefined) {
+    this.logger = logger;
+    this.config = config;
+  }
+}
+
+const container = createContainer([
+  provideValue(LOGGER, new Logger()),
+  provideInjectable(UserService),
+]);
+
+const users = container.get(USERS); // UserService
+```
+
+`@Injectable` is the only annotation needed for class injection. It produces a
+regular factory provider internally, so all existing container behavior still
+applies: optional dependencies, scopes, child containers, disposal hooks,
+overrides, and cycle detection.
+
+di-craft does not use `reflect-metadata` or parameter decorators. Constructor
+types are erased by JavaScript at runtime, so dependency tokens stay explicit
+instead of being guessed from TypeScript types.
+
 ### Optional dependencies
 
 Wrap a token with `optional` to mark a dependency as not required. When no
@@ -451,6 +512,8 @@ try {
 | `createToken<T>(name)`                     | Create a unique, typed token.                                                |
 | `provideValue(token, value)`               | Provider that returns an existing value.                                     |
 | `provideFactory(token, options)`           | Provider that builds a value via a factory.                                  |
+| `@Injectable(options)`                     | Mark a class as a token-backed injectable provider.                          |
+| `provideInjectable(class)`                 | Create a factory provider from an injectable class.                           |
 | `optional(token)`                          | Mark a dependency as optional (resolves to `undefined` when absent).         |
 | `createContainer(providers?)`              | Create a container, optionally seeded with providers.                        |
 | `createChildContainer(parent, providers?)` | Create a child container that inherits from `parent`.                        |

package/dist/index.d.mts

@@ -1,46 +1,106 @@
 //#region src/error/error.d.ts
+/**
+* Base class for all di-craft runtime errors.
+*/
 declare class DiError extends Error {
   constructor(message: string);
 }
 //#endregion
 //#region src/provider/errors.d.ts
+/**
+* Error thrown when a provider configuration cannot be used safely.
+*/
 declare class InvalidProviderError extends DiError {
   constructor(message: string);
 }
 //#endregion
 //#region src/scope/scope.d.ts
+/**
+* Built-in provider lifetimes.
+*/
 declare const Scopes: {
   readonly Singleton: "singleton";
   readonly Transient: "transient";
   readonly Scoped: "scoped";
 };
+/**
+* Provider lifetime.
+*
+* - `singleton`: one cached instance in the container that owns the provider.
+* - `scoped`: one cached instance in the container that resolves the provider.
+* - `transient`: a new instance for every resolution.
+*/
 type Scope = (typeof Scopes)[keyof typeof Scopes];
 //#endregion
 //#region src/token/types.d.ts
+/** A unique, typed key used to register and resolve a dependency. */
 type Token<T> = {
+  /**
+  * Runtime identity of the token.
+  *
+  * Tokens with the same name still have different identities.
+  */
   readonly id: symbol;
+  /**
+  * Human-readable name used in error messages and diagnostics.
+  */
   readonly name: string;
   readonly __type?: T;
 };
 //#endregion
 //#region src/token/token.d.ts
+/**
+* Creates a unique typed token.
+*
+* The `name` is used only for diagnostics. Token identity is unique per call,
+* so two tokens with the same name do not collide.
+*
+* @example
+* ```ts
+* const CONFIG = createToken<Config>("config");
+* ```
+*/
 declare const createToken: <T>(name: string) => Token<T>;
 //#endregion
 //#region src/provider/types.d.ts
+/**
+* A token wrapped as an optional dependency.
+*
+* Optional dependencies resolve to `undefined` when no provider is registered
+* in the container chain.
+*/
 type OptionalDependency<T> = {
   readonly token: Token<T>;
   readonly optional: true;
 };
+/**
+* A dependency accepted by factory providers and `container.get`.
+*/
 type Dependency<T> = Token<T> | OptionalDependency<T>;
 type DepsMap = Record<string, Dependency<unknown>>;
-type DependencyValue<TDep> = TDep extends OptionalDependency<infer T> ? T | undefined : TDep extends Token<infer T> ? T : never;
-type ResolveDeps<TDeps extends DepsMap> = { readonly [TKey in keyof TDeps]: DependencyValue<TDeps[TKey]> };
+type DependencyValue$1<TDep> = TDep extends OptionalDependency<infer T> ? T | undefined : TDep extends Token<infer T> ? T : never;
+type ResolveDeps<TDeps extends DepsMap> = { readonly [TKey in keyof TDeps]: DependencyValue$1<TDeps[TKey]> };
 type Factory<T, TDeps extends DepsMap> = (deps: ResolveDeps<TDeps>) => T;
+/**
+* Cleanup hook called for a cached instance during container disposal.
+*
+* Transient providers cannot use disposal hooks because their instances are not
+* cached or tracked by the container.
+*/
 type DisposeHook<T> = (instance: T) => void | Promise<void>;
+/**
+* Provider that resolves a token to an existing value.
+*/
 type ValueProvider<T> = {
   readonly provide: Token<T>;
   readonly useValue: T;
 };
+/**
+* Provider that lazily creates a token value from typed dependencies.
+*
+* `deps` keys become the properties passed to `useFactory`, `scope` controls
+* caching lifetime, and `onDispose` runs for cached singleton/scoped instances.
+*/
 type FactoryProvider<T, TDeps extends DepsMap = Record<never, never>> = {
   readonly provide: Token<T>;
   readonly deps?: TDeps;
@@ -49,50 +109,210 @@ type FactoryProvider<T, TDeps extends DepsMap = Record<never, never>> = {
   readonly onDispose?: DisposeHook<T>;
 };
 type AnyFactoryProvider = FactoryProvider<any, any>;
+/**
+* Provider accepted by `createContainer` and `container.register`.
+*/
 type Provider = ValueProvider<unknown> | AnyFactoryProvider;
 //#endregion
 //#region src/provider/provider.d.ts
+/**
+* Creates a provider for an already constructed value.
+*
+* The value must match the token type.
+*
+* @example
+* ```ts
+* provideValue(PORT, 3000);
+* ```
+*/
 declare const provideValue: <T>(token: Token<T>, useValue: T) => ValueProvider<T>;
+/**
+* Creates a provider that lazily builds a value.
+*
+* Dependencies declared in `deps` become the object passed to `useFactory`.
+* The factory return type must match the token type.
+*
+* @example
+* ```ts
+* provideFactory(HTTP, {
+*   deps: { config: CONFIG },
+*   useFactory: ({ config }) => new HttpClient(config.apiUrl),
+* });
+* ```
+*/
 declare const provideFactory: <T, TDeps extends DepsMap = Record<never, never>>(token: Token<T>, options: {
   readonly deps?: TDeps;
   readonly scope?: Scope;
   readonly useFactory: Factory<T, TDeps>;
   readonly onDispose?: DisposeHook<T>;
 }) => FactoryProvider<T, TDeps>;
+/**
+* Marks a token as optional.
+*
+* Optional dependencies resolve to `undefined` instead of throwing when no
+* provider exists in the container chain. They can be used in factory `deps`
+* or passed directly to `container.get`.
+*
+* @example
+* ```ts
+* const logger = container.get(optional(LOGGER));
+* ```
+*/
 declare const optional: <T>(token: Token<T>) => OptionalDependency<T>;
 //#endregion
+//#region src/annotation/types.d.ts
+type InjectableDeps = readonly Dependency<unknown>[];
+type DependencyValue<TDependency> = TDependency extends OptionalDependency<infer T> ? T | undefined : TDependency extends Token<infer T> ? T : never;
+type ResolveDependencyTuple<TDeps extends InjectableDeps> = { -readonly [TKey in keyof TDeps]: DependencyValue<TDeps[TKey]> };
+/**
+* Constructor type whose parameters match an injectable dependency tuple.
+*/
+type InjectableConstructor<T, TDeps extends InjectableDeps> = new (...args: ResolveDependencyTuple<TDeps>) => T;
+/**
+* Class that can be passed to `provideInjectable`.
+*
+* `never[]` keeps classes with required constructor parameters assignable
+* without claiming arbitrary constructor arguments are valid.
+*/
+type InjectableClass<T = unknown> = new (...args: never[]) => T;
+/**
+* Options stored by `@Injectable` and converted into a factory provider.
+*/
+type InjectableOptions<T, TDeps extends InjectableDeps = InjectableDeps> = {
+  /**
+  * Token provided by the decorated class.
+  */
+  readonly token: Token<T>;
+  /**
+  * Ordered constructor dependencies.
+  *
+  * Each item is resolved and passed to the constructor at the same index.
+  */
+  readonly deps?: TDeps;
+  /**
+  * Provider lifetime.
+  *
+  * Defaults to `Scopes.Singleton`.
+  */
+  readonly scope?: Scope;
+  /**
+  * Cleanup hook for cached singleton and scoped instances.
+  *
+  * Not supported for transient providers.
+  */
+  readonly onDispose?: DisposeHook<T>;
+};
+//#endregion
+//#region src/annotation/annotation.d.ts
+type InjectableDecorator<TTarget> = (target: TTarget, context: ClassDecoratorContext) => void;
+type InjectableOptionsWithoutDeps<T> = Omit<InjectableOptions<T, readonly []>, "deps">;
+declare function Injectable<T, const TDeps extends readonly Dependency<unknown>[]>(options: InjectableOptions<T, TDeps> & {
+  readonly deps: TDeps;
+}): InjectableDecorator<InjectableConstructor<T, TDeps>>;
+declare function Injectable<T>(options: InjectableOptionsWithoutDeps<T>): InjectableDecorator<InjectableConstructor<T, readonly []>>;
+/**
+* Creates a factory provider from a class marked with `@Injectable`.
+*
+* The returned provider is a normal di-craft factory provider, so scopes,
+* optional dependencies, disposal hooks, overrides, and cycle detection behave
+* the same as with `provideFactory`.
+*/
+declare function provideInjectable<T>(target: InjectableClass<T>): FactoryProvider<T, DepsMap>;
+//#endregion
 //#region src/registry/errors.d.ts
+/**
+* Error thrown when registering a provider for an already registered token.
+*/
 declare class DuplicateProviderError extends DiError {
   constructor(tokenName: string);
 }
 //#endregion
 //#region src/registry/types.d.ts
+/**
+* Options for provider registration.
+*/
 type RegisterOptions = {
+  /**
+  * Replace an existing provider for the same token.
+  *
+  * Overriding an already resolved disposable singleton is rejected to avoid
+  * dropping resources without running their cleanup hook.
+  */
   readonly allowOverride?: boolean;
 };
 //#endregion
 //#region src/container/types.d.ts
+/**
+* Container that stores providers and resolves typed dependencies.
+*/
 type Container = {
+  /**
+  * Registers a provider in this container.
+  *
+  * Pass `{ allowOverride: true }` to intentionally replace an existing
+  * provider for the same token.
+  */
   register(provider: Provider, options?: RegisterOptions): void;
+  /**
+  * Resolves a required token.
+  *
+  * Throws `MissingProviderError` when no provider exists in this container or
+  * any parent container.
+  */
   get<T>(token: Token<T>): T;
+  /**
+  * Resolves an optional dependency.
+  *
+  * Returns `undefined` when no provider exists in this container or any parent
+  * container.
+  */
   get<T>(dependency: OptionalDependency<T>): T | undefined;
+  /**
+  * Checks whether this container or one of its parents has a provider.
+  */
   has(token: Token<unknown>): boolean;
+  /**
+  * Disposes cached instances owned by this container.
+  *
+  * Disposal hooks run in reverse creation order. Calling `dispose` more than
+  * once is safe.
+  */
   dispose(): Promise<void>;
 };
 //#endregion
 //#region src/container/container.d.ts
+/**
+* Creates a root container with optional initial providers.
+*
+* Root containers own singleton instances for providers registered in them.
+*/
 declare const createContainer: (providers?: readonly Provider[]) => Container;
+/**
+* Creates a child container that can resolve providers from its parent.
+*
+* Child containers may register their own providers while still reusing parent
+* providers. Scoped providers create one cached instance per resolving child.
+*/
 declare const createChildContainer: (parent: Container, providers?: readonly Provider[]) => Container;
 //#endregion
 //#region src/resolver/errors.d.ts
+/**
+* Error thrown when resolving a token without a registered provider.
+*/
 declare class MissingProviderError extends DiError {
   constructor(tokenName: string);
 }
+/**
+* Error thrown when a dependency descriptor is invalid.
+*/
 declare class InvalidDependencyError extends DiError {
   constructor(dependencyKey: string);
 }
+/**
+* Error thrown when provider dependencies form a cycle.
+*/
 declare class CircularDependencyError extends DiError {
   constructor(tokenNames: string[]);
 }
 //#endregion
-export { CircularDependencyError, type Container, type Dependency, DiError, type DisposeHook, DuplicateProviderError, type FactoryProvider, InvalidDependencyError, InvalidProviderError, MissingProviderError, type OptionalDependency, type Provider, type RegisterOptions, type Scope, Scopes, type Token, type ValueProvider, createChildContainer, createContainer, createToken, optional, provideFactory, provideValue };
+export { CircularDependencyError, type Container, type Dependency, DiError, type DisposeHook, DuplicateProviderError, type FactoryProvider, Injectable, InvalidDependencyError, InvalidProviderError, MissingProviderError, type OptionalDependency, type Provider, type RegisterOptions, type Scope, Scopes, type Token, type ValueProvider, createChildContainer, createContainer, createToken, optional, provideFactory, provideInjectable, provideValue };

package/dist/index.mjs

@@ -1,267 +1 @@
-//#region src/error/error.ts
-var DiError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "DiError";
-		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-	}
-};
-
-//#endregion
-//#region src/provider/errors.ts
-var InvalidProviderError = class extends DiError {
-	constructor(message) {
-		super(message);
-		this.name = "InvalidProviderError";
-	}
-};
-
-//#endregion
-//#region src/scope/scope.ts
-const Scopes = {
-	Singleton: "singleton",
-	Transient: "transient",
-	Scoped: "scoped"
-};
-
-//#endregion
-//#region src/provider/provider.ts
-const provideValue = (token, useValue) => ({
-	provide: token,
-	useValue
-});
-const provideFactory = (token, options) => {
-	if (options.scope === Scopes.Transient && options.onDispose) throw new InvalidProviderError(`onDispose is not supported for transient providers (token "${token.name}"): transient instances are not tracked, so the hook would never run.`);
-	return {
-		provide: token,
-		useFactory: options.useFactory,
-		scope: options.scope ?? Scopes.Singleton,
-		...options.deps ? { deps: options.deps } : {},
-		...options.onDispose ? { onDispose: options.onDispose } : {}
-	};
-};
-const optional = (token) => ({
-	token,
-	optional: true
-});
-const isOptionalDependency = (dependency) => {
-	return dependency.optional === true;
-};
-const isValueProvider = (provider) => {
-	return "useValue" in provider;
-};
-
-//#endregion
-//#region src/registry/errors.ts
-var DuplicateProviderError = class extends DiError {
-	constructor(tokenName) {
-		super(`Provider for token "${tokenName}" is already registered`);
-		this.name = "DuplicateProviderError";
-	}
-};
-
-//#endregion
-//#region src/registry/registry.ts
-var RegistryClass = class {
-	providers = /* @__PURE__ */ new Map();
-	register(provider, options) {
-		const existed = this.providers.has(provider.provide.id);
-		if (existed && !options?.allowOverride) throw new DuplicateProviderError(provider.provide.name);
-		this.providers.set(provider.provide.id, provider);
-		return existed;
-	}
-	get(token) {
-		return this.providers.get(token.id);
-	}
-	has(token) {
-		return this.providers.has(token.id);
-	}
-};
-const createRegistry = () => new RegistryClass();
-
-//#endregion
-//#region src/resolver/errors.ts
-var MissingProviderError = class extends DiError {
-	constructor(tokenName) {
-		super(`Provider for token "${tokenName}" is not registered`);
-		this.name = "MissingProviderError";
-	}
-};
-var InvalidDependencyError = class extends DiError {
-	constructor(dependencyKey) {
-		super(`Invalid dependency "${dependencyKey}"`);
-		this.name = "InvalidDependencyError";
-	}
-};
-var CircularDependencyError = class extends DiError {
-	constructor(tokenNames) {
-		super(`Circular dependency detected: ${tokenNames.join(" -> ")}`);
-		this.name = "CircularDependencyError";
-	}
-};
-
-//#endregion
-//#region src/store/store.ts
-var StoreClass = class {
-	instances = /* @__PURE__ */ new Map();
-	get(token) {
-		return this.instances.get(token.id);
-	}
-	set(token, record) {
-		this.instances.set(token.id, record);
-	}
-	delete(token) {
-		this.instances.delete(token.id);
-	}
-	async dispose() {
-		const records = [...this.instances.values()].reverse();
-		this.instances.clear();
-		for (const record of records) if (record.onDispose) await record.onDispose(record.value);
-	}
-};
-const createStore = () => new StoreClass();
-
-//#endregion
-//#region src/resolver/context.ts
-var ResolutionContext = class {
-	resolving = /* @__PURE__ */ new Set();
-	path = [];
-	enter(token) {
-		if (this.resolving.has(token.id)) {
-			const cycleStartIndex = this.path.findIndex((pathToken) => pathToken.id === token.id);
-			throw new CircularDependencyError([...this.path.slice(cycleStartIndex), token].map((cycleToken) => cycleToken.name));
-		}
-		this.resolving.add(token.id);
-		this.path.push(token);
-	}
-	exit(token) {
-		this.path.pop();
-		this.resolving.delete(token.id);
-	}
-};
-
-//#endregion
-//#region src/resolver/resolver.ts
-const lifetimeRank = (scope) => scope === Scopes.Scoped ? 1 : scope === Scopes.Transient ? 2 : 0;
-var ResolverClass = class {
-	registry;
-	store = createStore();
-	parent;
-	constructor(registry, parent) {
-		this.registry = registry;
-		this.parent = parent;
-	}
-	resolve(token) {
-		return this.resolveToken(token, void 0);
-	}
-	resolveOptional(token) {
-		return this.lookupOptional(token, void 0);
-	}
-	invalidate(token) {
-		this.store.delete(token);
-	}
-	hasDisposableInstance(token) {
-		return this.store.get(token)?.onDispose !== void 0;
-	}
-	dispose() {
-		return this.store.dispose();
-	}
-	resolveToken(token, context, consumerScope, consumerName) {
-		let owner = this;
-		let provider;
-		while (owner) {
-			provider = owner.registry.get(token);
-			if (provider) break;
-			owner = owner.parent;
-		}
-		if (!provider || !owner) throw new MissingProviderError(token.name);
-		if (isValueProvider(provider)) return provider.useValue;
-		if (consumerScope !== void 0 && lifetimeRank(provider.scope) > lifetimeRank(consumerScope)) throw new InvalidProviderError(`"${consumerName}" (${consumerScope}) cannot depend on "${token.name}" (${provider.scope ?? Scopes.Singleton}): a longer-lived provider would capture a shorter-lived one. Widen the dependency's scope or narrow the consumer's.`);
-		const host = this.selectHost(provider.scope, owner);
-		if (host) {
-			const cached = host.store.get(token);
-			if (cached) return cached.value;
-		}
-		const ctx = context ?? new ResolutionContext();
-		ctx.enter(token);
-		try {
-			const deps = (host ?? this).resolveDeps(provider.deps, ctx, provider.scope, token.name);
-			const value = provider.useFactory(deps);
-			if (host) host.store.set(token, {
-				value,
-				...provider.onDispose ? { onDispose: provider.onDispose } : {}
-			});
-			return value;
-		} finally {
-			ctx.exit(token);
-		}
-	}
-	selectHost(scope, owner) {
-		if (scope === Scopes.Transient) return;
-		if (scope === Scopes.Scoped) return this;
-		return owner;
-	}
-	resolveDeps(deps, context, consumerScope, consumerName) {
-		if (!deps) return {};
-		const resolvedDeps = {};
-		for (const key of Object.keys(deps)) {
-			const dependency = deps[key];
-			if (dependency === void 0) throw new InvalidDependencyError(String(key));
-			resolvedDeps[key] = isOptionalDependency(dependency) ? this.lookupOptional(dependency.token, context, consumerScope, consumerName) : this.resolveToken(dependency, context, consumerScope, consumerName);
-		}
-		return resolvedDeps;
-	}
-	lookupOptional(token, context, consumerScope, consumerName) {
-		let owner = this;
-		while (owner) {
-			if (owner.registry.has(token)) return this.resolveToken(token, context, consumerScope, consumerName);
-			owner = owner.parent;
-		}
-	}
-};
-const createResolver = (registry, parent) => new ResolverClass(registry, parent);
-
-//#endregion
-//#region src/container/container.ts
-var ContainerClass = class {
-	registry;
-	resolver;
-	parent;
-	constructor(providers = [], parent) {
-		this.parent = parent;
-		this.registry = createRegistry();
-		for (const provider of providers) this.registry.register(provider);
-		this.resolver = createResolver(this.registry, parent?.resolver);
-	}
-	register(provider, options) {
-		if (options?.allowOverride && this.resolver.hasDisposableInstance(provider.provide)) throw new InvalidProviderError(`Cannot override token "${provider.provide.name}": its instance was already created and has an onDispose hook. Dispose the container before replacing it.`);
-		if (this.registry.register(provider, options)) this.resolver.invalidate(provider.provide);
-	}
-	get(dependency) {
-		if (isOptionalDependency(dependency)) return this.resolver.resolveOptional(dependency.token);
-		return this.resolver.resolve(dependency);
-	}
-	has(token) {
-		return this.registry.has(token) || (this.parent?.has(token) ?? false);
-	}
-	dispose() {
-		return this.resolver.dispose();
-	}
-};
-const createContainer = (providers = []) => new ContainerClass(providers);
-const createChildContainer = (parent, providers = []) => new ContainerClass(providers, parent);
-
-//#endregion
-//#region src/token/token.ts
-var TokenClass = class {
-	name;
-	id;
-	constructor(name) {
-		this.name = name;
-		this.id = Symbol(name);
-	}
-};
-const createToken = (name) => new TokenClass(name);
-
-//#endregion
-export { CircularDependencyError, DiError, DuplicateProviderError, InvalidDependencyError, InvalidProviderError, MissingProviderError, Scopes, createChildContainer, createContainer, createToken, optional, provideFactory, provideValue };
+var e=class extends Error{constructor(e){super(e),this.name=`DiError`,Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)}},t=class extends e{constructor(e){super(e),this.name=`InvalidProviderError`}};const n={Singleton:`singleton`,Transient:`transient`,Scoped:`scoped`},r=(e,t)=>({provide:e,useValue:t}),i=(e,r)=>{if(r.scope===n.Transient&&r.onDispose)throw new t(`onDispose is not supported for transient providers (token "${e.name}"): transient instances are not tracked, so the hook would never run.`);return{provide:e,useFactory:r.useFactory,scope:r.scope??n.Singleton,...r.deps?{deps:r.deps}:{},...r.onDispose?{onDispose:r.onDispose}:{}}},a=e=>({token:e,optional:!0}),o=e=>e.optional===!0,s=e=>`useValue`in e,c=e=>{if(e.length!==0)return Object.fromEntries(e.entries())},l=new WeakMap,u=e=>l.get(e),d=e=>{l.set(e.target,e.metadata)},f=e=>{let{context:n,target:r}=e;if(!(n.kind===`class`&&typeof r==`function`))throw new t(`@Injectable can only decorate classes`)};function p(e){return(t,n)=>{f({target:t,context:n}),d({target:t,metadata:e})}}function m(e){let n=u(e);if(!n)throw new t(`Class "${e.name||`<anonymous>`}" is not marked as injectable. Add @Injectable({ token: TOKEN }) before calling provideInjectable().`);let{deps:r=[],onDispose:a,scope:o,token:s}=n,l=c(r),d=e;return i(s,{useFactory:e=>new d(...r.map((t,n)=>e[String(n)])),...l?{deps:l}:{},...o?{scope:o}:{},...a?{onDispose:a}:{}})}var h=class extends e{constructor(e){super(`Provider for token "${e}" is already registered`),this.name=`DuplicateProviderError`}},g=class{providers=new Map;register(e,t){let n=this.providers.has(e.provide.id);if(n&&!t?.allowOverride)throw new h(e.provide.name);return this.providers.set(e.provide.id,e),n}get(e){return this.providers.get(e.id)}has(e){return this.providers.has(e.id)}};const _=()=>new g;var v=class extends e{constructor(e){super(`Provider for token "${e}" is not registered`),this.name=`MissingProviderError`}},y=class extends e{constructor(e){super(`Invalid dependency "${e}"`),this.name=`InvalidDependencyError`}},b=class extends e{constructor(e){super(`Circular dependency detected: ${e.join(` -> `)}`),this.name=`CircularDependencyError`}},x=class{instances=new Map;get(e){return this.instances.get(e.id)}set(e,t){this.instances.set(e.id,t)}delete(e){this.instances.delete(e.id)}async dispose(){let e=[...this.instances.values()].reverse();this.instances.clear();for(let t of e)t.onDispose&&await t.onDispose(t.value)}};const S=()=>new x;var C=class{resolving=new Set;path=[];enter(e){if(this.resolving.has(e.id)){let t=this.path.findIndex(t=>t.id===e.id);throw new b([...this.path.slice(t),e].map(e=>e.name))}this.resolving.add(e.id),this.path.push(e)}exit(e){this.path.pop(),this.resolving.delete(e.id)}};const w=e=>e===n.Scoped?1:e===n.Transient?2:0;var T=class{registry;store=S();parent;constructor(e,t){this.registry=e,this.parent=t}resolve(e){return this.resolveToken(e,void 0)}resolveOptional(e){return this.lookupOptional(e,void 0)}invalidate(e){this.store.delete(e)}hasDisposableInstance(e){return this.store.get(e)?.onDispose!==void 0}dispose(){return this.store.dispose()}resolveToken(e,r,i,a){let o=this,c;for(;o&&(c=o.registry.get(e),!c);)o=o.parent;if(!c||!o)throw new v(e.name);if(s(c))return c.useValue;if(i!==void 0&&w(c.scope)>w(i))throw new t(`"${a}" (${i}) cannot depend on "${e.name}" (${c.scope??n.Singleton}): a longer-lived provider would capture a shorter-lived one. Widen the dependency's scope or narrow the consumer's.`);let l=this.selectHost(c.scope,o);if(l){let t=l.store.get(e);if(t)return t.value}let u=r??new C;u.enter(e);try{let t=(l??this).resolveDeps(c.deps,u,c.scope,e.name),n=c.useFactory(t);return l&&l.store.set(e,{value:n,...c.onDispose?{onDispose:c.onDispose}:{}}),n}finally{u.exit(e)}}selectHost(e,t){if(e!==n.Transient)return e===n.Scoped?this:t}resolveDeps(e,t,n,r){if(!e)return{};let i={};for(let a of Object.keys(e)){let s=e[a];if(s===void 0)throw new y(String(a));i[a]=o(s)?this.lookupOptional(s.token,t,n,r):this.resolveToken(s,t,n,r)}return i}lookupOptional(e,t,n,r){let i=this;for(;i;){if(i.registry.has(e))return this.resolveToken(e,t,n,r);i=i.parent}}};const E=(e,t)=>new T(e,t);var D=class{registry;resolver;parent;constructor(e=[],t){this.parent=t,this.registry=_();for(let t of e)this.registry.register(t);this.resolver=E(this.registry,t?.resolver)}register(e,n){if(n?.allowOverride&&this.resolver.hasDisposableInstance(e.provide))throw new t(`Cannot override token "${e.provide.name}": its instance was already created and has an onDispose hook. Dispose the container before replacing it.`);this.registry.register(e,n)&&this.resolver.invalidate(e.provide)}get(e){return o(e)?this.resolver.resolveOptional(e.token):this.resolver.resolve(e)}has(e){return this.registry.has(e)||(this.parent?.has(e)??!1)}dispose(){return this.resolver.dispose()}};const O=(e=[])=>new D(e),k=(e,t=[])=>new D(t,e);var A=class{name;id;constructor(e){this.name=e,this.id=Symbol(e)}};const j=e=>new A(e);export{b as CircularDependencyError,e as DiError,h as DuplicateProviderError,p as Injectable,y as InvalidDependencyError,t as InvalidProviderError,v as MissingProviderError,n as Scopes,k as createChildContainer,O as createContainer,j as createToken,a as optional,i as provideFactory,m as provideInjectable,r as provideValue};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "di-craft",
-	"version": "0.0.17",
+	"version": "0.0.18",
 	"description": "A tiny, type-safe dependency injection container for TypeScript",
 	"license": "MIT",
 	"author": {