ts-ioc-container 72.0.0 → 72.2.0

package/typings/container/EmptyContainer.d.ts

@@ -4,29 +4,80 @@ import { type IRegistration } from '../registration/IRegistration.js';
 import { type constructor, type Instance } from '../utils/basic.js';
 import { type IInjector } from '../injector/IInjector.js';
 import { type ITypedEvent } from '../utils/TypedEvent.js';
+/**
+ * Terminates the parent chain of every root {@link Container}: `resolve` throws
+ * `DependencyNotFoundError`, alias lookups return nothing, and every other
+ * method throws `MethodNotImplementedError`. You rarely use it directly.
+ */
 export declare class EmptyContainer implements IContainer {
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container has no disposal state.
+     */
     get isDisposed(): boolean;
     addInstance(instance: Instance): void;
     getParent(): undefined;
     getScopes(): never[];
     getInstances(): never[];
     hasInstance(instance: Instance): boolean;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container cannot create scopes.
+     */
     createScope(): IContainer;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container constructs nothing, so it has no injector.
+     */
     getInjector(): IInjector;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container holds no providers to resolve.
+     */
     autoResolve(options?: AutoResolveOptions): this;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container cannot be disposed.
+     */
     dispose(): void;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container cannot hold registrations.
+     */
     register(key: DependencyKey, value: IProvider): this;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container has no tags.
+     */
     hasTag(tag: Tag): boolean;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container has no tags.
+     */
     addTags(...tags: Tag[]): void;
     getRegistrations(): never[];
     hasRegistration(key: DependencyKey): boolean;
     removeScope(): void;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container cannot use modules.
+     */
     useModule(module: IContainerModule): this;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container cannot hold registrations.
+     */
     addRegistration(registration: IRegistration): this;
+    /**
+     * @throws {DependencyNotFoundError} always — reaching the empty container means `key` was not found in any scope.
+     */
     resolve<T>(key: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
     resolveByAlias<T>(alias: DependencyKey, options?: ResolveManyOptions): T[];
+    /**
+     * @throws {DependencyNotFoundError} always — reaching the empty container means `alias` was not found in any scope.
+     */
     resolveOneByAlias<T>(alias: DependencyKey, options?: ResolveOneOptions): T;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container cannot hold hooks.
+     */
     get scopeCreated(): ITypedEvent<[IContainer]>;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container cannot hold hooks.
+     */
     get scopeDisposed(): ITypedEvent<[IContainer]>;
+    /**
+     * @throws {MethodNotImplementedError} always — the empty container cannot hold hooks.
+     */
     get registered(): ITypedEvent<[IProvider, DependencyKey, IContainer]>;
 }
+//# sourceMappingURL=EmptyContainer.d.ts.map

package/typings/container/EmptyContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmptyContainer.d.ts","sourceRoot":"","sources":["../../lib/container/EmptyContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,GAAG,EACT,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;GAIG;AACH,qBAAa,cAAe,YAAW,UAAU;IAC/C;;OAEG;IACH,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,WAAW,CAAC,QAAQ,EAAE,QAAQ;IAE9B,SAAS;IAIT,SAAS;IAIT,YAAY;IAIZ,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAIxC;;OAEG;IACH,WAAW,IAAI,UAAU;IAIzB;;OAEG;IACH,WAAW,IAAI,SAAS;IAIxB;;OAEG;IACH,WAAW,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,IAAI;IAI/C;;OAEG;IACH,OAAO,IAAI,IAAI;IAIf;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI;IAIpD;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO;IAIzB;;OAEG;IACH,OAAO,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI7B,gBAAgB;IAIhB,eAAe,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO;IAI5C,WAAW,IAAI,IAAI;IAEnB;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAIzC;;OAEG;IACH,eAAe,CAAC,YAAY,EAAE,aAAa,GAAG,IAAI;IAIlD;;OAEG;IACH,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,aAAa,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,CAAC;IAQ/E,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,CAAC,EAAE;IAI1E;;OAEG;IACH,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,CAAC;IAM1E;;OAEG;IACH,IAAI,YAAY,IAAI,WAAW,CAAC,CAAC,UAAU,CAAC,CAAC,CAE5C;IAED;;OAEG;IACH,IAAI,aAAa,IAAI,WAAW,CAAC,CAAC,UAAU,CAAC,CAAC,CAE7C;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,WAAW,CAAC,CAAC,SAAS,EAAE,aAAa,EAAE,UAAU,CAAC,CAAC,CAEpE;CACF"}

package/typings/container/IContainer.d.ts

@@ -3,8 +3,11 @@ import { type IRegistration } from '../registration/IRegistration.js';
 import { IInjector, type WithArgs } from '../injector/IInjector.js';
 import { type constructor, Instance } from '../utils/basic.js';
 import { type ITypedEvent } from '../utils/TypedEvent.js';
+/** A registration key: a string or a symbol. */
 export type DependencyKey = string | symbol;
+/** Narrows `target` to a {@link DependencyKey}. */
 export declare function isDependencyKey(target: unknown): target is DependencyKey;
+/** A scope label (`'application'`, `'request'`, ...) matched by `scope(...)` rules. */
 export type Tag = string;
 type WithTags = {
     tags: Tag[];
@@ -15,47 +18,119 @@ type WithChild = {
 type WithExcludedKeys = {
     excludedKeys: DependencyKey[];
 };
+/** Something carrying tags: a scope or a token. */
 export interface Tagged {
     hasTag(tag: Tag): boolean;
     addTags(...tags: Tag[]): void;
 }
+/** Options of `resolve`: runtime `args`, `lazy`, and the invoking `child` scope. */
 export type ResolveOneOptions = ResolveOptions & Partial<WithChild>;
+/** Options of `resolveByAlias`: like {@link ResolveOneOptions}, plus keys to exclude. */
 export type ResolveManyOptions = ResolveOneOptions & Partial<WithExcludedKeys>;
+/** Something that resolves a key or a class. */
 export interface Resolvable {
     resolve<T>(key: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
 }
+/**
+ * A reusable bundle of registrations or event subscriptions applied with
+ * `container.useModule(module)`. A plain object with `applyTo` is enough.
+ *
+ * @example
+ * const loggingModule: IContainerModule = {
+ *   applyTo: (container) => container.addRegistration(Registration.fromClass(Logger)),
+ * };
+ */
 export interface IContainerModule {
     applyTo(container: IContainer): void;
 }
+/** Options of `createScope`: the child scope's `tags`. */
 export type CreateScopeOptions = Partial<WithTags>;
 export type AutoResolveOptions = Partial<WithArgs>;
 export type RegisterOptions = {
     aliases?: DependencyKey[];
 };
+/**
+ * Scope event hooks - the container's own domain: a scope was created, a scope
+ * was disposed. The listener type of `IContainer.scopeCreated` / `scopeDisposed`.
+ *
+ * The other two hook domains live with the abstraction which raises them:
+ * injector hooks on `IInjector` (`InjectorHook`), provider hooks on
+ * {@link IProvider} (`ProviderHook`). An injector is configured before it is
+ * passed to a container's constructor, so a container never hands its injector
+ * out.
+ */
 export type ScopeHook = (scope: IContainer) => void;
+/**
+ * Scope event hook for a registration landing in a scope: a provider entered
+ * the provider map under `key`. Registration is always of a provider, so the
+ * name says only what varies. The listener type of `IContainer.registered`.
+ */
 export type RegisteredHook = (provider: IProvider, key: DependencyKey, scope: IContainer) => void;
+/** A dependency injection scope. See {@link Container}. */
 export interface IContainer extends Tagged {
     readonly isDisposed: boolean;
+    /**
+     * Raised once a scope this container created is fully registered and attached.
+     * The subscriber's side only - a container raises its own scope events.
+     */
     readonly scopeCreated: ITypedEvent<[IContainer]>;
+    /**
+     * Raised by this container as it disposes, before its providers and instances go.
+     */
     readonly scopeDisposed: ITypedEvent<[IContainer]>;
+    /**
+     * Raised once a provider is registered here under a resolvable key.
+     */
     readonly registered: ITypedEvent<[IProvider, DependencyKey, IContainer]>;
+    /** Low-level: puts `value` under `key` in this scope only. Prefer `addRegistration`. */
     register(key: DependencyKey, value: IProvider, options?: RegisterOptions): this;
+    /** Registers here if the registration's scope rules match, and remembers it for future child scopes. */
     addRegistration(registration: IRegistration): this;
+    /** Registrations added to this scope and its parents - what `createScope` copies. */
     getRegistrations(): IRegistration[];
+    /** Whether a provider is registered under `key` in this scope (parents are not checked). */
     hasRegistration(key: DependencyKey): boolean;
+    /**
+     * Resolves a key, or constructs a class with the injector. Takes a key or a
+     * class, not a token: for a token call `token.resolve(scope)`.
+     *
+     * @example
+     * scope.resolve<ILogger>('ILogger');
+     * scope.resolve(App, { args: ['tenant-1'] });
+     */
     resolve<T>(target: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
+    /** Resolves every accessible dependency registered under `alias`, in this scope and its parents. */
     resolveByAlias<T>(alias: DependencyKey, options?: ResolveManyOptions): T[];
+    /** Resolves one dependency registered under `alias`, looking here first and then in parents. */
     resolveOneByAlias<T>(alias: DependencyKey, options?: ResolveOneOptions): T;
+    /**
+     * Creates a child scope and copies into it the registrations whose scope
+     * rules match its tags. Registrations added later are not copied into it.
+     *
+     * @example
+     * const request = app.createScope({ tags: ['request'] });
+     */
     createScope(options?: CreateScopeOptions): IContainer;
+    /** Resolves every provider marked with `autoResolve()`. */
     autoResolve(options?: AutoResolveOptions): this;
+    /** Direct child scopes that are still alive. */
     getScopes(): IContainer[];
+    /** Detaches a child scope; called by the child on dispose. */
     removeScope(child: IContainer): void;
+    /** Applies a module to this scope. */
     useModule(module: IContainerModule): this;
+    /** The parent scope, if any. */
     getParent(): IContainer | undefined;
+    /** Instances constructed in this scope, and in child scopes when `cascade` is true. */
     getInstances(cascade?: boolean): Instance[];
+    /** Whether this scope tracks `instance`. */
     hasInstance(instance: Instance): boolean;
+    /** Raises `scopeDisposed`, drops providers and instances, and detaches from the parent. Child scopes are not disposed. */
     dispose(): void;
+    /** Tracks an instance in this scope; called by the injector. */
     addInstance(instance: Instance): void;
+    /** The injector shared by this scope tree, e.g. to subscribe to `onConstructed`. */
     getInjector(): IInjector;
 }
 export {};
+//# sourceMappingURL=IContainer.d.ts.map

package/typings/container/IContainer.d.ts.map

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

package/typings/errors/ArgumentNotFoundError.d.ts

@@ -1,5 +1,8 @@
 import { ContainerError } from './ContainerError.js';
+/** Thrown by `findOrFail` when no runtime arg matches the predicate. Code `IOC_ARGUMENT_NOT_FOUND`. */
 export declare class ArgumentNotFoundError extends ContainerError {
     name: string;
+    readonly code = "IOC_ARGUMENT_NOT_FOUND";
     constructor(message?: string);
 }
+//# sourceMappingURL=ArgumentNotFoundError.d.ts.map

package/typings/errors/ArgumentNotFoundError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArgumentNotFoundError.d.ts","sourceRoot":"","sources":["../../lib/errors/ArgumentNotFoundError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,uGAAuG;AACvG,qBAAa,qBAAsB,SAAQ,cAAc;IACvD,IAAI,SAA2B;IAC/B,QAAQ,CAAC,IAAI,4BAA4B;gBAE7B,OAAO,SAAuB;CAK3C"}

package/typings/errors/CannonSingletonApplyTwiceError.d.ts

@@ -1,6 +1,6 @@
-import { ContainerError } from './ContainerError.js';
-export declare class CannonSingletonApplyTwiceError extends ContainerError {
-    name: string;
-    constructor(message?: string);
-    static assert(isTrue: boolean, failMessage: string): void;
-}
+import { CannotApplySingletonTwiceError } from './CannotApplySingletonTwiceError.js';
+/** @deprecated Misspelled name kept for compatibility. Use {@link CannotApplySingletonTwiceError}. */
+export declare const CannonSingletonApplyTwiceError: typeof CannotApplySingletonTwiceError;
+/** @deprecated Misspelled name kept for compatibility. Use {@link CannotApplySingletonTwiceError}. */
+export type CannonSingletonApplyTwiceError = CannotApplySingletonTwiceError;
+//# sourceMappingURL=CannonSingletonApplyTwiceError.d.ts.map

package/typings/errors/CannonSingletonApplyTwiceError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CannonSingletonApplyTwiceError.d.ts","sourceRoot":"","sources":["../../lib/errors/CannonSingletonApplyTwiceError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAElF,sGAAsG;AACtG,eAAO,MAAM,8BAA8B,uCAAiC,CAAC;AAC7E,sGAAsG;AACtG,MAAM,MAAM,8BAA8B,GAAG,8BAA8B,CAAC"}

package/typings/errors/CannotApplySingletonTwiceError.d.ts

@@ -0,0 +1,12 @@
+import { ContainerError } from './ContainerError.js';
+/** Thrown when `singleton()` is applied twice to one provider. Code `IOC_SINGLETON_APPLIED_TWICE`. */
+export declare class CannotApplySingletonTwiceError extends ContainerError {
+    name: string;
+    readonly code = "IOC_SINGLETON_APPLIED_TWICE";
+    constructor(message?: string);
+    /**
+     * @throws {CannotApplySingletonTwiceError} when `isTrue` is falsy.
+     */
+    static assert(isTrue: boolean, failMessage: string): void;
+}
+//# sourceMappingURL=CannotApplySingletonTwiceError.d.ts.map

package/typings/errors/CannotApplySingletonTwiceError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CannotApplySingletonTwiceError.d.ts","sourceRoot":"","sources":["../../lib/errors/CannotApplySingletonTwiceError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,sGAAsG;AACtG,qBAAa,8BAA+B,SAAQ,cAAc;IAChE,IAAI,SAAoC;IACxC,QAAQ,CAAC,IAAI,iCAAiC;gBAElC,OAAO,CAAC,EAAE,MAAM;IAM5B;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM;CAKnD"}

package/typings/errors/ContainerDisposedError.d.ts

@@ -1,5 +1,8 @@
 import { ContainerError } from './ContainerError.js';
+/** Thrown when a disposed scope is used. Code `IOC_CONTAINER_DISPOSED`. */
 export declare class ContainerDisposedError extends ContainerError {
     name: string;
+    readonly code = "IOC_CONTAINER_DISPOSED";
     constructor(message: string);
 }
+//# sourceMappingURL=ContainerDisposedError.d.ts.map

package/typings/errors/ContainerDisposedError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContainerDisposedError.d.ts","sourceRoot":"","sources":["../../lib/errors/ContainerDisposedError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,2EAA2E;AAC3E,qBAAa,sBAAuB,SAAQ,cAAc;IACxD,IAAI,SAA4B;IAChC,QAAQ,CAAC,IAAI,4BAA4B;gBAE7B,OAAO,EAAE,MAAM;CAK5B"}

package/typings/errors/ContainerError.d.ts

@@ -1,4 +1,11 @@
+/**
+ * Base class of every error the container throws. `code` is stable across
+ * versions (unlike `message`), so match on it — or on the subclass — rather
+ * than on the text. The codes are listed in the package's AGENTS.md.
+ */
 export declare abstract class ContainerError extends Error {
     name: string;
+    readonly code: string;
     protected constructor(message?: string);
 }
+//# sourceMappingURL=ContainerError.d.ts.map

package/typings/errors/ContainerError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContainerError.d.ts","sourceRoot":"","sources":["../../lib/errors/ContainerError.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,8BAAsB,cAAe,SAAQ,KAAK;IAChD,IAAI,SAAoB;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAyB;IAE9C,SAAS,aAAa,OAAO,CAAC,EAAE,MAAM;CAKvC"}

package/typings/errors/ContainerNotFoundError.d.ts

@@ -1,5 +1,8 @@
 import { ContainerError } from './ContainerError.js';
+/** Signals that no container is associated with a target. Code `IOC_CONTAINER_NOT_FOUND`. */
 export declare class ContainerNotFoundError extends ContainerError {
     name: string;
+    readonly code = "IOC_CONTAINER_NOT_FOUND";
     constructor(message: string);
 }
+//# sourceMappingURL=ContainerNotFoundError.d.ts.map

package/typings/errors/ContainerNotFoundError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContainerNotFoundError.d.ts","sourceRoot":"","sources":["../../lib/errors/ContainerNotFoundError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,6FAA6F;AAC7F,qBAAa,sBAAuB,SAAQ,cAAc;IACxD,IAAI,SAA4B;IAChC,QAAQ,CAAC,IAAI,6BAA6B;gBAE9B,OAAO,EAAE,MAAM;CAK5B"}

package/typings/errors/DependencyMissingKeyError.d.ts

@@ -1,5 +1,8 @@
 import { ContainerError } from './ContainerError.js';
+/** Thrown when a registration has no binding key. Code `IOC_DEPENDENCY_MISSING_KEY`. */
 export declare class DependencyMissingKeyError extends ContainerError {
     name: string;
+    readonly code = "IOC_DEPENDENCY_MISSING_KEY";
     constructor(message: string);
 }
+//# sourceMappingURL=DependencyMissingKeyError.d.ts.map

package/typings/errors/DependencyMissingKeyError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DependencyMissingKeyError.d.ts","sourceRoot":"","sources":["../../lib/errors/DependencyMissingKeyError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,wFAAwF;AACxF,qBAAa,yBAA0B,SAAQ,cAAc;IAC3D,IAAI,SAA+B;IACnC,QAAQ,CAAC,IAAI,gCAAgC;gBAEjC,OAAO,EAAE,MAAM;CAK5B"}

package/typings/errors/DependencyNotFoundError.d.ts

@@ -1,5 +1,8 @@
 import { ContainerError } from './ContainerError.js';
+/** Thrown when a key or alias is not found in the scope or any parent. Code `IOC_DEPENDENCY_NOT_FOUND`. */
 export declare class DependencyNotFoundError extends ContainerError {
     name: string;
+    readonly code = "IOC_DEPENDENCY_NOT_FOUND";
     constructor(message: string);
 }
+//# sourceMappingURL=DependencyNotFoundError.d.ts.map

package/typings/errors/DependencyNotFoundError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DependencyNotFoundError.d.ts","sourceRoot":"","sources":["../../lib/errors/DependencyNotFoundError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,2GAA2G;AAC3G,qBAAa,uBAAwB,SAAQ,cAAc;IACzD,IAAI,SAA6B;IACjC,QAAQ,CAAC,IAAI,8BAA8B;gBAE/B,OAAO,EAAE,MAAM;CAK5B"}

package/typings/errors/MethodNotImplementedError.d.ts

@@ -1,5 +1,8 @@
 import { ContainerError } from './ContainerError.js';
+/** Thrown by a method the object does not support; the message names the class and method. Code `IOC_METHOD_NOT_IMPLEMENTED`. */
 export declare class MethodNotImplementedError extends ContainerError {
     name: string;
+    readonly code = "IOC_METHOD_NOT_IMPLEMENTED";
     constructor(message?: string);
 }
+//# sourceMappingURL=MethodNotImplementedError.d.ts.map

package/typings/errors/MethodNotImplementedError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodNotImplementedError.d.ts","sourceRoot":"","sources":["../../lib/errors/MethodNotImplementedError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,iIAAiI;AACjI,qBAAa,yBAA0B,SAAQ,cAAc;IAC3D,IAAI,SAA+B;IACnC,QAAQ,CAAC,IAAI,gCAAgC;gBAEjC,OAAO,CAAC,EAAE,MAAM;CAK7B"}

package/typings/errors/ProviderDisposedError.d.ts

@@ -1,6 +1,12 @@
 import { ContainerError } from './ContainerError.js';
+/** Thrown when a provider of a disposed scope is used. Code `IOC_PROVIDER_DISPOSED`. */
 export declare class ProviderDisposedError extends ContainerError {
     name: string;
+    readonly code = "IOC_PROVIDER_DISPOSED";
+    /**
+     * @throws {ProviderDisposedError} when `isTrue` is falsy.
+     */
     static assert(isTrue: boolean, failMessage: string): void;
     constructor(message: string);
 }
+//# sourceMappingURL=ProviderDisposedError.d.ts.map

package/typings/errors/ProviderDisposedError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProviderDisposedError.d.ts","sourceRoot":"","sources":["../../lib/errors/ProviderDisposedError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,wFAAwF;AACxF,qBAAa,qBAAsB,SAAQ,cAAc;IACvD,IAAI,SAA2B;IAC/B,QAAQ,CAAC,IAAI,2BAA2B;IAExC;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM;gBAMtC,OAAO,EAAE,MAAM;CAK5B"}

package/typings/errors/TypedEventDisposedError.d.ts

@@ -1,6 +1,12 @@
 import { ContainerError } from './ContainerError.js';
+/** Thrown when subscribing to an event of a disposed scope. Code `IOC_EVENT_DISPOSED`. */
 export declare class TypedEventDisposedError extends ContainerError {
     name: string;
+    readonly code = "IOC_EVENT_DISPOSED";
+    /**
+     * @throws {TypedEventDisposedError} when `isTrue` is falsy.
+     */
     static assert(isTrue: boolean, failMessage: string): void;
     constructor(message: string);
 }
+//# sourceMappingURL=TypedEventDisposedError.d.ts.map

package/typings/errors/TypedEventDisposedError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedEventDisposedError.d.ts","sourceRoot":"","sources":["../../lib/errors/TypedEventDisposedError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,0FAA0F;AAC1F,qBAAa,uBAAwB,SAAQ,cAAc;IACzD,IAAI,SAA6B;IACjC,QAAQ,CAAC,IAAI,wBAAwB;IAErC;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM;gBAMtC,OAAO,EAAE,MAAM;CAK5B"}

package/typings/errors/UnsupportedTokenTypeError.d.ts

@@ -1,5 +1,8 @@
 import { ContainerError } from './ContainerError.js';
+/** Thrown by `toToken` for a value that is not a token, key, class or function. Code `IOC_UNSUPPORTED_TOKEN_TYPE`. */
 export declare class UnsupportedTokenTypeError extends ContainerError {
     name: string;
+    readonly code = "IOC_UNSUPPORTED_TOKEN_TYPE";
     constructor(message: string);
 }
+//# sourceMappingURL=UnsupportedTokenTypeError.d.ts.map

package/typings/errors/UnsupportedTokenTypeError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnsupportedTokenTypeError.d.ts","sourceRoot":"","sources":["../../lib/errors/UnsupportedTokenTypeError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,sHAAsH;AACtH,qBAAa,yBAA0B,SAAQ,cAAc;IAC3D,IAAI,SAA+B;IACnC,QAAQ,CAAC,IAAI,gCAAgC;gBAEjC,OAAO,EAAE,MAAM;CAK5B"}

package/typings/hooks/HookCollector.d.ts

@@ -3,26 +3,62 @@ import { type Task } from '../utils/task.js';
 import { type Instance } from '../utils/basic.js';
 import { type HookFn } from './hook.js';
 import { type CreateHookExecutionContext, type IHookContext } from './HookContext.js';
+/** Transforms each hook context before it is handed to its hook. */
 export type MapHookExecutionContext = (context: IHookContext) => IHookContext;
+/**
+ * One decorated member's hook, resolved to a function and bound to the context
+ * it runs against — the model the library hands back, and the whole of what it
+ * says about a hook. The member it came from is `context.methodName`.
+ * Performing it is the caller's business (ADR 0016).
+ */
 export type HookAction = {
     hook: HookFn;
     context: IHookContext;
 };
+/**
+ * Shapes what is collected: how each action's hook context is built, and which
+ * members take part. A collector carries defaults for all three, so a call
+ * names only what it overrides.
+ */
 export type HookCollectorOptions = {
     createExecutionContext?: CreateHookExecutionContext;
     mapExecutionContext?: MapHookExecutionContext;
     predicate?: (methodName: string) => boolean;
 };
+/** What one collection runs in: the scope, plus any per-call overrides of the collector's options. */
 export type HookCollectionContext = ExecutionContext & HookCollectorOptions;
+/** Options of `new HookCollector(...)`. */
 export type HookCollectorProps = HookCollectorOptions & {
+    /** The hook key this collector reads: `onConstruct`, `onScopeDisposed`, `onResolved`, or a custom one. */
     key: string | symbol;
 };
+/**
+ * Reads the hooks declared under one key off a target and hands them back as
+ * {@link HookAction}s, in declaration order. It runs nothing: what order the
+ * actions are performed in, what is awaited and where a failure goes are
+ * answered by the caller (ADR 0016).
+ *
+ * Wire it to whichever event should collect — the injector's `onConstructed`,
+ * the scope's `scopeDisposed`, a provider's `onResolved` — the library ships no
+ * module which does that for you (ADR 0018).
+ *
+ * ```typescript
+ * const collector = new HookCollector({ key: 'onStart' });
+ *
+ * container.getInjector().onConstructed((instance, scope) => {
+ *   runInOrder(collector.getActions(instance, { scope }).map(toTask))?.catch(report);
+ * });
+ * ```
+ */
 export declare class HookCollector {
     private readonly key;
     private readonly options;
     private readonly hooksOf;
     constructor({ key, createExecutionContext, mapExecutionContext, predicate, }: HookCollectorProps);
     hasHooks(target: Instance): boolean;
+    /** The actions `target` declares under this collector's key — empty when it declares none. */
     getActions(target: Instance, { scope, createExecutionContext, mapExecutionContext, predicate, }: HookCollectionContext): HookAction[];
 }
+/** The {@link Task} an action runs as: `runInOrder(actions.map(toTask))`, `runAtOnce(actions.map(toTask))`. */
 export declare const toTask: ({ hook, context }: HookAction) => Task;
+//# sourceMappingURL=HookCollector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HookCollector.d.ts","sourceRoot":"","sources":["../../lib/hooks/HookCollector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAsB,KAAK,MAAM,EAAY,MAAM,QAAQ,CAAC;AACnE,OAAO,EAA8B,KAAK,0BAA0B,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAE/G,oEAAoE;AACpE,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,EAAE,YAAY,KAAK,YAAY,CAAC;AAE9E;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,sBAAsB,CAAC,EAAE,0BAA0B,CAAC;IACpD,mBAAmB,CAAC,EAAE,uBAAuB,CAAC;IAC9C,SAAS,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;CAC7C,CAAC;AAEF,sGAAsG;AACtG,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,GAAG,oBAAoB,CAAC;AAE5E,2CAA2C;AAC3C,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,GAAG;IACtD,0GAA0G;IAC1G,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IAGzD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAEjC,EACV,GAAG,EACH,sBAAmD,EACnD,mBAA0C,EAC1C,SAAsB,GACvB,EAAE,kBAAkB;IAKrB,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO;IAInC,8FAA8F;IAC9F,UAAU,CACR,MAAM,EAAE,QAAQ,EAChB,EACE,KAAK,EACL,sBAA4D,EAC5D,mBAAsD,EACtD,SAAkC,GACnC,EAAE,qBAAqB,GACvB,UAAU,EAAE;CAYhB;AAED,+GAA+G;AAC/G,eAAO,MAAM,MAAM,GAChB,mBAAmB,UAAU,KAAG,IAElB,CAAC"}

package/typings/hooks/HookContext.d.ts

@@ -1,6 +1,11 @@
 import type { IContainer } from '../container/IContainer.js';
 import { type Instance } from '../utils/basic.js';
 import { type InjectFn } from './hook.js';
+/**
+ * What a hook receives: the `instance`, the `scope` and the decorated member's
+ * name. `invokeMethod({ args: resolveArgs() })` calls the member with its
+ * `@inject` parameters; `setProperty(fn)` assigns it (see `injectProp`).
+ */
 export interface IHookContext {
     instance: Instance;
     scope: IContainer;
@@ -14,6 +19,7 @@ export interface IHookContext {
     setInitialArgs(...args: unknown[]): this;
     getInitialArgs(): unknown[];
 }
+/** The default {@link IHookContext}. */
 export declare class HookContext implements IHookContext {
     readonly instance: Instance;
     readonly scope: IContainer;
@@ -29,8 +35,12 @@ export declare class HookContext implements IHookContext {
     setInitialArgs(...args: unknown[]): this;
     getInitialArgs(): unknown[];
 }
+/** Builds the context a hook receives. */
 export type CreateHookExecutionContext = (Target: Instance, scope: IContainer, methodName?: string) => IHookContext;
+/** The default {@link CreateHookExecutionContext}: a {@link HookContext}. */
 export declare const createHookExecutionContext: CreateHookExecutionContext;
+/** A {@link CreateHookExecutionContext} whose contexts start with `args` as initial args. */
 export declare const createHookContextFactory: ({ args }?: {
     args?: unknown[];
 }) => CreateHookExecutionContext;
+//# sourceMappingURL=HookContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HookContext.d.ts","sourceRoot":"","sources":["../../lib/hooks/HookContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEvC;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,EAAE,UAAU,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,WAAW,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC;IAE3C,YAAY,CAAC,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC;IAEtD,WAAW,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAAC;IAEhC,WAAW,IAAI,OAAO,CAAC;IAEvB,cAAc,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAEzC,cAAc,IAAI,OAAO,EAAE,CAAC;CAC7B;AAED,wCAAwC;AACxC,qBAAa,WAAY,YAAW,YAAY;IAI5C,QAAQ,CAAC,QAAQ,EAAE,QAAQ;IAC3B,QAAQ,CAAC,KAAK,EAAE,UAAU;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM;IAL9B,OAAO,CAAC,WAAW,CAAiB;gBAGzB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,UAAU,EACjB,UAAU,CAAC,EAAE,MAAM,YAAA;IAG9B,WAAW,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE;IAU1C,YAAY,CAAC,EAAE,IAAyB,EAAE,GAAE;QAAE,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;KAAO,GAAG,OAAO;IAK/E,WAAW,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI;IAK/B,WAAW,IAAI,OAAO;IAKtB,cAAc,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAKxC,cAAc,IAAI,OAAO,EAAE;CAG5B;AAED,0CAA0C;AAC1C,MAAM,MAAM,0BAA0B,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,MAAM,KAAK,YAAY,CAAC;AACpH,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B,EAAE,0BACG,CAAC;AAE7C,6FAA6F;AAC7F,eAAO,MAAM,wBAAwB,GAClC,WAAe;IAAE,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;CAAO,KAAG,0BAEmC,CAAC"}

package/typings/hooks/combinators.d.ts

@@ -1,6 +1,29 @@
 import type { IContainer } from '../container/IContainer.js';
 import { type HookFn, type HookType } from './hook.js';
+/**
+ * A provider hook narrowed to the dependencies that can carry hook metadata.
+ */
 export type ResolvedObjectHook = (dependency: object, scope: IContainer) => void;
+/**
+ * Combines hooks into one which runs them in declaration order, staying
+ * synchronous until one returns a promise and awaiting the rest from that point.
+ *
+ * A member carries a single hook, so this is how several are declared together:
+ * `@hook('onConstruct', sequential(validate, persist))`.
+ */
 export declare const sequential: (...hooks: HookType[]) => HookFn;
+/**
+ * Combines hooks into one which starts them all at once. Settles when every
+ * hook has; a fully synchronous run returns nothing, like {@link sequential}.
+ *
+ * Use it for hooks of one member which do not depend on each other:
+ * `@hook('onScopeDisposed', parallel(flush, closeSocket))`.
+ */
 export declare const parallel: (...hooks: HookType[]) => HookFn;
+/**
+ * Wraps a hook so it runs a single time per instance, however often the event
+ * it is declared under fires. Composes with the combinators above —
+ * `oncePerInstance(sequential(connect, warmUp))` runs the whole sequence once.
+ */
 export declare const oncePerInstance: (execute: HookType) => HookFn;
+//# sourceMappingURL=combinators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"combinators.d.ts","sourceRoot":"","sources":["../../lib/hooks/combinators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,QAAQ,EAAY,MAAM,QAAQ,CAAC;AAE9D;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;AAEjF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,GAAG,OAAO,QAAQ,EAAE,KAAG,MAGjD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,QAAQ,EAAE,KAAG,MAG/C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,QAAQ,KAAG,MAYnD,CAAC"}

package/typings/hooks/hook.d.ts

@@ -1,14 +1,53 @@
 import { type IHookContext } from './HookContext.js';
 import { type constructor, type Instance } from '../utils/basic.js';
 import { ProviderOptions } from '../provider/IProvider.js';
+/**
+ * What `@inject(...)` and `injectProp(...)` take: a function of the resolution
+ * context returning the value to inject. Usually built with `by(...)` or `arg(...)`.
+ */
 export type InjectFn<T = unknown> = (options: ProviderOptions) => T;
+/** A hook as a function of its context. Must return `void` or `Promise<void>`. */
 export type HookFn<T extends IHookContext = IHookContext> = (context: T) => void | Promise<void>;
+/** A hook as a class resolved from the scope; its `execute` receives the context. */
 export interface HookClass<T extends IHookContext = IHookContext> {
     execute(context: Omit<T, 'scope'>): void | Promise<void>;
 }
+/** Anything `@hook(...)` accepts: a {@link HookFn} or a {@link HookClass} constructor. */
 export type HookType<T extends IHookContext = IHookContext> = HookFn<T> | constructor<HookClass<T>>;
+/** The hooks of one class under one key, by member name: one hook per member (compose with `sequential` / `parallel`). */
 export type HooksOfClass = Map<string, HookType>;
+/** Normalizes a {@link HookType} to a {@link HookFn}; a hook class is resolved from the context's scope. */
 export declare const toHookFn: <C extends IHookContext>(execute: HookFn<C> | constructor<HookClass<C>>) => HookFn<C>;
+/**
+ * Reads the hooks declared under `key`, merging hooks declared on parent classes.
+ * Hooks are collected from base to derived, so a derived class's hook for the
+ * same member replaces the parent's.
+ *
+ * `target` is an instance or its class, a proxy of either included - it is
+ * normalized by `resolveConstructor`, so callers never unwrap it themselves.
+ *
+ * The merge runs on every call and returns a fresh map. Hook metadata is fixed
+ * once a class is defined, so a caller which reads it often can wrap this in
+ * `memoize` (`HookCollector` already does).
+ */
 export declare function getHooks(target: Instance | constructor<unknown>, key: string | symbol): HooksOfClass;
+/** Whether `target` (an instance or class, proxies included) declares any hook under `key`. */
 export declare function hasHooks(target: Instance | constructor<unknown>, key: string | symbol): boolean;
+/**
+ * Method/property decorator that declares a hook under `key`. The library only
+ * stores it: collect with `new HookCollector({ key })` and run the actions
+ * yourself. A member carries exactly one hook per key - decorating it twice
+ * replaces the earlier hook; compose several with `sequential(...)` / `parallel(...)`.
+ *
+ * @example
+ * const onInit = (fn: HookType) => hook('onInit', fn);
+ *
+ * class Service {
+ *   @onInit((ctx) => {
+ *     ctx.invokeMethod({ args: ctx.resolveArgs() });
+ *   })
+ *   init() {}
+ * }
+ */
 export declare const hook: (key: string | symbol, fn: HookType) => (target: object, propertyKey: string | symbol) => void;
+//# sourceMappingURL=hook.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../lib/hooks/hook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAM,MAAM,gBAAgB,CAAC;AAGrE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;GAGG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,OAAO,EAAE,eAAe,KAAK,CAAC,CAAC;AAEpE,kFAAkF;AAClF,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEjG,qFAAqF;AACrF,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY;IAC9D,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D;AAED,0FAA0F;AAC1F,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAEpG,0HAA0H;AAC1H,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AAQjD,4GAA4G;AAC5G,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,YAAY,EAAE,SAAS,MAAM,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CACA,CAAC;AAE3G;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,CAWpG;AAED,+FAA+F;AAC/F,wBAAgB,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAE/F;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,MAAM,GAAG,MAAM,EAAE,IAAI,QAAQ,MAAM,QAAQ,MAAM,EAAE,aAAa,MAAM,GAAG,MAAM,SAMxG,CAAC"}

package/typings/hooks/injectProp.d.ts

@@ -1,2 +1,11 @@
 import { HookFn, InjectFn } from './hook.js';
+/**
+ * Injects a dependency into the decorated property.
+ *
+ * `fn` is an `InjectFn`, exactly as for `@inject`: it receives the resolution
+ * context and returns the value to assign, so `injectProp(({ scope }) =>
+ * scope.resolve('key'))` assigns the dependency and `injectProp(pipe(fn, sanitize()))`
+ * a mapped one.
+ */
 export declare const injectProp: <T>(fn: InjectFn<T>) => HookFn;
+//# sourceMappingURL=injectProp.d.ts.map