class-resolver 1.1.1 → 2.1.0

package/README.md

@@ -1,13 +1,27 @@
 # Simple Class resolver
 
-## Getting started
+A lightweight TypeScript/JavaScript library for implementing the Chain of Responsibility pattern with class-based resolvers.
 
-```
-$ npm i -S class-resolver
-```
+## Features
+
+- Simple and intuitive API for handling different types of requests
+- Type-safe implementation with TypeScript support
+- Flexible resolver registration (constructor, setUpdaters, addUpdater)
+- Support for multiple resolvers with different handling logic
+- Clear error handling for unsupported types
+- Generic type support for better type safety
 
-## Example code
+## Installation
+
+```bash
+npm install class-resolver
+# or
+yarn add class-resolver
 ```
+
+## Basic Usage
+
+```typescript
 const Resolver = require('class-resolver')
 
 class ExampleClass {
@@ -26,32 +40,286 @@ class ExampleClass2 {
     return 'fuga'
   }
 }
-console.log(Resolver)
+
 const resolver = new Resolver(new ExampleClass(), new ExampleClass2())
 const c = resolver.resolve('hoge')
-console.log(c.handle())
+console.log(c.handle()) // Output: hoge
+
 const c2 = resolver.resolve('fuga')
-console.log(c2.handle())
+console.log(c2.handle()) // Output: fuga
 
 try {
-  resolver.resolve('xxx')
+  resolver.resolve('xxx') // This will throw an error
 } catch (e) {
-  console.log(e)
+  console.log(e) // Error: Unsupported type: xxx
 }
 ```
 
-Execute result
+## Advanced Usage
+
+### With TypeScript and Parameters
+
+```typescript
+import Resolver from 'class-resolver';
+import { ResolveTarget } from 'class-resolver';
+
+// Using generics for better type safety
+class MessageFormatter implements ResolveTarget<[string, number], string> {
+  supports(type: string): boolean {
+    return type === 'greeting'
+  }
+  
+  handle(name: string, count: number): string {
+    return `Hello ${name}, this is message #${count}!`
+  }
+}
+
+class ErrorFormatter implements ResolveTarget<[string, number], string> {
+  supports(type: string): boolean {
+    return type === 'error'
+  }
+  
+  handle(message: string, code: number): string {
+    return `Error ${code}: ${message}`
+  }
+}
+
+// Specify the generic type for better type safety
+const resolver = new Resolver<ResolveTarget<[string, number], string>>(
+  new MessageFormatter(), 
+  new ErrorFormatter()
+)
+
+// Using the greeting formatter
+const greeting = resolver.resolve('greeting')
+console.log(greeting.handle('John', 1)) // Output: Hello John, this is message #1!
 
+// Using the error formatter
+const error = resolver.resolve('error')
+console.log(error.handle('Not Found', 404)) // Output: Error 404: Not Found
 ```
-$ node index.js
-hoge
-fuga
-Error: Unsupported type: xxx
+
+### Dynamic Resolver Registration
+
+```typescript
+// Specify the generic type for better type safety
+const resolver = new Resolver<ResolveTarget<[string, number], string>>()
+
+// Add resolvers after initialization
+resolver.setUpdaters(new MessageFormatter(), new ErrorFormatter())
+
+// Or add them one by one
+resolver.addUpdater(new MessageFormatter())
+resolver.addUpdater(new ErrorFormatter())
 ```
 
-## Contributing
+## Generic Type Support
+
+From version 2.0.0, class-resolver supports generic types for better type safety:
+
+```typescript
+// Define the interface with generics
+interface ResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> {
+  supports(type: TType): boolean;
+  handle(...args: TArgs): TReturn;
+}
+
+// Define a class that implements the interface with specific types
+class StringFormatter implements ResolveTarget<[string], string> {
+  supports(type: string): boolean {
+    return type === 'string-format';
+  }
+  
+  handle(input: string): string {
+    return input.toUpperCase();
+  }
+}
 
