ts-ioc-container 72.0.0 → 72.2.0

package/typings/hooks/injectProp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectProp.d.ts","sourceRoot":"","sources":["../../lib/hooks/injectProp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAE1C;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GACpB,CAAC,EAAE,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAG,MAEG,CAAC"}

package/typings/index.d.ts

@@ -17,6 +17,7 @@ export { DependencyMissingKeyError } from './errors/DependencyMissingKeyError.js
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError.js';
 export { ContainerDisposedError } from './errors/ContainerDisposedError.js';
 export { ProviderDisposedError } from './errors/ProviderDisposedError.js';
+export { CannotApplySingletonTwiceError } from './errors/CannotApplySingletonTwiceError.js';
 export { CannonSingletonApplyTwiceError } from './errors/CannonSingletonApplyTwiceError.js';
 export { UnsupportedTokenTypeError } from './errors/UnsupportedTokenTypeError.js';
 export { TypedEventDisposedError } from './errors/TypedEventDisposedError.js';
@@ -36,9 +37,9 @@ export { FunctionToken } from './token/FunctionToken.js';
 export { ConstantToken } from './token/ConstantToken.js';
 export { type InstancePredicate, GroupInstanceToken } from './token/GroupInstanceToken.js';
 export { resolveConstructor } from './metadata/target.js';
-export { addClassMeta, getClassMeta, addClassLabel, getClassLabels, addClassTag, getClassTags } from './metadata/class.js';
-export { addParamMeta, getParamMeta, addParamLabel, getParamLabels, addParamTag, getParamTags, } from './metadata/parameter.js';
-export { addMethodMeta, getMethodMeta, addMethodLabel, getMethodLabels, addMethodTag, getMethodTags, } from './metadata/method.js';
+export { addClassMeta, getClassMeta, addClassLabel, getClassLabels, addClassTag, getClassTags, createComposeClassDecorator, } from './metadata/class.js';
+export { addParamMeta, getParamMeta, addParamLabel, getParamLabels, addParamTag, getParamTags, createComposeParameterDecorator, } from './metadata/parameter.js';
+export { addMethodMeta, getMethodMeta, addMethodLabel, getMethodLabels, addMethodTag, getMethodTags, createComposeMethodDecorator, } from './metadata/method.js';
 export { handleError, handleAsyncError, type HandleErrorParams } from './utils/errorHandler.js';
 export { runInOrder, runAtOnce, type Task } from './utils/task.js';
 export { throttle } from './utils/throttle.js';
@@ -54,3 +55,4 @@ export { pipe, type MapFn } from './utils/fp.js';
 export { findOrFail, type Predicate } from './utils/array.js';
 export { ProxyRegistry, unwrapProxy, type IProxyRegistry } from './utils/ProxyRegistry.js';
 export { type Branded, type constructor, type Instance, type Serializable, Is, isSerializable } from './utils/basic.js';
+//# sourceMappingURL=index.d.ts.map

package/typings/index.d.ts.map

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

package/typings/injector/IInjector.d.ts

