class-resolver 2.1.1 → 4.0.0

package/README.md

@@ -10,6 +10,11 @@ A lightweight TypeScript/JavaScript library for implementing the Chain of Respon
 - Support for multiple resolvers with different handling logic
 - Clear error handling for unsupported types
 - Generic type support for better type safety
+- **Fallback handler support for graceful handling of unsupported types**
+- **Method chaining support for fluent API usage**
+- **🎯 NEW: Multiple handler execution (resolveAll, handleAll)**
+- **🎯 NEW: Priority-based handler resolution**
+- **🎯 NEW: Async handler support (handleAllAsync, handleAllSequential)**
 
 ## Installation
 
@@ -55,6 +60,27 @@ try {
 }
 ```
 
+## Fallback Handler Usage
+
+The fallback handler allows you to gracefully handle unsupported types without throwing errors:
+
+```typescript
+const resolver = new Resolver(new ExampleClass(), new ExampleClass2())
+
+// Set a fallback handler for unsupported types
+resolver.setFallbackHandler((type) => {
+  return `Fallback: ${type}`
+})
+
+// Now unsupported types will use the fallback handler instead of throwing errors
+const result = resolver.resolve('xxx')
+console.log(result.handle('xxx')) // Output: Fallback: xxx
+
+// Supported types still work normally
+const c = resolver.resolve('hoge')
+console.log(c.handle()) // Output: hoge
+```
+
 ## Advanced Usage
 
 ### With TypeScript and Parameters
@@ -113,6 +139,33 @@ resolver.addUpdater(new MessageFormatter())
 resolver.addUpdater(new ErrorFormatter())
 ```
 