+// Create a resolver with the specific type
+const resolver = new Resolver<ResolveTarget<[string], string>>(new StringFormatter());
+const formatter = resolver.resolve('string-format');
+const result = formatter.handle('hello'); // result is typed as string
 ```
+
+### Advanced Type Support
+
+You can now use any type for the `supports` method, not just strings. This is particularly useful for handling complex objects like Stripe events:
+
+```typescript
+// Define a complex event type
+interface StripeEvent {
+  id: string;
+  type: string;
+  data: {
+    object: {
+      id: string;
+      amount: number;
+    };
+  };
+}
+
+// Create handlers for specific event types
+class PaymentEventHandler implements ResolveTarget<[StripeEvent], string, StripeEvent> {
+  supports(event: StripeEvent): boolean {
+    return event.type === 'payment_intent.succeeded';
+  }
+  
+  handle(event: StripeEvent): string {
+    return `Payment succeeded: ${event.data.object.amount}`;
+  }
+}
+
+class RefundEventHandler implements ResolveTarget<[StripeEvent], string, StripeEvent> {
+  supports(event: StripeEvent): boolean {
+    return event.type === 'charge.refunded';
+  }
+  
+  handle(event: StripeEvent): string {
+    return `Refund processed: ${event.data.object.amount}`;
+  }
+}
+
+// Create a resolver that handles StripeEvent types
+const resolver = new Resolver<ResolveTarget<[StripeEvent], string, StripeEvent>, StripeEvent>(
+  new PaymentEventHandler(),
+  new RefundEventHandler()
+);
+
+// Handle different event types
+const paymentEvent: StripeEvent = {
+  id: 'evt_123',
+  type: 'payment_intent.succeeded',
+  data: { object: { id: 'pi_123', amount: 1000 } }
+};
+
+const handler = resolver.resolve(paymentEvent);
+console.log(handler.handle(paymentEvent)); // Output: Payment succeeded: 1000
+```
+
+This advanced type support allows you to:
+- Use complex objects as type identifiers instead of simple strings
+- Maintain full type safety throughout the resolution process
+- Handle domain-specific objects like Stripe events, database records, or custom business objects
+- Create more expressive and type-safe event handling systems
+
+## 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
+
+## Error Handling
+
+The resolver will throw errors in the following cases:
+- When no resolvers are registered: `"Unasigned resolve target."`
+- When trying to resolve an unsupported type: `"Unsupported type: xxx"`
+
+## Upgrade Guide
+
+### Upgrading from 1.x to 2.0.0
+
+Version 2.0.0 introduces generic type support for better type safety. This change is backward compatible for JavaScript users, but TypeScript users may need to update their code.
+
+#### Changes for TypeScript Users
+
+1. The `ResolveTarget` interface now supports generics:
+   ```typescript
+   // Before (1.x)
+   interface ResolveTarget {
+     supports(type: string): boolean;
+     handle(...args: any[]): any;
+   }
+   
+   // After (2.0.0)
+   interface ResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> {
+     supports(type: TType): boolean;
+     handle(...args: TArgs): TReturn;
+   }
+   ```
+
+2. The `Resolver` class now supports generics:
+   ```typescript
+   // Before (1.x)
+   class Resolver {
+     // ...
+   }
+   
+   // After (2.0.0)
+   class Resolver<TBase extends ResolveTarget<any[], any, any> = ResolveTarget<any[], any, any>, TType = string> {
+     // ...
+   }
+   ```
+
+3. **New in 2.0.0**: You can now specify custom types for the `supports` method:
+   ```typescript
+   // Use custom types instead of strings
+   interface CustomEvent {
+     type: string;
+     data: any;
+   }
+   
+   class CustomHandler implements ResolveTarget<[CustomEvent], string, CustomEvent> {
+     supports(event: CustomEvent): boolean {
+       return event.type === 'custom-type';
+     }
+     
+     handle(event: CustomEvent): string {
+       return `Handled: ${event.type}`;
+     }
+   }
+   ```
+
+#### Migration Steps
+
+1. If you're using TypeScript with default `any` types, your code should continue to work without changes.
+
+2. To take advantage of the improved type safety, update your class implementations:
+   ```typescript
+   // Before (1.x)
+   class MyHandler implements ResolveTarget {
+     supports(type: string): boolean {
+       return type === 'my-type';
+     }
+     handle(name: string): string {
+       return `Hello ${name}`;
+     }
+   }
+   
+   // After (2.0.0)
+   class MyHandler implements ResolveTarget<[string], string> {
+     supports(type: string): boolean {
+       return type === 'my-type';
+     }
+     handle(name: string): string {
+       return `Hello ${name}`;
+     }
+   }
+   ```
+
+3. When creating a new Resolver, specify the generic type:
+   ```typescript
+   // Before (1.x)
+   const resolver = new Resolver(new MyHandler());
+   
+   // After (2.0.0)
+   const resolver = new Resolver<ResolveTarget<[string], string>>(new MyHandler());
+   ```
+
+4. If you have mixed handler types, you can use a union type or keep using the default `any` type:
+   ```typescript
+   // Using union type
+   type MyHandlers = ResolveTarget<[string], string> | ResolveTarget<[number], boolean>;
+   const resolver = new Resolver<MyHandlers>(new StringHandler(), new NumberHandler());
+   
+   // Or keep using the default any type
+   const resolver = new Resolver(new StringHandler(), new NumberHandler());
+   ```
+
+## Contributing
+
+```bash
 $ npm install
 $ git checkout -b YOUR_TOPIC_BRANCH
 $ npm test