@@ -8,24 +8,56 @@ export type WithScope = {
 export type WithArgs = {
     args: unknown[];
 };
+/**
+ * What an injector needs to build an instance: the scope it is built in, plus
+ * the runtime `args`. The scope travels inside the options rather than beside
+ * them, so every function handed a resolution context - `InjectFn`, `ArgsFn`,
+ * `ResolveDependency`, `IProvider.resolve`, `IInjector.resolve` - takes one
+ * object and destructures what it uses.
+ */
 export type InjectOptions = WithScope & Partial<WithArgs>;
+/**
+ * Injector hooks - the injector's own domain: an instance was constructed.
+ *
+ * Construction is the injector's business, so the hook list belongs to the
+ * injector rather than to a scope. One injector is shared by a container and
+ * every scope created from it, so a hook added here observes construction in
+ * all of them.
+ */
 export type InjectorHook = (instance: Instance, scope: IContainer) => void;
+/** Builds instances of classes for a scope. Shared by a container and every scope created from it. */
 export interface IInjector {
     resolve<T>(Target: constructor<T>, options: ProviderOptions): T;
     onConstructed(...hooks: InjectorHook[]): this;
 }
+/**
+ * The injector counterpart of `IContainerModule`: an opt-in bundle of injector
+ * hooks, applied to the injector before it is handed to a container.
+ */
 export interface IInjectorModule {
     applyTo(injector: IInjector): void;
 }
+/** Something that resolves a value from a scope. */
 export interface IInjectFnResolver<T> {
     resolve(s: IContainer, options?: ResolveOneOptions): T;
 }
+/**
+ * Base class of the bundled injectors: tracks the instance in the scope, runs
+ * `onConstructed` hooks and handles `lazy`. Subclass it and implement
+ * `createInstance` for a custom injection strategy.
+ */
 export declare abstract class Injector {
     private readonly proxyRegistry;
     private readonly onConstructedHookList;
     constructor(proxyRegistry?: IProxyRegistry);
     resolve<T>(Target: constructor<T>, { scope, args, lazy }: ProviderOptions): T;
+    /**
+     * Hooks run after the constructed instance is handed to the scope, and before
+     * it reaches the caller. A `lazy` resolve returns a proxy first, so its hooks
+     * run when the proxy is first touched.
+     */
     onConstructed(...hooks: InjectorHook[]): this;
     useModule(module: IInjectorModule): this;
     protected abstract createInstance<T>(Target: constructor<T>, options: InjectOptions): T;
 }
+//# sourceMappingURL=IInjector.d.ts.map

package/typings/injector/IInjector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IInjector.d.ts","sourceRoot":"","sources":["../../lib/injector/IInjector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,KAAK,cAAc,EAAiB,MAAM,wBAAwB,CAAC;AAC5E,OAAO,EAAE,KAAK,WAAW,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE5D,MAAM,MAAM,SAAS,GAAG;IAAE,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC;AAC9C,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,CAAC;AAC3C;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;AAE3E,sGAAsG;AACtG,MAAM,WAAW,SAAS;IACxB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,eAAe,GAAG,CAAC,CAAC;IAEhE,aAAa,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAC;CACpC;AAED,oDAAoD;AACpD,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,CAAC,CAAC;CACxD;AAED;;;;GAIG;AACH,8BAAsB,QAAQ;IAGhB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAF1C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAsB;gBAE/B,aAAa,GAAE,cAA4C;IAExF,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,eAAe,GAAG,CAAC;IAe7E;;;;OAIG;IACH,aAAa,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI;IAK7C,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI;IAKxC,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,GAAG,CAAC;CACxF"}

package/typings/injector/MetadataInjector.d.ts

@@ -4,12 +4,70 @@ import { ProviderOptions } from '../provider/IProvider.js';
 import { InjectFn } from '../hooks/hook.js';
 import { type DependencyKey } from '../container/IContainer.js';
 import { type InjectionToken } from '../token/InjectionToken.js';
+/**
+ * The default injector: builds a class by calling each constructor parameter's
+ * `@inject(...)` function. Parameters without `@inject` receive `undefined`.
+ * Needs `reflect-metadata` imported once at the entrypoint.
+ *
+ * @example
+ * const container = new Container({ injector: new MetadataInjector() });
+ */
 export declare class MetadataInjector extends Injector implements IInjector {
     protected createInstance<T>(Target: constructor<T>, { scope, args: deps }: InjectOptions): T;
 }
+/**
+ * Injects a dependency into a constructor parameter.
+ *
+ * `fn` receives the resolution context - the `scope` the instance is built in and
+ * the runtime `args` it is built with - and returns the value to inject. That is
+ * the whole contract: a token, key or class is resolved with {@link by}, a
+ * runtime argument picked with {@link arg}, and a mapped value is
+ * `pipe(fn, ...mappers)`.
+ *
+ * @example
+ * class App {
+ *   constructor(
+ *     @inject(by(ILoggerToken)) private logger: ILogger,
+ *     @inject(pipe(by(ConfigToken), (c) => c.apiUrl)) private apiUrl: string,
+ *     @inject(arg(0)) private tenantId: string,
+ *   ) {}
+ * }
+ */
 export declare function inject<T>(fn: InjectFn<T>): ParameterDecorator;
+/**
+ * The `InjectFn` which resolves `target` - an `InjectionToken`, a `DependencyKey`
+ * or a class - from the scope, handing it the runtime args of the class being
+ * constructed (see "Runtime args flow through tokens" in the README) and the
+ * `lazy` flag: `@inject(by(Token))`, `@inject(by('key'))`, `@inject(by(Logger))`.
+ * Being a function, it composes: `pipe(by(Config), (c) => c.apiUrl)`.
+ *
+ * @throws {UnsupportedTokenTypeError} when `target` is none of the three.
+ */
 export declare const by: <T>(target: InjectionToken<T> | DependencyKey | constructor<T>) => InjectFn<T>;
+/**
+ * Injects the first runtime arg matching `predicate`, or `undefined`.
+ *
+ * @example
+ * constructor(@inject(argsFn((value) => typeof value === 'string')) readonly name: string) {}
+ */
 export declare const argsFn: <T = unknown>(predicate: (value: unknown, index: number) => boolean) => InjectFn<T>;
+/**
+ * Injects the runtime arg at `index`, or `undefined`. Args arrive as passed:
+ * a token in the args list is not resolved.
+ *
+ * @example
+ * constructor(@inject(arg(0)) readonly baseUrl: string) {}
+ * // Token.args('https://api.example.com').resolve(scope)
+ */
 export declare const arg: <T = unknown>(index: number) => InjectFn<T>;
+/** Injects the whole runtime args array. */
 export declare const args: InjectFn<unknown[]>;
+/**
+ * Resolves the arguments annotated with `@inject` on `target`'s constructor, or on
+ * its `methodName` method, by calling each parameter's `InjectFn` with `options`.
+ *
+ * `target` is the class or any instance of it - a proxy included, since it is
+ * unwrapped on the way to the metadata (see {@link resolveConstructor}).
+ */
 export declare const resolveArgs: (target: constructor<unknown> | Instance, methodName?: string) => (options: ProviderOptions) => unknown[];
+//# sourceMappingURL=MetadataInjector.d.ts.map

package/typings/injector/MetadataInjector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataInjector.d.ts","sourceRoot":"","sources":["../../lib/injector/MetadataInjector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAGjE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAG9D;;;;;;;GAOG;AACH,qBAAa,gBAAiB,SAAQ,QAAS,YAAW,SAAS;IACjE,SAAS,CAAC,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAS,EAAE,EAAE,aAAa,GAAG,CAAC;CAIlG;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAI7D;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,QAAQ,cAAc,CAAC,CAAC,CAAC,GAAG,aAAa,GAAG,WAAW,CAAC,CAAC,CAAC,KAAG,QAAQ,CAAC,CAAC,CAG5F,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAChB,CAAC,GAAG,OAAO,EAAE,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,KAAG,QAAQ,CAAC,CAAC,CAErB,CAAC;AAE9D;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,GAAG,OAAO,EAAE,OAAO,MAAM,KAAG,QAAQ,CAAC,CAAC,CAAyC,CAAC;AAErG,4CAA4C;AAC5C,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAE,CAA2B,CAAC;AAEjE;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,WAAW,CAAC,OAAO,CAAC,GAAG,QAAQ,EAAE,aAAa,MAAM,MAE9E,SAAS,eAAe,KAAG,OAAO,EAC3C,CAAC"}

package/typings/injector/ProxyInjector.d.ts

@@ -1,5 +1,18 @@
 import { IInjector, InjectOptions, Injector } from './IInjector.js';
 import { type constructor } from '../utils/basic.js';
+/**
+ * Injector that passes one proxy object as the first constructor argument:
+ * reading `deps.someKey` resolves `'someKey'`, a property name containing
+ * "alias" resolves by alias, and `deps.args` returns the runtime args. Needs no
+ * decorators or `reflect-metadata`.
+ *
+ * @example
+ * class App {
+ *   constructor({ logger }: { logger: ILogger }) {}
+ * }
+ * new Container({ injector: new ProxyInjector() });
+ */
 export declare class ProxyInjector extends Injector implements IInjector {
     protected createInstance<T>(Target: constructor<T>, { scope, args }: InjectOptions): T;
 }
+//# sourceMappingURL=ProxyInjector.d.ts.map

package/typings/injector/ProxyInjector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProxyInjector.d.ts","sourceRoot":"","sources":["../../lib/injector/ProxyInjector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,qBAAa,aAAc,SAAQ,QAAS,YAAW,SAAS;IAC9D,SAAS,CAAC,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,IAAS,EAAE,EAAE,aAAa,GAAG,CAAC;CAc5F"}

package/typings/injector/SimpleInjector.d.ts

@@ -1,5 +1,18 @@
 import { IInjector, InjectOptions, Injector } from './IInjector.js';
 import { type constructor } from '../utils/basic.js';
+/**
+ * Injector that passes the scope itself as the first constructor argument,
+ * followed by the runtime args. Needs no decorators or `reflect-metadata`.
+ *
+ * @example
+ * class App {
+ *   constructor(scope: IContainer) {
+ *     this.logger = scope.resolve('Logger');
+ *   }
+ * }
+ * new Container({ injector: new SimpleInjector() });
+ */
 export declare class SimpleInjector extends Injector implements IInjector {
     protected createInstance<T>(Target: constructor<T>, { scope, args }: InjectOptions): T;
 }
+//# sourceMappingURL=SimpleInjector.d.ts.map

package/typings/injector/SimpleInjector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleInjector.d.ts","sourceRoot":"","sources":["../../lib/injector/SimpleInjector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,qBAAa,cAAe,SAAQ,QAAS,YAAW,SAAS;IAC/D,SAAS,CAAC,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,IAAS,EAAE,EAAE,aAAa,GAAG,CAAC;CAG5F"}

package/typings/metadata/class.d.ts

@@ -1,6 +1,34 @@
+/** Decorator that writes class metadata under `key`; `mapFn` receives the previous value. */
 export declare const addClassMeta: <T>(key: string | symbol, mapFn: (prev: T | undefined) => T) => ClassDecorator;
+/** Reads class metadata written by `addClassMeta`. */
 export declare function getClassMeta<T>(target: object, key: string | symbol): T | undefined;
+/** Decorator that attaches a `key` -> `label` pair to a class. */
 export declare const addClassLabel: (key: string, label: string) => ClassDecorator;
+/** Reads the labels written by `addClassLabel`. */
 export declare const getClassLabels: (target: object) => Map<string, string>;
+/** Decorator that attaches a tag to a class. */
 export declare const addClassTag: (tag: string) => ClassDecorator;
+/** Reads the tags written by `addClassTag`. */
 export declare const getClassTags: (target: object) => Set<string>;
+/**
+ * Applies several class decorators as one, so a stack repeated on many classes
+ * can be given a name:
+ *
+ * ```typescript
+ * const repository = <T>(token: SingleToken<T>, ...mappers: RegistrationMapper<T>[]) =>
+ *   createComposeClassDecorator(
+ *     register(IRepositoryToken, token, addMediator(token), ...mappers),
+ *     addClassMeta('injection-token', () => token),
+ *   );
+ * ```
+ *
+ * Decorators are applied bottom-up, exactly as stacking them would be, so
+ * `@createComposeClassDecorator(a, b)` behaves like `@a @b` - moving a stack into one
+ * call never changes which decorator writes its metadata first.
+ *
+ * A decorator which returns a replacement class hands it to the next one, and
+ * the last replacement is returned - the same threading the runtime does for a
+ * stack.
+ */
+export declare const createComposeClassDecorator: (...decorators: ClassDecorator[]) => ClassDecorator;
+//# sourceMappingURL=class.d.ts.map

package/typings/metadata/class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class.d.ts","sourceRoot":"","sources":["../../lib/metadata/class.ts"],"names":[],"mappings":"AAEA,6FAA6F;AAC7F,eAAO,MAAM,YAAY,GACtB,CAAC,EAAE,KAAK,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC,KAAG,cAI7D,CAAC;AAEJ,sDAAsD;AACtD,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,GAAG,SAAS,CAEnF;AAED,kEAAkE;AAClE,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,OAAO,MAAM,mBACgC,CAAC;AACzF,mDAAmD;AACnD,eAAO,MAAM,cAAc,GAAI,QAAQ,MAAM,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAA+C,CAAC;AAElH,gDAAgD;AAChD,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,mBAA0E,CAAC;AAClH,+CAA+C;AAC/C,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,KAAG,GAAG,CAAC,MAAM,CAA6C,CAAC;AAEtG;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,2BAA2B,GACrC,GAAG,YAAY,cAAc,EAAE,KAAG,cAEsC,CAAC"}

package/typings/metadata/method.d.ts

@@ -1,6 +1,31 @@
+/** Decorator that writes method metadata under `key`; `mapFn` receives the previous value. */
 export declare const addMethodMeta: <T>(key: string, mapFn: (prev: T | undefined) => T) => MethodDecorator;
+/** Reads method metadata written by `addMethodMeta`. */
 export declare const getMethodMeta: (key: string, target: object, propertyKey: string) => unknown;
+/** Decorator that attaches a `key` -> `label` pair to a method. */
 export declare const addMethodLabel: (key: string, label: string) => MethodDecorator;
+/** Reads the labels written by `addMethodLabel`. */
 export declare const getMethodLabels: (target: object, propertyKey: string) => Map<string, string>;
+/** Decorator that attaches a tag to a method. */
 export declare const addMethodTag: (tag: string) => MethodDecorator;
+/** Reads the tags written by `addMethodTag`. */
 export declare const getMethodTags: (target: object, propertyKey: string) => Set<string>;
+/**
+ * Applies several method decorators as one, so a stack repeated on many members
+ * can be given a name:
+ *
+ * ```typescript
+ * const handler = (event: string) =>
+ *   createComposeMethodDecorator(addMethodTag('handler'), addMethodMeta('event', () => event));
+ * ```
+ *
+ * Decorators are applied bottom-up, exactly as stacking them would be, so
+ * `@createComposeMethodDecorator(a, b)` behaves like `@a @b`.
+ *
+ * The property descriptor is threaded through the chain the way the runtime
+ * threads it: a decorator which returns a replacement descriptor hands it to the
+ * next one, and the last replacement is returned. That is what makes wrapping
+ * decorators such as `@once` or `@throttle` compose here.
+ */
+export declare const createComposeMethodDecorator: (...decorators: MethodDecorator[]) => MethodDecorator;
+//# sourceMappingURL=method.d.ts.map

package/typings/metadata/method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method.d.ts","sourceRoot":"","sources":["../../lib/metadata/method.ts"],"names":[],"mappings":"AAEA,8FAA8F;AAC9F,eAAO,MAAM,aAAa,GACvB,CAAC,EAAE,KAAK,MAAM,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC,KAAG,eAIpD,CAAC;AACJ,wDAAwD;AACxD,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,EAAE,aAAa,MAAM,KAAG,OACd,CAAC;AAEpE,mEAAmE;AACnE,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,EAAE,OAAO,MAAM,oBACgC,CAAC;AAC1F,oDAAoD;AACpD,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,EAAE,aAAa,MAAM,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CACO,CAAC;AAEhG,iDAAiD;AACjD,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,oBAA2E,CAAC;AACpH,gDAAgD;AAChD,eAAO,MAAM,aAAa,GAAI,QAAQ,MAAM,EAAE,aAAa,MAAM,KAAG,GAAG,CAAC,MAAM,CACO,CAAC;AAEtF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,4BAA4B,GACtC,GAAG,YAAY,eAAe,EAAE,KAAG,eAE8D,CAAC"}

package/typings/metadata/parameter.d.ts

@@ -1,6 +1,28 @@
+/** Decorator that writes parameter metadata under `key`; `mapFn` receives the previous value. */
 export declare const addParamMeta: (key: string | symbol, mapFn: (prev: unknown) => unknown) => ParameterDecorator;
+/** Reads parameter metadata written by `addParamMeta`. */
 export declare const getParamMeta: (key: string | symbol, target: object) => unknown[];
+/** Decorator that attaches a `key` -> `label` pair to a parameter. */
 export declare const addParamLabel: (key: string, label: string) => ParameterDecorator;
+/** Reads the labels written by `addParamLabel`. */
 export declare const getParamLabels: (target: object, parameterIndex: number) => Map<string, string>;
+/** Decorator that attaches a tag to a parameter. */
 export declare const addParamTag: (tag: string) => ParameterDecorator;
+/** Reads the tags written by `addParamTag`. */
 export declare const getParamTags: (target: object, parameterIndex: number) => Set<string>;
+/**
+ * Applies several parameter decorators as one, so a stack repeated on many
+ * parameters can be given a name:
+ *
+ * ```typescript
+ * const fromConfig = <T>(key: string, map: MapFn<IConfig, T>) =>
+ *   createComposeParameterDecorator(inject(pipe(by(ConfigToken), map)), addParamLabel('config', key));
+ * ```
+ *
+ * Decorators are applied bottom-up, exactly as stacking them would be, so
+ * `@createComposeParameterDecorator(a, b)` behaves like `@a @b`. A parameter
+ * decorator returns nothing, so there is nothing to thread - each one is called
+ * with the same target, property key and parameter index.
+ */
+export declare const createComposeParameterDecorator: (...decorators: ParameterDecorator[]) => ParameterDecorator;
+//# sourceMappingURL=parameter.d.ts.map

package/typings/metadata/parameter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter.d.ts","sourceRoot":"","sources":["../../lib/metadata/parameter.ts"],"names":[],"mappings":"AAEA,iGAAiG;AACjG,eAAO,MAAM,YAAY,GACtB,KAAK,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,KAAG,kBAK1D,CAAC;AACJ,0DAA0D;AAC1D,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,GAAG,MAAM,EAAE,QAAQ,MAAM,KAAG,OAAO,EAE1E,CAAC;AAEF,sEAAsE;AACtE,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,OAAO,MAAM,uBAIpD,CAAC;AACL,mDAAmD;AACnD,eAAO,MAAM,cAAc,GAAI,QAAQ,MAAM,EAAE,gBAAgB,MAAM,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAGzF,CAAC;AAEF,oDAAoD;AACpD,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,uBAInC,CAAC;AACL,+CAA+C;AAC/C,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,EAAE,gBAAgB,MAAM,KAAG,GAAG,CAAC,MAAM,CAG/E,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,+BAA+B,GACzC,GAAG,YAAY,kBAAkB,EAAE,KAAG,kBAKtC,CAAC"}

package/typings/metadata/target.d.ts

@@ -1,2 +1,21 @@
 import { type constructor, type Instance } from '../utils/basic.js';
+/**
+ * The class behind `target`: `target` itself when it is already a constructor,
+ * otherwise the constructor of the instance.
+ *
+ * `target` may be a proxy (a `lazy()` provider hands one out), and it is
+ * unwrapped before either branch, because metadata is defined on the real class
+ * and a proxy is never that class. A proxied class misses the lookup outright,
+ * standing in for the very object metadata is keyed by; a proxied instance would
+ * only answer `constructor` correctly if its handler forwards the read, which a
+ * custom one need not do.
+ *
+ * The branch tests for a constructor rather than for an instance: `Is.instance`
+ * asks for an *own* `constructor` property, which a prototype has and an
+ * instance does not - its own `constructor` lives one level up the chain.
+ *
+ * Every metadata read goes through here, so callers pass whatever they hold - a
+ * class, an instance, or a proxy of either - and never unwrap by hand.
+ */
 export declare function resolveConstructor(target: constructor<unknown> | Instance): constructor<unknown>;
+//# sourceMappingURL=target.d.ts.map

package/typings/metadata/target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../lib/metadata/target.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAM,MAAM,gBAAgB,CAAC;AAGrE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,CAGhG"}

package/typings/provider/IProvider.d.ts

@@ -4,19 +4,43 @@ import { Serializable } from '../utils/basic.js';
 export type WithLazy = {
     lazy: boolean;
 };
+/**
+ * The resolution context a provider works in: the `scope` resolving, the runtime
+ * `args`, and whether the caller asked for a `lazy` instance. One object, so a
+ * function handed it destructures what it uses (`({ scope, args }) => ...`).
+ */
 export type ProviderOptions = InjectOptions & Partial<WithLazy>;
+/**
+ * `ProviderOptions` as a caller which addresses the scope directly passes them -
+ * `scope.resolve(key, options)`, `token.resolve(scope, options)` - so the scope is
+ * not repeated inside.
+ */
 export type ResolveOptions = Omit<ProviderOptions, keyof WithScope>;
+/** A factory: builds the dependency from the resolution context. What `Registration.fromFn` takes. */
 export type ResolveDependency<T = unknown> = (options: ProviderOptions) => T;
+/** What a {@link ScopeAccessRule} sees: the scope asking, the scope holding the provider, and the runtime args. */
 export type ScopeAccessOptions = {
     invocationScope: Tagged;
     providerScope: Tagged;
     args: unknown[];
 };
+/** Decides whether a provider may be resolved for an invocation; `prev` is the result of earlier rules. Set with `scopeAccess(...)`. */
 export type ScopeAccessRule = (options: ScopeAccessOptions, prev: boolean) => boolean;
+/** Computes args from the resolution context. */
 export type ArgsFn = (options: InjectOptions) => unknown[];
+/** Maps runtime args to a `singleton(...)` cache key: one instance per distinct key. */
 export type GetCacheKey = (args: unknown[]) => string | Serializable;
+/** Wraps or replaces a resolved dependency. Used by `decorate(...)`. */
 export type DecorateFn<Instance = any> = (dep: Instance, scope: IContainer) => Instance;
+/**
+ * Provider hooks - the provider's own domain: a dependency was resolved.
+ *
+ * Resolution is the provider's business, so the hook list belongs to the
+ * provider. A dependency is not necessarily a constructed instance - a provider
+ * can hand out a value the container never built - so the hook takes `unknown`.
+ */
 export type ProviderHook = (dependency: unknown, scope: IContainer) => void;
+/** The factory behind a registration. See {@link Provider}. */
 export interface IProvider<T = any> {
     resolve(options: ProviderOptions): T;
     hasAccess(options: ScopeAccessOptions): boolean;
@@ -30,3 +54,4 @@ export interface IProvider<T = any> {
     dispose(): void;
     onResolved(...hooks: ProviderHook[]): this;
 }
+//# sourceMappingURL=IProvider.d.ts.map

package/typings/provider/IProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IProvider.d.ts","sourceRoot":"","sources":["../../lib/provider/IProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AACzC;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAChE;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,eAAe,EAAE,MAAM,SAAS,CAAC,CAAC;AACpE,sGAAsG;AACtG,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,OAAO,EAAE,eAAe,KAAK,CAAC,CAAC;AAC7E,mHAAmH;AACnH,MAAM,MAAM,kBAAkB,GAAG;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,CAAC;AACrG,wIAAwI;AACxI,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;AAEtF,iDAAiD;AACjD,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,EAAE,CAAC;AAE3D,wFAAwF;AACxF,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,GAAG,YAAY,CAAC;AACrE,wEAAwE;AACxE,MAAM,MAAM,UAAU,CAAC,QAAQ,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,KAAK,QAAQ,CAAC;AAExF;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;AAE5E,+DAA+D;AAC/D,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,GAAG;IAChC,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,CAAC,CAAC;IAErC,SAAS,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC;IAEhD,GAAG,CAAC,GAAG,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC;IAEvC,aAAa,CAAC,GAAG,KAAK,EAAE,eAAe,EAAE,GAAG,IAAI,CAAC;IAEjD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhC,IAAI,IAAI,IAAI,CAAC;IAEb,WAAW,IAAI,IAAI,CAAC;IAEpB,gBAAgB,IAAI,OAAO,CAAC;IAE5B,SAAS,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAE3C,OAAO,IAAI,IAAI,CAAC;IAEhB,UAAU,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;CAC5C"}

package/typings/provider/Provider.d.ts

@@ -1,6 +1,12 @@
 import { type ArgsFn, type DecorateFn, type GetCacheKey, type IProvider, type ProviderOptions, type ResolveDependency, type ScopeAccessOptions, type ScopeAccessRule, type ProviderHook } from './IProvider.js';
 import type { DependencyKey } from '../container/IContainer.js';
 import { type constructor } from '../utils/basic.js';
+/**
+ * The factory behind a registration: creates or returns the dependency and
+ * applies the pipes (`singleton`, `lazy`, `decorate`, args and access rules).
+ * Usually created for you by {@link Registration}; use it directly only for
+ * low-level `container.register(key, provider)` calls.
+ */
 export declare class Provider<T = any> implements IProvider<T> {
     private readonly resolveDependency;
     static fromClass<T>(Target: constructor<T>): IProvider<T>;
@@ -16,16 +22,40 @@ export declare class Provider<T = any> implements IProvider<T> {
     private isDisposed;
     private readonly onResolvedHookList;
     constructor(resolveDependency: ResolveDependency<T>);
+    /**
+     * @throws {ProviderDisposedError} when the provider has already been disposed.
+     * @throws {unknown} rethrows whatever an `onResolved` hook threw.
+     */
     resolve(options: ProviderOptions): T;
+    /**
+     * @throws {unknown} rethrows whatever an `onResolved` hook threw.
+     */
     private resolveDep;
     map(...mappers: DecorateFn<T>[]): this;
     addAccessRule(...rules: ScopeAccessRule[]): this;
     lazy(): this;
     autoResolve(): this;
+    /**
+     * @throws {ProviderDisposedError} when the provider has already been disposed.
+     */
     isAutoResolvable(): boolean;
     addArgsFn(...fns: ArgsFn[]): this;
+    /**
+     * @throws {ProviderDisposedError} when the provider has already been disposed.
+     */
     hasAccess(options: ScopeAccessOptions): boolean;
+    /**
+     * @throws {CannotApplySingletonTwiceError} when the provider is already configured as a singleton.
+     */
     singleton(getCacheKey?: GetCacheKey): this;
+    /**
+     * Hooks run after every mapper, on each resolved dependency. A singleton provider
+     * caches the dependency, so its hooks run once — on the resolve that filled the cache.
+     */
     onResolved(...hooks: ProviderHook[]): this;
+    /**
+     * @throws {ProviderDisposedError} when the provider has already been disposed.
+     */
     dispose(): void;
 }
+//# sourceMappingURL=Provider.d.ts.map

package/typings/provider/Provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.d.ts","sourceRoot":"","sources":["../../lib/provider/Provider.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,KAAK,WAAW,EAAY,MAAM,gBAAgB,CAAC;AAI5D;;;;;GAKG;AACH,qBAAa,QAAQ,CAAC,CAAC,GAAG,GAAG,CAAE,YAAW,SAAS,CAAC,CAAC,CAAC;IAuBxC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAtB9C,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;IAIzD,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;IAI3C,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,aAAa;IAIpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyB;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAsB;gBAE5B,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAEpE;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,CAAC;IAmBpC;;OAEG;IACH,OAAO,CAAC,UAAU;IAalB,GAAG,CAAC,GAAG,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI;IAKtC,aAAa,CAAC,GAAG,KAAK,EAAE,eAAe,EAAE,GAAG,IAAI;IAKhD,IAAI,IAAI,IAAI;IAKZ,WAAW,IAAI,IAAI;IAKnB;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAS3B,SAAS,CAAC,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI;IAKjC;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO;IAS/C;;OAEG;IACH,SAAS,CAAC,WAAW,GAAE,WAAuB,GAAG,IAAI;IASrD;;;OAGG;IACH,UAAU,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI;IAK1C;;OAEG;IACH,OAAO,IAAI,IAAI;CAchB"}