ts-ioc-container 72.1.0 → 72.2.0

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,7 +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,7 +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,7 +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"}

package/typings/registration/IRegistration.d.ts

@@ -3,19 +3,61 @@ import type { ArgsFn, DecorateFn, GetCacheKey, IProvider, ProviderHook, ScopeAcc
 import { BindToken } from '../token/BindToken.js';
 import { MapFn } from '../utils/fp.js';
 import { type constructor } from '../utils/basic.js';
+/**
+ * Decides whether a registration is copied into a scope when that scope is
+ * created (or when the registration is added). `prev` is the result of the
+ * rules before it, so rules chain. Set with {@link scope} or `registration.when(...)`.
+ *
+ * @example
+ * const onlyRequest: ScopeMatchRule = (s) => s.hasTag('request');
+ */
 export type ScopeMatchRule = (s: IContainer, prev: boolean) => boolean;
+/**
+ * A provider transform usable in both places: `registration.pipe(...)` calls
+ * `mapProvider`, `@register(...)` calls `mapRegistration`. Build one with
+ * {@link registerPipe}; `singleton()`, `lazy()`, `scopeAccess()` etc. are all pipes.
+ */
 export interface ProviderPipe<T = unknown> {
     mapProvider(p: IProvider<T>): IProvider<T>;
     mapRegistration(r: IRegistration<T>): IRegistration<T>;
 }
+/** Narrows `obj` to a {@link ProviderPipe}. */
 export declare const isProviderPipe: <T>(obj: unknown) => obj is ProviderPipe<T>;
+/**
+ * Turns a provider transform into a {@link ProviderPipe}, so it works both in
+ * `@register(...)` and in `registration.pipe(...)`.
+ *
+ * @example
+ * const cached = <T>() => registerPipe<T>((p) => p.singleton());
+ *
+ * @register(bindTo('Cache'), cached())
+ * class Cache {}
+ */
 export declare const registerPipe: <T>(mapProvider: (p: IProvider<T>) => IProvider<T>) => ProviderPipe<T>;
+/**
+ * Anything that can name a binding key: a raw key, or a token that knows how to bind itself.
+ */
 export type Bindable<T = any> = DependencyKey | BindToken<T>;
+/** Normalizes a {@link Bindable}: a raw key becomes a `SingleToken`, a token is returned as is. */
 export declare const toBindToken: <T>(target: Bindable<T>) => BindToken<T>;
+/**
+ * Everything accepted at provider level - by `IRegistration.pipe(...)`.
+ */
 export type ProviderMapper<T = any> = MapFn<IProvider<T>> | ProviderPipe<T>;
+/** Normalizes a {@link ProviderMapper} to a plain provider transform. */
 export declare const toProviderFn: <T>(mapper: ProviderMapper<T>) => MapFn<IProvider<T>>;
+/**
+ * Everything accepted at registration level - by `@register(...)`.
+ */
 export type RegistrationMapper<T = any> = MapFn<IRegistration<T>> | ProviderPipe<T> | Bindable<T>;
+/** Normalizes a {@link RegistrationMapper} to a plain registration transform (a `Bindable` becomes `bindTo(...)`). */
 export declare const toRegistrationFn: <T>(mapper: RegistrationMapper<T>) => MapFn<IRegistration<T>>;
+/**
+ * A recipe for putting one provider into matching scopes. Created with
+ * `Registration.fromClass` / `fromValue` / `fromFn` / `fromKey` and added with
+ * `container.addRegistration(...)`; `applyTo(scope)` registers the provider
+ * when the scope rules match.
+ */
 export interface IRegistration<T = any> extends IContainerModule {
     getKeyOrFail(): DependencyKey;
     when(...predicates: ScopeMatchRule[]): this;
@@ -24,16 +66,111 @@ export interface IRegistration<T = any> extends IContainerModule {
     pipe(...mappers: ProviderMapper<T>[]): this;
     bindToAlias(alias: DependencyKey): this;
 }
+/** The dependency type `T` of an `IRegistration<T>`. */
 export type ReturnTypeOfRegistration<T> = T extends IRegistration<infer R> ? R : never;
+/** Reads the registration transforms written on a class by {@link register}. */
 export declare const getTransformers: (Target: constructor<unknown>) => MapFn<IRegistration<any>>[];
+/**
+ * Class decorator that configures how `Registration.fromClass(Target)` registers
+ * the class: binding keys, scope rules and provider pipes. A bare key or token
+ * is shorthand for `bindTo(...)`. Without a key the class name is used.
+ *
+ * @example
+ * @register(bindTo(ILoggerToken), scope((s) => s.hasTag('application')), singleton())
+ * class Logger implements ILogger {}
+ *
+ * container.addRegistration(Registration.fromClass(Logger));
+ */
 export declare const register: (...mappers: RegistrationMapper[]) => ClassDecorator;
+/**
+ * Binds a registration to one or more keys or tokens. A `SingleToken` binds its
+ * key; an alias token (`toSingleAlias`, `toGroupAlias`) adds an alias.
+ *
+ * @example
+ * @register(bindTo(ILoggerToken))
+ * class Logger {}
+ *
+ * @example
+ * Registration.fromValue(config).bindTo('Config');
+ */
 export declare const bindTo: (...tokens: Bindable[]) => MapFn<IRegistration>;
+/**
+ * Limits which scopes a registration is copied into. Without it, a registration
+ * lands in every scope, so a `singleton()` becomes one instance per scope.
+ *
+ * @example
+ * @register(bindTo('Repo'), scope((s) => s.hasTag('request')))
+ * class Repo {}
+ */
 export declare const scope: (...rules: ScopeMatchRule[]) => MapFn<IRegistration>;
+/**
+ * Appends fixed values after the runtime args handed to the provider.
+ *
+ * @example
+ * @register(bindTo('Client'), appendArgs('https://api.example.com'))
+ * class Client {
+ *   constructor(@inject(arg(0)) readonly baseUrl: string) {}
+ * }
+ */
 export declare const appendArgs: <T>(...extraArgs: unknown[]) => ProviderPipe<T>;
+/**
+ * Appends values computed at resolve time after the runtime args.
+ *
+ * @example
+ * @register(bindTo('Client'), appendArgsFn(({ scope }) => [scope.resolve('API_URL')]))
+ * class Client {}
+ */
 export declare const appendArgsFn: <T>(fn: ArgsFn) => ProviderPipe<T>;
+/**
+ * Controls from which scopes the provider may be resolved (unlike {@link scope},
+ * which controls where it is registered). A denied lookup falls through to the parent.
+ *
+ * @example
+ * @register(bindTo('Admin'), scopeAccess(({ invocationScope }) => invocationScope.hasTag('admin')))
+ * class AdminService {}
+ */
 export declare const scopeAccess: <T>(rule: ScopeAccessRule) => ProviderPipe<T>;
+/**
+ * Resolves the dependency as a proxy that constructs the real instance on first
+ * member access.
+ *
+ * @example
+ * @register(bindTo('Heavy'), lazy())
+ * class HeavyService {}
+ */
 export declare const lazy: <T>() => ProviderPipe<T>;
+/**
+ * Marks the provider for eager resolution when the scope is set up; needs
+ * `container.useModule(new AutoResolveModule())`.
+ */
 export declare const autoResolve: <T>() => ProviderPipe<T>;
+/**
+ * Wraps or replaces the resolved dependency. Order relative to `lazy()` decides
+ * whether the proxy or the real instance is decorated.
+ *
+ * @example
+ * @register(bindTo('Api'), decorate((api, scope) => new LoggingApi(api)))
+ * class Api {}
+ */
 export declare const decorate: (...fns: DecorateFn[]) => ProviderPipe<unknown>;
+/**
+ * Caches the dependency per provider, which means per scope the registration
+ * was copied into (combine with {@link scope}). `getCacheKey` receives the
+ * runtime args and caches one instance per distinct key.
+ *
+ * @example
+ * @register(bindTo('Db'), scope((s) => s.hasTag('application')), singleton())
+ * class Db {}
+ *
+ * @example
+ * // one instance per tenant id passed as the first runtime arg
+ * @register(bindTo('TenantDb'), singleton(([tenantId]) => String(tenantId)))
+ * class TenantDb {}
+ */
 export declare const singleton: <T = unknown>(getCacheKey?: GetCacheKey) => ProviderPipe<T>;
+/**
+ * Registration-level form of `IProvider.onResolved`: attaches provider hooks to
+ * the piped registration's provider.
+ */
 export declare const onResolve: <T = unknown>(...hooks: ProviderHook[]) => ProviderPipe<T>;
+//# sourceMappingURL=IRegistration.d.ts.map

package/typings/registration/IRegistration.d.ts.map

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

package/typings/registration/Registration.d.ts

@@ -2,6 +2,22 @@ import { DependencyKey, IContainer } from '../container/IContainer.js';
 import type { IProvider, ResolveDependency } from '../provider/IProvider.js';
 import { type Bindable, type IRegistration, type ProviderMapper, type ScopeMatchRule } from './IRegistration.js';
 import { type constructor } from '../utils/basic.js';
+/**
+ * Builds registrations for `container.addRegistration(...)`. Usually imported as
+ * `Registration as R`.
+ *
+ * - `R.fromClass(Class)` - reads the class's `@register(...)` config; the key
+ *   defaults to the class name.
+ * - `R.fromValue(value).bindTo('Key')` - a constant.
+ * - `R.fromFn(({ scope, args }) => ...).bindTo('Key')` - a factory.
+ * - `R.fromKey('Other').bindTo('Key')` - an alias of another key.
+ *
+ * @example
+ * container
+ *   .addRegistration(R.fromClass(Logger))
+ *   .addRegistration(R.fromValue('https://api.example.com').bindTo('API_URL'))
+ *   .addRegistration(R.fromFn(({ scope }) => new Client(scope.resolve('API_URL'))).bindTo('Client'));
+ */
 export declare class Registration<T = any> implements IRegistration<T> {
     private createProvider;
     key?: DependencyKey | undefined;
@@ -21,6 +37,13 @@ export declare class Registration<T = any> implements IRegistration<T> {
     when(...predicates: ScopeMatchRule[]): this;
     bindTo(key: Bindable): this;
     private matchScope;
+    /**
+     * @throws {DependencyMissingKeyError} when the registration matches the scope but has no binding key.
+     */
     applyTo(container: IContainer): void;
+    /**
+     * @throws {DependencyMissingKeyError} when no binding key has been set for this registration.
+     */
     getKeyOrFail(): DependencyKey;
 }
+//# sourceMappingURL=Registration.d.ts.map

package/typings/registration/Registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Registration.d.ts","sourceRoot":"","sources":["../../lib/registration/Registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAEpE,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1E,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,cAAc,EAIpB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,KAAK,WAAW,EAAM,MAAM,gBAAgB,CAAC;AAEtD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,YAAY,CAAC,CAAC,GAAG,GAAG,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IA0B1D,OAAO,CAAC,cAAc;IACf,GAAG,CAAC,EAAE,aAAa;IAC1B,OAAO,CAAC,UAAU;IA3BpB,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAO;IAK5E,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC;IAQ5B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAIzC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,aAAa;IAIpC,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,OAAO,CAAiC;gBAGtC,cAAc,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,EACnC,GAAG,CAAC,EAAE,aAAa,YAAA,EAClB,UAAU,GAAE,cAAc,EAAO;IAG3C,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI;IAKnC,WAAW,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAKvC,IAAI,CAAC,GAAG,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI;IAK3C,IAAI,CAAC,GAAG,UAAU,EAAE,cAAc,EAAE,GAAG,IAAI;IAK3C,MAAM,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI;IAK3B,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,UAAU,GAAG,IAAI;IAepC;;OAEG;IACH,YAAY,IAAI,aAAa;CAQ9B"}

package/typings/select.d.ts

@@ -1,6 +1,20 @@
 import { type CreateScopeOptions } from './container/IContainer.js';
 import { FunctionToken } from './token/FunctionToken.js';
 import { GroupInstanceToken, InstancePredicate } from './token/GroupInstanceToken.js';
+/**
+ * Shortcuts for common tokens.
+ *
+ * - `select.token(x)` - `toToken(x)`
+ * - `select.alias('Key')` - a {@link GroupAliasToken}
+ * - `select.instances(predicate)` - instances already created in the scope
+ * - `select.scope.current` - the resolving scope itself
+ * - `select.scope.create({ tags })` - a new child scope
+ *
+ * @example
+ * class Handler {
+ *   constructor(@inject(by(select.scope.current)) private scope: IContainer) {}
+ * }
+ */
 export declare const select: {
     alias: <T>(token: import("./container/IContainer.js").DependencyKey) => import("./token/GroupAliasToken.js").GroupAliasToken<T>;
     token: <T = any>(token: import("./token/toToken.js").Injectable<T>) => import(".").InjectionToken<T>;
@@ -10,3 +24,4 @@ export declare const select: {
         create: (options: CreateScopeOptions) => FunctionToken<import("./container/IContainer.js").IContainer>;
     };
 };
+//# sourceMappingURL=select.d.ts.map

package/typings/select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../lib/select.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAGnF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,MAAM;;;4BAKM,iBAAiB;;;0BAKpB,kBAAkB;;CAEvC,CAAC"}

package/typings/token/BindToken.d.ts

@@ -1,5 +1,8 @@
 import { IRegistration } from '../registration/IRegistration.js';
+/** A token that can bind a registration to itself (a key or an alias). */
 export interface BindToken<T = any> {
     bindTo(r: IRegistration<T>): void;
 }
+/** Narrows `token` to a {@link BindToken}. */
 export declare function isBindToken(token: unknown): token is BindToken;
+//# sourceMappingURL=BindToken.d.ts.map

package/typings/token/BindToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BindToken.d.ts","sourceRoot":"","sources":["../../lib/token/BindToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAI9D,0EAA0E;AAC1E,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,GAAG;IAChC,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CACnC;AAED,8CAA8C;AAC9C,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAE9D"}

package/typings/token/ClassToken.d.ts

@@ -2,6 +2,7 @@ import { IContainer } from '../container/IContainer.js';
 import { InjectionToken } from './InjectionToken.js';
 import { type constructor, Serializable } from '../utils/basic.js';
 import { ArgsFn, ResolveOptions } from '../provider/IProvider.js';
+/** A token for a class: resolves it through the scope's injector. `toToken(Class)` creates one. */
 export declare class ClassToken<T = any> extends InjectionToken<T> implements Serializable {
     private readonly target;
     private readonly _getArgsFn;
@@ -19,3 +20,4 @@ export declare class ClassToken<T = any> extends InjectionToken<T> implements Se
     addTags(...tags: string[]): ClassToken<T>;
     toString(): string;
 }
+//# sourceMappingURL=ClassToken.d.ts.map

package/typings/token/ClassToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassToken.d.ts","sourceRoot":"","sources":["../../lib/token/ClassToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAe,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE/D,mGAAmG;AACnG,qBAAa,UAAU,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAE,YAAW,YAAY;IAK9E,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJzB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAGf,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EACvC,EACE,SAAuB,EACvB,MAAc,EACd,IAAS,GACV,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO;IAOnE,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,IACpB,GAAG,UAAU;IAGvB,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,IAAS,EAAE,IAAI,EAAE,GAAE,cAAmB,GAAG,CAAC;IAOnE,IAAI,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE;IAS1B,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO,EAAE;IASvC,IAAI;IAQJ,OAAO,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC;IAQzC,QAAQ,IAAI,MAAM;CAGnB"}

package/typings/token/ConstantToken.d.ts

@@ -1,15 +1,29 @@
 import type { IContainer } from '../container/IContainer.js';
 import { InjectionToken } from './InjectionToken.js';
 import { Serializable } from '../utils/basic.js';
+/** A token that always resolves to a fixed value. It takes no args and cannot be lazy. */
 export declare class ConstantToken<T = any> extends InjectionToken<T> implements Serializable {
     private readonly token;
     constructor(token: T, { tags }?: {
         tags?: string[];
     });
     resolve(s: IContainer): T;
+    /**
+     * @throws {MethodNotImplementedError} always — a constant token cannot receive static args.
+     */
     args(...deps: unknown[]): InjectionToken<T>;
+    /**
+     * @throws {MethodNotImplementedError} always — a constant token cannot receive resolved args.
+     */
     argsFn(getArgsFn: (s: IContainer) => unknown[]): InjectionToken<T>;
+    /**
+     * @throws {MethodNotImplementedError} always — a constant token cannot be made lazy.
+     */
     lazy(): InjectionToken<T>;
     addTags(...tags: string[]): ConstantToken<T>;
+    /**
+     * @throws {MethodNotImplementedError} always — a constant token has no underlying key.
+     */
     toString(): string;
 }
+//# sourceMappingURL=ConstantToken.d.ts.map

package/typings/token/ConstantToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConstantToken.d.ts","sourceRoot":"","sources":["../../lib/token/ConstantToken.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,0FAA0F;AAC1F,qBAAa,aAAa,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAE,YAAW,YAAY;IAEjF,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAAL,KAAK,EAAE,CAAC,EACzB,EAAE,IAAS,EAAE,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO;IAKzC,OAAO,CAAC,CAAC,EAAE,UAAU,GAAG,CAAC;IAIzB;;OAEG;IACH,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAI3C;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAIlE;;OAEG;IACH,IAAI,IAAI,cAAc,CAAC,CAAC,CAAC;IAIzB,OAAO,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC;IAI5C;;OAEG;IACH,QAAQ,IAAI,MAAM;CAGnB"}

package/typings/token/FunctionToken.d.ts

@@ -3,6 +3,12 @@ import { InjectionToken } from './InjectionToken.js';
 import { InjectFn } from '../hooks/hook.js';
 import { ArgsFn, ResolveOptions } from '../provider/IProvider.js';
 import { Serializable } from '../utils/basic.js';
+/**
+ * A token that resolves by calling an `InjectFn` with the resolution context.
+ *
+ * @example
+ * const CurrentScope = new FunctionToken(({ scope }) => scope);
+ */
 export declare class FunctionToken<T = any> extends InjectionToken<T> implements Serializable {
     private readonly fn;
     private readonly _getArgsFn;
@@ -17,5 +23,9 @@ export declare class FunctionToken<T = any> extends InjectionToken<T> implements
     argsFn(fn: (s: IContainer) => unknown[]): InjectionToken<T>;
     lazy(): InjectionToken<T>;
     addTags(...tags: string[]): FunctionToken<T>;
+    /**
+     * @throws {MethodNotImplementedError} always — a function token has no underlying key.
+     */
     toString(): string;
 }
+//# sourceMappingURL=FunctionToken.d.ts.map

package/typings/token/FunctionToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionToken.d.ts","sourceRoot":"","sources":["../../lib/token/FunctionToken.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAe,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;GAKG;AACH,qBAAa,aAAa,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAE,YAAW,YAAY;IAKjF,OAAO,CAAC,QAAQ,CAAC,EAAE;IAJrB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAGf,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC,EAChC,EACE,SAAuB,EACvB,MAAc,EACd,IAAS,GACV,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO;IAOnE,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,IAAS,EAAE,IAAI,EAAE,GAAE,cAAmB,GAAG,CAAC;IAQnE,IAAI,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAS9C,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAS3D,IAAI,IAAI,cAAc,CAAC,CAAC,CAAC;IAQzB,OAAO,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC;IAQ5C;;OAEG;IACH,QAAQ,IAAI,MAAM;CAGnB"}