@@ -59,4 +327,8 @@ $ npm run build
 $ git add ./
 $ git commit -m "YOUR UPDATE DESCRIPTION"
 $ git push YOUR_ORIGIN YOUR_TOPIC_BRANCH
-```
+```
+
+## License
+
+MIT

package/dist/index.js

@@ -1,8 +1,26 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interface"), exports);
 const resolver_1 = __importDefault(require("./resolver"));
 exports.default = resolver_1.default;
+// Export for CommonJS compatibility
+// @ts-ignore
 module.exports = resolver_1.default;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../libs/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,8CAA2B;AAC3B,0DAAiC;AACjC,kBAAe,kBAAQ,CAAA;AACvB,oCAAoC;AACpC,aAAa;AACb,MAAM,CAAC,OAAO,GAAG,kBAAQ,CAAA"}

package/dist/interface.d.ts

@@ -1,10 +1,23 @@
-export interface ResolveTarget {
-    supports(type: string): boolean;
-    handle(...args: any): any;
+/**
+ * Interface that classes which are targets for the resolver should implement
+ */
+export interface ResolveTarget<TArgs extends any[] = any[], TReturn = any, 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;
+    /**
+     * Handles the request
+     * @param args Arguments needed for processing
+     * @returns Processing result
+     */
+    handle(...args: TArgs): TReturn;
 }
 export declare namespace interfaces {
-    interface ResolveTarget {
-        supports(type: string): boolean;
-        handle(...args: any): any;
+    interface ResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> {
+        supports(type: TType): boolean;
+        handle(...args: TArgs): TReturn;
     }
 }

package/dist/interface.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/dist/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.js","sourceRoot":"","sources":["../libs/interface.ts"],"names":[],"mappings":""}

package/dist/resolver.d.ts

@@ -1,12 +1,48 @@
-import { interfaces } from './interface';
-import ResolveTarget = interfaces.ResolveTarget;
-declare class Resolver {
-    private updater;
-    constructor(...args: ResolveTarget[]);
-    getArgs(arg: ResolveTarget[]): ResolveTarget[];
-    set(updaters: ResolveTarget[]): void;
-    setUpdaters(...args: ResolveTarget[]): void;
-    addUpdater(updater: ResolveTarget): void;
-    resolve(type: string): ResolveTarget;
+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;
+    /**
+     * 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): void;
+    /**
+     * 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
+     */
+    resolve(type: TType): TBase;
 }
 export default Resolver;

package/dist/resolver.js

@@ -1,29 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Resolver class implementing the Chain of Responsibility pattern
+ * Resolves handlers for specific types
+ */
 class Resolver {
+    /**
+     * Initializes the resolver
+     * @param args Initial resolver targets
+     */
     constructor(...args) {
-        this.updater = [];
-        this.set(this.getArgs(args));
+        /**
+         * Array of registered resolver targets
+         * @private
+         */
+        this.updaters = [];
+        if (args.length > 0) {
+            this.set(args);
+        }
     }
-    getArgs(arg) {
-        return Array.prototype.slice.call(arg, 0);
+    /**
+     * Processes an array of arguments
+     * @param args Array of resolver targets
+     * @returns Processed array
+     * @private
+     */
+    getArgs(args) {
+        return [...args];
     }
+    /**
+     * Sets resolver targets
+     * @param updaters Array of resolver targets
+     */
     set(updaters) {
-        this.updater = updaters;
+        this.updaters = updaters;
     }
+    /**
+     * Sets resolver targets (variadic version)
+     * @param args Resolver targets
+     */
     setUpdaters(...args) {
         this.set(this.getArgs(args));
     }
+    /**
+     * Adds a resolver target
+     * @param updater Resolver target to add
+     */
     addUpdater(updater) {
-        this.updater.push(updater);
+        this.updaters.push(updater);
     }
+    /**
+     * 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
+     */
     resolve(type) {
-        if (this.updater.length < 1)
+        if (this.updaters.length < 1) {
             throw new Error('Unasigned resolve target.');
-        const target = this.updater.filter(updater => updater.supports(type));
-        if (target.length < 1)
+        }
+        const target = this.updaters.find(updater => updater.supports(type));
+        if (!target) {
             throw new Error(`Unsupported type: ${type}`);
-        return target[0];
+        }
+        return target;
     }
 }
 exports.default = Resolver;
+//# sourceMappingURL=resolver.js.map

package/dist/resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../libs/resolver.ts"],"names":[],"mappings":";;AAEA;;;GAGG;AACH,MAAM,QAAQ;IAOZ;;;OAGG;IACH,YAAY,GAAG,IAAa;QAV5B;;;WAGG;QACK,aAAQ,GAAY,EAAE,CAAC;QAO7B,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,OAAO,CAAC,IAAa;QAC3B,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IACnB,CAAC;IAED;;;OAGG;IACI,GAAG,CAAC,QAAiB;QAC1B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACI,WAAW,CAAC,GAAG,IAAa;QACjC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACI,UAAU,CAAC,OAAc;QAC9B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;OAMG;IACI,OAAO,CAAC,IAAW;QACxB,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC/C,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QAErE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,qBAAqB,IAAI,EAAE,CAAC,CAAC;QAC/C,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAED,kBAAe,QAAQ,CAAC"}

package/index.js

@@ -1,3 +1,5 @@
-const Resolver = require('./libs/resolver')
+'use strict';
 
-module.exports = Resolver.default || Resolver
+const Resolver = require('./dist/index');
+
+module.exports = Resolver.default || Resolver;

package/libs/index.ts

@@ -1,4 +1,6 @@
 export * from './interface'
 import Resolver from './resolver'
 export default Resolver
+// Export for CommonJS compatibility
+// @ts-ignore
 module.exports = Resolver

package/libs/interface.ts

@@ -1,10 +1,26 @@
-export interface ResolveTarget {
-  supports(type: string): boolean
-  handle(...args:any): any
+/**
+ * Interface that classes which are targets for the resolver should implement
+ */
+export interface ResolveTarget<TArgs extends any[] = any[], TReturn = any, 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
+  
+  /**
+   * Handles the request
+   * @param args Arguments needed for processing
+   * @returns Processing result
+   */
+  handle(...args: TArgs): TReturn
 }
+
+// Maintain namespace for backward compatibility
 export namespace interfaces {
-  export interface ResolveTarget {
-    supports(type: string): boolean
-    handle(...args:any): any
+  export interface ResolveTarget<TArgs extends any[] = any[], TReturn = any, TType = string> {
+    supports(type: TType): boolean
+    handle(...args: TArgs): TReturn
   }
 }

package/libs/resolver.ts

@@ -1,29 +1,80 @@
-import { interfaces } from './interface'
-import ResolveTarget = interfaces.ResolveTarget
-
-class Resolver {
-  private updater: ResolveTarget[]
-  constructor (...args: ResolveTarget[]) {
-    this.updater = []
-    this.set(this.getArgs(args))
+import { ResolveTarget } from './interface'
+
+/**
+ * Resolver class implementing the Chain of Responsibility pattern
+ * Resolves handlers for specific types
+ */
+class Resolver<TBase extends ResolveTarget<any[], any, any> = ResolveTarget<any[], any, any>, TType = string> {
+  /**
+   * Array of registered resolver targets
+   * @private
+   */
+  private updaters: TBase[] = [];
+
+  /**
+   * Initializes the resolver
+   * @param args Initial resolver targets
+   */
+  constructor(...args: TBase[]) {
+    if (args.length > 0) {
+      this.set(args);
+    }
   }
-  getArgs (arg: ResolveTarget[]): ResolveTarget[] {
-    return Array.prototype.slice.call(arg, 0)
+
+  /**
+   * Processes an array of arguments
+   * @param args Array of resolver targets
+   * @returns Processed array
+   * @private
+   */
+  private getArgs(args: TBase[]): TBase[] {
+    return [...args];
   }
-  set (updaters: ResolveTarget[]) {
-    this.updater = updaters
+
+  /**
+   * Sets resolver targets
+   * @param updaters Array of resolver targets
+   */
+  public set(updaters: TBase[]): void {
+    this.updaters = updaters;
   }
-  setUpdaters (...args: ResolveTarget[]) {
-    this.set(this.getArgs(args))
+
+  /**
+   * Sets resolver targets (variadic version)
+   * @param args Resolver targets
+   */
+  public setUpdaters(...args: TBase[]): void {
+    this.set(this.getArgs(args));
   }
-  addUpdater (updater: ResolveTarget) {
-    this.updater.push(updater)
+
+  /**
+   * Adds a resolver target
+   * @param updater Resolver target to add
+   */
+  public addUpdater(updater: TBase): void {
+    this.updaters.push(updater);
   }
-  resolve (type: string): ResolveTarget {
-    if (this.updater.length < 1) throw new Error('Unasigned resolve target.')
-    const target = this.updater.filter(updater => updater.supports(type))
-    if (target.length < 1) throw new Error(`Unsupported type: ${type}`)
-    return target[0]
+
+  /**
+   * 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
+   */
+  public resolve(type: TType): TBase {
+    if (this.updaters.length < 1) {
+      throw new Error('Unasigned resolve target.');
+    }
+    
+    const target = this.updaters.find(updater => updater.supports(type));
+    
+    if (!target) {
+      throw new Error(`Unsupported type: ${type}`);
+    }
+    
+    return target;
   }
 }
-export default Resolver
+
+export default Resolver;

package/package.json

@@ -1,23 +1,29 @@
 {
   "name": "class-resolver",
-  "version": "1.1.1",
+  "version": "2.1.0",
   "description": "Simple class resolver.",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
     "test": "jest",
     "test:watch": "jest --watch",
-    "test:dev": "jest --watch --silent=false --verbose false --coverage"
+    "test:dev": "jest --watch --silent=false --verbose false --coverage",
+    "prepublishOnly": "npm run build"
   },
-  "keywords": [],
+  "keywords": [
+    "resolver",
+    "chain-of-responsibility",
+    "typescript"
+  ],
   "author": "Hidetaka Okamoto <info@wp-kyoto.net> (https://wp-kyoto.net)",
   "license": "MIT",
   "devDependencies": {
-    "@types/jest": "^23.3.10",
-    "@types/node": "^11.10.4",
-    "jest": "^24.8.0",
-    "ts-jest": "^23.10.5",
-    "typescript": "^3.2.2"
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
   },
   "jest": {
     "moduleFileExtensions": [
@@ -26,15 +32,22 @@
       "js"
     ],
     "transform": {
-      "^.+\\.(ts|tsx)$": "ts-jest"
-    },
-    "globals": {
-      "ts-jest": {
-        "tsConfigFile": "tsconfig.json"
-      }
+      "^.+\\.(ts|tsx)$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.json"
+        }
+      ]
     },
     "testMatch": [
       "**/__tests__/*.+(ts|tsx|js)"
     ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hideokamoto/class-resolver.git"
+  },
+  "engines": {
+    "node": ">=14.0.0"
   }
 }

package/readme-ja.md

@@ -0,0 +1,301 @@
+# Simple Class resolver
+
+クラスベースのリゾルバーを使用して責任連鎖パターンを実装するための軽量なTypeScript/JavaScriptライブラリです。
+
+## 特徴
+
+- さまざまなタイプのリクエストを処理するためのシンプルで直感的なAPI
+- TypeScriptによる型安全な実装
+- 柔軟なリゾルバー登録（コンストラクタ、setUpdaters、addUpdater）
+- 異なる処理ロジックを持つ複数のリゾルバーのサポート
+- サポートされていないタイプに対する明確なエラー処理
+- より良い型安全性のためのジェネリック型サポート
+
+## インストール
+
+```bash
+npm install class-resolver
+# または
+yarn add class-resolver
+```
+
+## 基本的な使い方
+
+```typescript
+const Resolver = require('class-resolver')
+
+class ExampleClass {
+  supports(type) {
+    return type === 'hoge'
+  }
+  handle() {
+    return 'hoge'
+  }
+}
+class ExampleClass2 {
+  supports(type) {
+    return type === 'fuga'
+  }
+  handle() {
+    return 'fuga'
+  }
+}
+
+const resolver = new Resolver(new ExampleClass(), new ExampleClass2())
+const c = resolver.resolve('hoge')
+console.log(c.handle()) // 出力: hoge
+
+const c2 = resolver.resolve('fuga')
+console.log(c2.handle()) // 出力: fuga
+
+try {
+  resolver.resolve('xxx') // これはエラーをスローします
+} catch (e) {
+  console.log(e) // Error: Unsupported type: xxx
+}
+```
+
+## 高度な使い方
+
+### TypeScriptとパラメータの使用
+
+```typescript
+import Resolver from 'class-resolver';
+import { ResolveTarget } from 'class-resolver';
+
+// より良い型安全性のためにジェネリクスを使用
+class MessageFormatter implements ResolveTarget<[string, number], string> {
+  supports(type: string): boolean {
+    return type === 'greeting'
+  }
+  
+  handle(name: string, count: number): string {
+    return `Hello ${name}, this is message #${count}!`
+  }
+}
+
+class ErrorFormatter implements ResolveTarget<[string, number], string> {
+  supports(type: string): boolean {
+    return type === 'error'
+  }
+  
+  handle(message: string, code: number): string {
+    return `Error ${code}: ${message}`
+  }
+}
+
+// より良い型安全性のためにジェネリック型を指定
+const resolver = new Resolver<ResolveTarget<[string, number], string>>(
+  new MessageFormatter(), 
+  new ErrorFormatter()
+)
+
+// グリーティングフォーマッターの使用
+const greeting = resolver.resolve('greeting')
+console.log(greeting.handle('John', 1)) // 出力: Hello John, this is message #1!
+
+// エラーフォーマッターの使用
+const error = resolver.resolve('error')
+console.log(error.handle('Not Found', 404)) // 出力: Error 404: Not Found
+```
+
+### 動的リゾルバー登録
+
+```typescript
+// より良い型安全性のためにジェネリック型を指定
+const resolver = new Resolver<ResolveTarget<[string, number], string>>()
+
+// 初期化後にリゾルバーを追加
+resolver.setUpdaters(new MessageFormatter(), new ErrorFormatter())
+
+// または一つずつ追加
+resolver.addUpdater(new MessageFormatter())
+resolver.addUpdater(new ErrorFormatter())
+```
+
+## ジェネリック型サポート
+
+バージョン2.0.0から、class-resolverはより良い型安全性のためにジェネリック型をサポートしています：
+
+```typescript
+// ジェネリクスを使用したインターフェースの定義
+interface ResolveTarget<TArgs extends any[] = any[], TReturn = any> {
+  supports(type: string): boolean;
+  handle(...args: TArgs): TReturn;
+}
+
+// 特定の型でインターフェースを実装するクラスを定義
+class StringFormatter implements ResolveTarget<[string], string> {
+  supports(type: string): boolean {
+    return type === 'string-format';
+  }
+  
+  handle(input: string): string {
+    return input.toUpperCase();
+  }
+}
+
+// 特定の型でリゾルバーを作成
+const resolver = new Resolver<ResolveTarget<[string], string>>(new StringFormatter());
+const formatter = resolver.resolve('string-format');
+const result = formatter.handle('hello'); // resultはstring型として型付けされます
+```
+
+## ユースケース
+
+1. **コマンドパターンの実装**: 特定のハンドラーで異なるタイプのコマンドを処理
+2. **フォーマット変換**: タイプに基づいてデータを異なるフォーマット間で変換
+3. **リクエスト処理**: 専用のハンドラーで異なるタイプのリクエストを処理
+4. **プラグインシステム**: 異なるプラグインが特定のタイプの操作を処理するプラグインシステムを実装
+5. **メッセージフォーマット**: 特定のフォーマッターで異なるタイプのメッセージをフォーマット
+
+## エラー処理
+
+リゾルバーは以下の場合にエラーをスローします：
+- リゾルバーが登録されていない場合: `"Unasigned resolve target."`
+- サポートされていないタイプを解決しようとした場合: `"Unsupported type: xxx"`
+
+## アップグレードガイド
+
+### 1.xから2.0.0へのアップグレード
+
+バージョン2.0.0では、より良い型安全性のためにジェネリック型サポートが導入されました。この変更はJavaScriptユーザーにとって後方互換性がありますが、TypeScriptユーザーはコードを更新する必要があるかもしれません。
+
+#### TypeScriptユーザーの変更点
+
+1. `ResolveTarget`インターフェースがジェネリクスをサポートするようになりました：
+   ```typescript
+   // 以前 (1.x)
+   interface ResolveTarget {
+     supports(type: string): boolean;
+     handle(...args: any[]): any;
+   }
+   
+   // 以後 (2.0.0)
+   interface ResolveTarget<TArgs extends any[] = any[], TReturn = any> {
+     supports(type: string): boolean;
+     handle(...args: TArgs): TReturn;
+   }
+   ```
+
+2. `Resolver`クラスがジェネリクスをサポートするようになりました：
+   ```typescript
+   // 以前 (1.x)
+   class Resolver {
+     // ...
+   }
+   
+   // 以後 (2.0.0)
+   class Resolver<TBase extends ResolveTarget = ResolveTarget> {
+     // ...
+   }
+   ```
+
+#### 移行手順
+
+1. デフォルトの`any`型を使用してTypeScriptを使用している場合、コードは変更なしで引き続き動作するはずです。
+
+2. 改善された型安全性を活用するには、クラスの実装を更新してください：
+   ```typescript
+   // 以前 (1.x)
+   class MyHandler implements ResolveTarget {
+     supports(type: string): boolean {
+       return type === 'my-type';
+     }
+     handle(name: string): string {
+       return `Hello ${name}`;
+     }
+   }
+   
+   // 以後 (2.0.0)
+   class MyHandler implements ResolveTarget<[string], string> {
+     supports(type: string): boolean {
+       return type === 'my-type';
+     }
+     handle(name: string): string {
+       return `Hello ${name}`;
+     }
+   }
+   ```
+
+3. 新しいResolverを作成する際に、ジェネリック型を指定してください：
+   ```typescript
+   // 以前 (1.x)
+   const resolver = new Resolver(new MyHandler());
+   
+   // 以後 (2.0.0)
+   const resolver = new Resolver<ResolveTarget<[string], string>>(new MyHandler());
+   ```
+
+4. 混合ハンドラータイプがある場合は、ユニオン型を使用するか、デフォルトの`any`型を引き続き使用できます：
+   ```typescript
+   // ユニオン型の使用
+   type MyHandlers = ResolveTarget<[string], string> | ResolveTarget<[number], boolean>;
+   const resolver = new Resolver<MyHandlers>(new StringHandler(), new NumberHandler());
+   
+   // またはデフォルトのany型を引き続き使用
+   const resolver = new Resolver(new StringHandler(), new NumberHandler());
+   ```
+
+## 貢献
+
+```bash
+$ npm install
+$ git checkout -b YOUR_TOPIC_BRANCH
+$ npm test
+$ npm run build
+$ git add ./
+$ git commit -m "YOUR UPDATE DESCRIPTION"
+$ git push YOUR_ORIGIN YOUR_TOPIC_BRANCH
+```
+
+## サンプル
+
+このライブラリには、使用方法を示すサンプルが含まれています。サンプルを実行するには：
+
+```bash
+# サンプルディレクトリに移動
+cd example
+
+# 依存関係をインストール
+npm install
+
+# ビルドを実行
+npm run build
+
+# サンプルを実行
+npm test
+```
+
+### JavaScriptサンプル
+
+JavaScriptでの基本的な使用例は`index.js`ファイルにあります：
+
+```bash
+node index.js
+```
+
+### TypeScriptサンプル
+
+TypeScriptでの使用例は`libs/index.ts`ファイルにあります。v2.0.0からはジェネリクスをサポートしており、型安全性が向上しています：
+
+```typescript
+import Resolver, { ResolveTarget } from 'class-resolver';
+
+// ジェネリクスを使用して引数と戻り値の型を指定
+class StringFormatter implements ResolveTarget<[string], string> {
+  supports(type: string): boolean {
+    return type === 'string-format';
+  }
+  
+  handle(input: string): string {
+    return input.toUpperCase();
+  }
+}
+
+// Resolverにも型パラメータを指定
+const resolver = new Resolver<ResolveTarget<[string], string>>(new StringFormatter());
+const formatter = resolver.resolve('string-format');
+const result = formatter.handle('hello'); // resultはstring型として型付けされます
+console.log(result); // "HELLO"
+``` 

package/dist/libs/interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/libs/resolver.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class Resolver {
-    constructor(...args) {
-        this.updater = [];
-        this.set(this.getArgs(args));
-    }
-    getArgs(arg) {
-        return Array.prototype.slice.call(arg, 0);
-    }
-    set(updaters) {
-        this.updater = updaters;
-    }
-    setUpdaters(...args) {
-        this.set(this.getArgs(args));
-    }
-    addUpdater(updater) {
-        this.updater.push(updater);
-    }
-    resolve(type) {
-        if (this.updater.length < 1)
-            throw new Error('Unasigned resolve target.');
-        const target = this.updater.filter(updater => updater.supports(type));
-        if (target.length < 1)
-            throw new Error(`Unsupported type: ${type}`);
-        return target[0];
-    }
-}
-exports.default = Resolver;