class-resolver/dist/resolver.d.ts

Simple class resolver.

import { ResolveTarget } from './interface';
/**
 * Resolver class implementing the Chain of Responsibility pattern
 * Resolves handlers for specific types
 */
declare class Resolver<TBase extends ResolveTarget<any[], any, any> = ResolveTarget<any[], any, any>, TType = string> {
    /**
     * Array of registered resolver targets
     * @private
     */
    private updaters;
    /**
     * Fallback handler function
     * @private
     */
    private fallbackHandler?;
    /**
     * Initializes the resolver
     * @param args Initial resolver targets
     */
    constructor(...args: TBase[]);
    /**
     * Processes an array of arguments
     * @param args Array of resolver targets
     * @returns Processed array
     * @private
     */
    private getArgs;
    /**
     * Sets resolver targets
     * @param updaters Array of resolver targets
     */
    set(updaters: TBase[]): void;
    /**
     * Sets resolver targets (variadic version)
     * @param args Resolver targets
     */
    setUpdaters(...args: TBase[]): void;
    /**
     * Adds a resolver target
     * @param updater Resolver target to add
     */
    addUpdater(updater: TBase): this;
    /**
     * Sets a fallback handler for unsupported types
     * @param handler Fallback handler function
     * @returns This resolver instance for method chaining
     */
    setFallbackHandler(handler: (...args: Parameters<TBase['handle']>) => ReturnType<TBase['handle']>): this;
    /**
     * Resolves a resolver target for the specified type
     * @param type Type to resolve
     * @returns Resolved resolver target
     * @throws {Error} When no resolver targets are registered
     * @throws {Error} When no resolver target supporting the specified type is found and no fallback is set
     */
    resolve(type: TType): TBase;
}
export default Resolver;