+### Fallback Handler with TypeScript
+
+The fallback handler maintains full type safety and automatically infers types from your resolver configuration:
+
+```typescript
+// Create a resolver with specific types
+const resolver = new Resolver<ResolveTarget<[string, number], string>>(
+  new MessageFormatter()
+)
+
+// Set a fallback handler with the same type signature
+resolver.setFallbackHandler((name: string, count: number): string => {
+  return `Default greeting for ${name} (message #${count})`
+})
+
+// The fallback handler will be used for unsupported types
+const result = resolver.resolve('unknown').handle('John', 5)
+console.log(result) // Output: Default greeting for John (message #5)
+
+// Method chaining is also supported
+resolver
+  .setFallbackHandler((name: string, count: number): string => {
+    return `Custom fallback: ${name} - ${count}`
+  })
+  .addUpdater(new ErrorFormatter())
+```
+
 ## Generic Type Support
 
 From version 2.0.0, class-resolver supports generic types for better type safety:
@@ -202,20 +255,290 @@ This advanced type support allows you to:
 - Handle domain-specific objects like Stripe events, database records, or custom business objects
 - Create more expressive and type-safe event handling systems
 
+## Breaking Changes in v3.0.0
+
+### `resolve()` Method Behavior Change
+
+**Important**: The `resolve()` method now returns the **highest priority handler** instead of the first matching handler based on registration order.
+
+#### Before (v2.x)
+```typescript
+const resolver = new Resolver(handler1, handler2, handler3);
+const result = resolver.resolve('type'); // Returns handler1 (first registered)
+```
+
+#### After (v3.0.0)
+```typescript
+// Without priority - behavior unchanged (returns first matching handler)
+const resolver = new Resolver(handler1, handler2, handler3);
+const result = resolver.resolve('type'); // Still returns handler1
+
+// With priority - returns highest priority handler
+class HighPriority implements PrioritizedResolveTarget {
+  priority = 100;
+  // ...
+}
+class LowPriority implements PrioritizedResolveTarget {
+  priority = 10;
+  // ...
+}
+
+const resolver = new Resolver(lowPriority, highPriority);
+const result = resolver.resolve('type'); // Returns highPriority (priority: 100)
+```
+
+**Migration Guide**: If you rely on registration order and don't want priority-based resolution:
+- Continue using handlers without the `priority` property - they will maintain registration order (all have default priority of 0)
+- Or explicitly set the same priority on all handlers to maintain registration order
+
+## New Features in v3.0.0
+
+### Multiple Handler Execution
+
+Execute all matching handlers for a single event type. Perfect for webhook fanout patterns where one event needs multiple processors.
+
+```typescript
+import Resolver from 'class-resolver';
+import { ResolveTarget } from 'class-resolver';
+
+interface StripeEvent {
+  type: string;
+  data: { amount: number };
+}
+
+class AccountingHandler implements ResolveTarget<[StripeEvent], string, StripeEvent> {
+  supports(event: StripeEvent): boolean {
+    return event.type === 'payment.succeeded';
+  }
+  handle(event: StripeEvent): string {
+    return `Accounting: Recorded ${event.data.amount}`;
+  }
+}
+
+class EmailHandler implements ResolveTarget<[StripeEvent], string, StripeEvent> {
+  supports(event: StripeEvent): boolean {
+    return event.type === 'payment.succeeded';
+  }
+  handle(event: StripeEvent): string {
+    return `Email: Sent confirmation for ${event.data.amount}`;
+  }
+}
+
+class AnalyticsHandler implements ResolveTarget<[StripeEvent], string, StripeEvent> {
+  supports(event: StripeEvent): boolean {
+    return event.type === 'payment.succeeded';
+  }
+  handle(event: StripeEvent): string {
+    return `Analytics: Logged ${event.data.amount}`;
+  }
+}
+
+const resolver = new Resolver<ResolveTarget<[StripeEvent], string, StripeEvent>, StripeEvent>(
+  new AccountingHandler(),
+  new EmailHandler(),
+  new AnalyticsHandler()
+);
+
+const event: StripeEvent = {
+  type: 'payment.succeeded',
+  data: { amount: 1000 }
+};
+
+// Execute ALL matching handlers
+const results = resolver.handleAll(event, event);
+// Results: [
+//   'Accounting: Recorded 1000',
+//   'Email: Sent confirmation for 1000',
+//   'Analytics: Logged 1000'
+// ]
+
+// Or get all matching handlers
+const handlers = resolver.resolveAll(event);
+// handlers.length === 3
+```
+
+### Priority-Based Handler Resolution
+
+Control execution order with priority levels. Higher priority handlers execute first.
+
+```typescript
+import { PrioritizedResolveTarget } from 'class-resolver';
+
+class ValidationHandler implements PrioritizedResolveTarget<[any], boolean, string> {
+  priority = 100;  // Highest priority
+
+  supports(type: string): boolean {
+    return type === 'webhook';
+  }
+
+  handle(data: any): boolean {
+    return data !== null && data !== undefined;
+  }
+}
+
+class BusinessLogicHandler implements PrioritizedResolveTarget<[any], string, string> {
+  priority = 50;  // Medium priority
+
+  supports(type: string): boolean {
+    return type === 'webhook';
+  }
+
+  handle(data: any): string {
+    return `Processed: ${JSON.stringify(data)}`;
+  }
+}
+
+class LoggingHandler implements PrioritizedResolveTarget<[any], void, string> {
+  priority = 10;  // Lowest priority
+
+  supports(type: string): boolean {
+    return type === 'webhook';
+  }
+
+  handle(data: any): void {
+    console.log(`Logged: ${JSON.stringify(data)}`);
+  }
+}
+
+const resolver = new Resolver<PrioritizedResolveTarget<[any], any, string>, string>(
+  new LoggingHandler(),      // Registered third
+  new ValidationHandler(),   // Registered first
+  new BusinessLogicHandler() // Registered second
+);
+
+// Handlers execute in PRIORITY order (not registration order):
+// 1. ValidationHandler (priority: 100)
+// 2. BusinessLogicHandler (priority: 50)
+// 3. LoggingHandler (priority: 10)
+const results = resolver.handleAll('webhook', { test: true });
+```
+
+### Async Handler Support
+
+Execute async handlers in parallel or sequentially.
+
+```typescript
+import { AsyncResolveTarget } from 'class-resolver';
+
+class SaveToDBHandler implements AsyncResolveTarget<[any], string, string> {
+  supports(type: string): boolean {
+    return type === 'payment';
+  }
+
+  async handle(data: any): Promise<string> {
+    // Simulate DB save
+    await new Promise(resolve => setTimeout(resolve, 100));
+    return 'Saved to DB';
+  }
+}
+
+class SendWebhookHandler implements AsyncResolveTarget<[any], string, string> {
+  supports(type: string): boolean {
+    return type === 'payment';
+  }
+
+  async handle(data: any): Promise<string> {
+    // Simulate external API call
+    await new Promise(resolve => setTimeout(resolve, 200));
+    return 'Webhook sent';
+  }
+}
+
+const resolver = new Resolver<AsyncResolveTarget<[any], string, string>, string>(
+  new SaveToDBHandler(),
+  new SendWebhookHandler()
+);
+
+// Execute handlers in PARALLEL (fastest)
+const results = await resolver.handleAllAsync('payment', { amount: 1000 });
+// Results: ['Saved to DB', 'Webhook sent']
+// Total time: ~200ms (not 300ms)
+
+// Or execute SEQUENTIALLY (ordered, stops on error)
+const results2 = await resolver.handleAllSequential('payment', { amount: 1000 });
+// Results: ['Saved to DB', 'Webhook sent']
+// Total time: ~300ms
+```
+
+### Priority + Async Combined
+
+```typescript
+import { PrioritizedAsyncResolveTarget } from 'class-resolver';
+
+class ValidationHandler implements PrioritizedAsyncResolveTarget<[any], boolean, string> {
+  priority = 100;
+
+  supports(type: string): boolean {
+    return type === 'order';
+  }
+
+  async handle(data: any): Promise<boolean> {
+    // Async validation
+    return data.amount > 0;
+  }
+}
+
+class ProcessHandler implements PrioritizedAsyncResolveTarget<[any], string, string> {
+  priority = 50;
+
+  supports(type: string): boolean {
+    return type === 'order';
+  }
+
+  async handle(data: any): Promise<string> {
+    return `Processed order ${data.id}`;
+  }
+}
+
+const resolver = new Resolver<PrioritizedAsyncResolveTarget<[any], any, string>, string>(
+  new ProcessHandler(),    // priority: 50
+  new ValidationHandler()  // priority: 100
+);
+
+// Executes in priority order: Validation → Process
+const results = await resolver.handleAllAsync('order', { id: 123, amount: 1000 });
+// Results: [true, 'Processed order 123']
+```
+
 ## Use Cases
 
-1. **Command Pattern Implementation**: Handle different types of commands with specific handlers
-2. **Format Conversion**: Convert data between different formats based on type
-3. **Request Processing**: Process different types of requests with dedicated handlers
-4. **Plugin System**: Implement a plugin system where different plugins handle specific types of operations
-5. **Message Formatting**: Format different types of messages with specific formatters
+1. **Webhook Fanout**: Process a single webhook event with multiple handlers (accounting, notifications, analytics)
+2. **Event-Driven Architecture**: Route events to multiple subscribers based on event type
+3. **Command Pattern Implementation**: Handle different types of commands with specific handlers
+4. **Validation Pipeline**: Execute validation, business logic, and logging in priority order
+5. **Async Workflows**: Coordinate multiple async operations (DB saves, API calls, file operations)
+6. **Plugin System**: Implement a plugin system where different plugins handle specific types of operations
+7. **Message Formatting**: Format different types of messages with specific formatters
+8. **Graceful Degradation**: Use fallback handlers to provide default behavior for unknown types
+9. **API Versioning**: Handle different API versions with fallback to backward-compatible behavior
+10. **LINE Bot / Discord Bot**: Route different message types to appropriate handlers
 
 ## Error Handling
 
 The resolver will throw errors in the following cases:
-- When no resolvers are registered: `"Unasigned resolve target."`
+- When no resolvers are registered: `"Unassigned resolve target."`
 - When trying to resolve an unsupported type: `"Unsupported type: xxx"`
 
+### Fallback Handler for Error Prevention
+
+With the fallback handler, you can prevent errors for unsupported types:
+
+```typescript
+const resolver = new Resolver(new ExampleClass())
+
+// Without fallback handler - throws error
+try {
+  resolver.resolve('unknown')
+} catch (e) {
+  console.log(e) // Error: Unsupported type: unknown
+}
+
+// With fallback handler - no error thrown
+resolver.setFallbackHandler((type) => `Default: ${type}`)
+const result = resolver.resolve('unknown') // No error, uses fallback
+console.log(result.handle('unknown')) // Output: Default: unknown
+```
+
 ## Upgrade Guide
 
 ### Upgrading from 1.x to 2.0.0

package/dist/index.cjs

@@ -0,0 +1,2 @@
+"use strict";class i{updaters=[];fallbackHandler;constructor(...t){t.length>0&&this.set(t)}getArgs(t){return[...t]}set(t){this.updaters=t}setUpdaters(...t){this.set(this.getArgs(t))}addUpdater(t){return this.updaters.push(t),this}setFallbackHandler(t){return this.fallbackHandler=t,this}getPriority(t){const r=t;return typeof r.priority=="number"?r.priority:0}sortByPriority(t){return[...t].sort((r,e)=>{const s=this.getPriority(r);return this.getPriority(e)-s})}resolve(t){if(this.updaters.length<1)throw new Error("Unassigned resolve target.");const r=this.updaters.filter(n=>n.supports(t)),s=this.sortByPriority(r)[0];if(!s){if(this.fallbackHandler)return{supports:()=>!0,handle:this.fallbackHandler};const n=typeof t=="object"&&t!==null?JSON.stringify(t):String(t);throw new Error(`Unsupported type: ${n}`)}return s}resolveAll(t){if(this.updaters.length<1)throw new Error("Unassigned resolve target.");const r=this.updaters.filter(e=>e.supports(t));return r.length===0?this.fallbackHandler?[{supports:()=>!0,handle:this.fallbackHandler}]:[]:this.sortByPriority(r)}handleAll(t,...r){return this.resolveAll(t).map(s=>s.handle(...r))}async handleAllAsync(t,...r){const s=this.resolveAll(t).map(n=>n.handle(...r));return Promise.all(s)}async handleAllSequential(t,...r){const e=this.resolveAll(t),s=[];for(const n of e){const l=await n.handle(...r);s.push(l)}return s}}module.exports=i;module.exports=i;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../libs/resolver.ts","../libs/index.ts"],"sourcesContent":["import type { ResolveTarget } from './interface';\n\n/**\n * Resolver class implementing the Chain of Responsibility pattern\n * Resolves handlers for specific types\n */\nclass Resolver<\n  TBase extends ResolveTarget<any[], any, any> = ResolveTarget<any[], any, any>,\n  TType = string,\n> {\n  /**\n   * Array of registered resolver targets\n   * @private\n   */\n  private updaters: TBase[] = [];\n\n  /**\n   * Fallback handler function\n   * @private\n   */\n  private fallbackHandler?: (...args: Parameters<TBase['handle']>) => ReturnType<TBase['handle']>;\n\n  /**\n   * Initializes the resolver\n   * @param args Initial resolver targets\n   */\n  constructor(...args: TBase[]) {\n    if (args.length > 0) {\n      this.set(args);\n    }\n  }\n\n  /**\n   * Processes an array of arguments\n   * @param args Array of resolver targets\n   * @returns Processed array\n   * @private\n   */\n  private getArgs(args: TBase[]): TBase[] {\n    return [...args];\n  }\n\n  /**\n   * Sets resolver targets\n   * @param updaters Array of resolver targets\n   */\n  public set(updaters: TBase[]): void {\n    this.updaters = updaters;\n  }\n\n  /**\n   * Sets resolver targets (variadic version)\n   * @param args Resolver targets\n   */\n  public setUpdaters(...args: TBase[]): void {\n    this.set(this.getArgs(args));\n  }\n\n  /**\n   * Adds a resolver target\n   * @param updater Resolver target to add\n   */\n  public addUpdater(updater: TBase): this {\n    this.updaters.push(updater);\n    return this;\n  }\n\n  /**\n   * Sets a fallback handler for unsupported types\n   * @param handler Fallback handler function\n   * @returns This resolver instance for method chaining\n   */\n  public setFallbackHandler(\n    handler: (...args: Parameters<TBase['handle']>) => ReturnType<TBase['handle']>\n  ): this {\n    this.fallbackHandler = handler;\n    return this;\n  }\n\n  /**\n   * Gets the priority of a handler\n   * @param handler The handler to get priority for\n   * @returns Priority value (0 if not defined)\n   * @private\n   */\n  private getPriority(handler: TBase): number {\n    const handlerWithPriority = handler as Partial<{ priority: number }>;\n    return typeof handlerWithPriority.priority === 'number' ? handlerWithPriority.priority : 0;\n  }\n\n  /**\n   * Sorts handlers by priority (highest first), maintaining registration order for equal priorities\n   * @param handlers Array of handlers to sort\n   * @returns Sorted array of handlers\n   * @private\n   */\n  private sortByPriority(handlers: TBase[]): TBase[] {\n    return [...handlers].sort((a, b) => {\n      const priorityA = this.getPriority(a);\n      const priorityB = this.getPriority(b);\n      return priorityB - priorityA; // Higher priority first\n    });\n  }\n\n  /**\n   * Resolves a resolver target for the specified type\n   * @param type Type to resolve\n   * @returns Resolved resolver target\n   * @throws {Error} When no resolver targets are registered\n   * @throws {Error} When no resolver target supporting the specified type is found and no fallback is set\n   */\n  public resolve(type: TType): TBase {\n    if (this.updaters.length < 1) {\n      throw new Error('Unassigned resolve target.');\n    }\n\n    // Get all matching handlers and sort by priority\n    const matchingHandlers = this.updaters.filter((updater) => updater.supports(type));\n    const sortedHandlers = this.sortByPriority(matchingHandlers);\n    const target = sortedHandlers[0];\n\n    if (!target) {\n      // If fallback handler is set, create a temporary target that uses it\n      if (this.fallbackHandler) {\n        return {\n          supports: () => true,\n          handle: this.fallbackHandler,\n        } as unknown as TBase;\n      }\n\n      // Determine the string representation of the unsupported type\n      // If it's a non-null object, use JSON.stringify for detailed output\n      // Otherwise, use String() for basic conversion\n      const typeString =\n        typeof type === 'object' && type !== null ? JSON.stringify(type) : String(type);\n      throw new Error(`Unsupported type: ${typeString}`);\n    }\n\n    return target;\n  }\n\n  /**\n   * Resolves all resolver targets for the specified type\n   * @param type Type to resolve\n   * @returns Array of all matching resolver targets sorted by priority (highest first).\n   *          Returns an empty array if no handlers match and no fallback is set.\n   *          Note: Unlike resolve(), this method does not throw when no handlers match.\n   * @throws {Error} When no resolver targets are registered\n   */\n  public resolveAll(type: TType): TBase[] {\n    if (this.updaters.length < 1) {\n      throw new Error('Unassigned resolve target.');\n    }\n\n    const targets = this.updaters.filter((updater) => updater.supports(type));\n\n    if (targets.length === 0) {\n      // If fallback handler is set, return it as a single-element array\n      if (this.fallbackHandler) {\n        return [\n          {\n            supports: () => true,\n            handle: this.fallbackHandler,\n          } as unknown as TBase,\n        ];\n      }\n\n      // Return empty array if no handlers match\n      return [];\n    }\n\n    // Sort by priority (highest first)\n    return this.sortByPriority(targets);\n  }\n\n  /**\n   * Executes all matching handlers for the specified type\n   * @param type Type to resolve\n   * @param args Arguments to pass to the handlers\n   * @returns Array of results from all matching handlers\n   * @throws {Error} When no resolver targets are registered\n   */\n  public handleAll(\n    type: TType,\n    ...args: Parameters<TBase['handle']>\n  ): ReturnType<TBase['handle']>[] {\n    const targets = this.resolveAll(type);\n    return targets.map((target) => target.handle(...args));\n  }\n\n  /**\n   * Executes all matching async handlers in parallel for the specified type\n   * @param type Type to resolve\n   * @param args Arguments to pass to the handlers\n   * @returns Promise that resolves to array of results from all matching handlers\n   * @throws {Error} When no resolver targets are registered\n   */\n  public async handleAllAsync(\n    type: TType,\n    ...args: Parameters<TBase['handle']>\n  ): Promise<Awaited<ReturnType<TBase['handle']>>[]> {\n    const targets = this.resolveAll(type);\n    const promises = targets.map((target) => target.handle(...args));\n    return Promise.all(promises);\n  }\n\n  /**\n   * Executes all matching async handlers sequentially for the specified type\n   * Stops on first error\n   * @param type Type to resolve\n   * @param args Arguments to pass to the handlers\n   * @returns Promise that resolves to array of results from all matching handlers\n   * @throws {Error} When no resolver targets are registered\n   * @throws {Error} When any handler throws an error\n   */\n  public async handleAllSequential(\n    type: TType,\n    ...args: Parameters<TBase['handle']>\n  ): Promise<Awaited<ReturnType<TBase['handle']>>[]> {\n    const targets = this.resolveAll(type);\n    const results: Awaited<ReturnType<TBase['handle']>>[] = [];\n\n    for (const target of targets) {\n      const result = await target.handle(...args);\n      results.push(result);\n    }\n\n    return results;\n  }\n}\n\nexport default Resolver;\n","export * from './interface';\nimport Resolver from './resolver';\nexport default Resolver;\n// Export for CommonJS compatibility\n// @ts-ignore\nmodule.exports = Resolver;\n"],"names":["Resolver","args","updaters","updater","handler","handlerWithPriority","handlers","a","b","priorityA","type","matchingHandlers","target","typeString","targets","promises","results","result"],"mappings":"aAMA,MAAMA,CAGJ,CAKQ,SAAoB,CAAA,EAMpB,gBAMR,eAAeC,EAAe,CACxBA,EAAK,OAAS,GAChB,KAAK,IAAIA,CAAI,CAEjB,CAQQ,QAAQA,EAAwB,CACtC,MAAO,CAAC,GAAGA,CAAI,CACjB,CAMO,IAAIC,EAAyB,CAClC,KAAK,SAAWA,CAClB,CAMO,eAAeD,EAAqB,CACzC,KAAK,IAAI,KAAK,QAAQA,CAAI,CAAC,CAC7B,CAMO,WAAWE,EAAsB,CACtC,YAAK,SAAS,KAAKA,CAAO,EACnB,IACT,CAOO,mBACLC,EACM,CACN,YAAK,gBAAkBA,EAChB,IACT,CAQQ,YAAYA,EAAwB,CAC1C,MAAMC,EAAsBD,EAC5B,OAAO,OAAOC,EAAoB,UAAa,SAAWA,EAAoB,SAAW,CAC3F,CAQQ,eAAeC,EAA4B,CACjD,MAAO,CAAC,GAAGA,CAAQ,EAAE,KAAK,CAACC,EAAGC,IAAM,CAClC,MAAMC,EAAY,KAAK,YAAYF,CAAC,EAEpC,OADkB,KAAK,YAAYC,CAAC,EACjBC,CACrB,CAAC,CACH,CASO,QAAQC,EAAoB,CACjC,GAAI,KAAK,SAAS,OAAS,EACzB,MAAM,IAAI,MAAM,4BAA4B,EAI9C,MAAMC,EAAmB,KAAK,SAAS,OAAQR,GAAYA,EAAQ,SAASO,CAAI,CAAC,EAE3EE,EADiB,KAAK,eAAeD,CAAgB,EAC7B,CAAC,EAE/B,GAAI,CAACC,EAAQ,CAEX,GAAI,KAAK,gBACP,MAAO,CACL,SAAU,IAAM,GAChB,OAAQ,KAAK,eAAA,EAOjB,MAAMC,EACJ,OAAOH,GAAS,UAAYA,IAAS,KAAO,KAAK,UAAUA,CAAI,EAAI,OAAOA,CAAI,EAChF,MAAM,IAAI,MAAM,qBAAqBG,CAAU,EAAE,CACnD,CAEA,OAAOD,CACT,CAUO,WAAWF,EAAsB,CACtC,GAAI,KAAK,SAAS,OAAS,EACzB,MAAM,IAAI,MAAM,4BAA4B,EAG9C,MAAMI,EAAU,KAAK,SAAS,OAAQX,GAAYA,EAAQ,SAASO,CAAI,CAAC,EAExE,OAAII,EAAQ,SAAW,EAEjB,KAAK,gBACA,CACL,CACE,SAAU,IAAM,GAChB,OAAQ,KAAK,eAAA,CACf,EAKG,CAAA,EAIF,KAAK,eAAeA,CAAO,CACpC,CASO,UACLJ,KACGT,EAC4B,CAE/B,OADgB,KAAK,WAAWS,CAAI,EACrB,IAAKE,GAAWA,EAAO,OAAO,GAAGX,CAAI,CAAC,CACvD,CASA,MAAa,eACXS,KACGT,EAC8C,CAEjD,MAAMc,EADU,KAAK,WAAWL,CAAI,EACX,IAAKE,GAAWA,EAAO,OAAO,GAAGX,CAAI,CAAC,EAC/D,OAAO,QAAQ,IAAIc,CAAQ,CAC7B,CAWA,MAAa,oBACXL,KACGT,EAC8C,CACjD,MAAMa,EAAU,KAAK,WAAWJ,CAAI,EAC9BM,EAAkD,CAAA,EAExD,UAAWJ,KAAUE,EAAS,CAC5B,MAAMG,EAAS,MAAML,EAAO,OAAO,GAAGX,CAAI,EAC1Ce,EAAQ,KAAKC,CAAM,CACrB,CAEA,OAAOD,CACT,CACF,CChOA,OAAO,QAAUhB"}

package/dist/index.d.ts

@@ -1,3 +1,190 @@
-export * from './interface';
-import Resolver from './resolver';
-export default Resolver;
+/**
+ * Interface for async resolver targets
+ * Handle method returns a Promise
+ */
+export declare interface AsyncResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> extends SupportsType<TType> {
+    /**
+     * Handles the request asynchronously
+     * @param args Arguments needed for processing
+     * @returns Promise with processing result
+     */
+    handle(...args: TArgs): Promise<TReturn>;
+}
+
+/**
+ * Interface for prioritized handlers
+ * Higher priority values are executed first
+ */
+export declare interface HasPriority {
+    /**
+     * Priority for this handler (higher values execute first)
+     * Default is 0 if not specified
+     */
+    priority?: number;
+}
+
+export declare namespace interfaces {
+    export interface ResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> {
+        supports(type: TType): boolean;
+        handle(...args: TArgs): TReturn;
+    }
+    export interface PrioritizedResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> extends ResolveTarget<TArgs, TReturn, TType> {
+        priority?: number;
+    }
+    export interface AsyncResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> {
+        supports(type: TType): boolean;
+        handle(...args: TArgs): Promise<TReturn>;
+    }
+    export interface PrioritizedAsyncResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> extends AsyncResolveTarget<TArgs, TReturn, TType> {
+        priority?: number;
+    }
+}
+
+/**
+ * Interface for async resolver targets with priority support
+ * Higher priority values are executed first
+ */
+export declare interface PrioritizedAsyncResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> extends AsyncResolveTarget<TArgs, TReturn, TType>, HasPriority {
+}
+
+/**
+ * Interface for resolver targets with priority support
+ * Higher priority values are executed first
+ */
+export declare interface PrioritizedResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> extends ResolveTarget<TArgs, TReturn, TType>, HasPriority {
+}
+
+/**
+ * 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;
+    /**
+     * Gets the priority of a handler
+     * @param handler The handler to get priority for
+     * @returns Priority value (0 if not defined)
+     * @private
+     */
+    private getPriority;
+    /**
+     * Sorts handlers by priority (highest first), maintaining registration order for equal priorities
+     * @param handlers Array of handlers to sort
+     * @returns Sorted array of handlers
+     * @private
+     */
+    private sortByPriority;
+    /**
+     * 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;
+    /**
+     * Resolves all resolver targets for the specified type
+     * @param type Type to resolve
+     * @returns Array of all matching resolver targets sorted by priority (highest first).
+     *          Returns an empty array if no handlers match and no fallback is set.
+     *          Note: Unlike resolve(), this method does not throw when no handlers match.
+     * @throws {Error} When no resolver targets are registered
+     */
+    resolveAll(type: TType): TBase[];
+    /**
+     * Executes all matching handlers for the specified type
+     * @param type Type to resolve
+     * @param args Arguments to pass to the handlers
+     * @returns Array of results from all matching handlers
+     * @throws {Error} When no resolver targets are registered
+     */
+    handleAll(type: TType, ...args: Parameters<TBase['handle']>): ReturnType<TBase['handle']>[];
+    /**
+     * Executes all matching async handlers in parallel for the specified type
+     * @param type Type to resolve
+     * @param args Arguments to pass to the handlers
+     * @returns Promise that resolves to array of results from all matching handlers
+     * @throws {Error} When no resolver targets are registered
+     */
+    handleAllAsync(type: TType, ...args: Parameters<TBase['handle']>): Promise<Awaited<ReturnType<TBase['handle']>>[]>;
+    /**
+     * Executes all matching async handlers sequentially for the specified type
+     * Stops on first error
+     * @param type Type to resolve
+     * @param args Arguments to pass to the handlers
+     * @returns Promise that resolves to array of results from all matching handlers
+     * @throws {Error} When no resolver targets are registered
+     * @throws {Error} When any handler throws an error
+     */
+    handleAllSequential(type: TType, ...args: Parameters<TBase['handle']>): Promise<Awaited<ReturnType<TBase['handle']>>[]>;
+}
+export default Resolver;
+
+/**
+ * Interface that classes which are targets for the resolver should implement
+ */
+export declare interface ResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> extends SupportsType<TType> {
+    /**
+     * Handles the request
+     * @param args Arguments needed for processing
+     * @returns Processing result
+     */
+    handle(...args: TArgs): TReturn;
+}
+
+/**
+ * Base interface for type matching
+ * Extracted to reduce code duplication across sync and async targets
+ */
+export declare interface SupportsType<TType = string> {
+    /**
+     * Determines whether the specified type is supported
+     * @param type The type to check for support
+     * @returns true if supported, false otherwise
+     */
+    supports(type: TType): boolean;
+}
+
+export { }