class-resolver 2.1.1 → 4.0.0

package/dist/index.mjs

@@ -0,0 +1,163 @@
+class i {
+  /**
+   * Array of registered resolver targets
+   * @private
+   */
+  updaters = [];
+  /**
+   * Fallback handler function
+   * @private
+   */
+  fallbackHandler;
+  /**
+   * Initializes the resolver
+   * @param args Initial resolver targets
+   */
+  constructor(...t) {
+    t.length > 0 && this.set(t);
+  }
+  /**
+   * Processes an array of arguments
+   * @param args Array of resolver targets
+   * @returns Processed array
+   * @private
+   */
+  getArgs(t) {
+    return [...t];
+  }
+  /**
+   * Sets resolver targets
+   * @param updaters Array of resolver targets
+   */
+  set(t) {
+    this.updaters = t;
+  }
+  /**
+   * Sets resolver targets (variadic version)
+   * @param args Resolver targets
+   */
+  setUpdaters(...t) {
+    this.set(this.getArgs(t));
+  }
+  /**
+   * Adds a resolver target
+   * @param updater Resolver target to add
+   */
+  addUpdater(t) {
+    return this.updaters.push(t), this;
+  }
+  /**
+   * Sets a fallback handler for unsupported types
+   * @param handler Fallback handler function
+   * @returns This resolver instance for method chaining
+   */
+  setFallbackHandler(t) {
+    return this.fallbackHandler = t, this;
+  }
+  /**
+   * Gets the priority of a handler
+   * @param handler The handler to get priority for
+   * @returns Priority value (0 if not defined)
+   * @private
+   */
+  getPriority(t) {
+    const r = t;
+    return typeof r.priority == "number" ? r.priority : 0;
+  }
+  /**
+   * 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
+   */
+  sortByPriority(t) {
+    return [...t].sort((r, s) => {
+      const e = this.getPriority(r);
+      return this.getPriority(s) - e;
+    });
+  }
+  /**
+   * 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(t) {
+    if (this.updaters.length < 1)
+      throw new Error("Unassigned resolve target.");
+    const r = this.updaters.filter((l) => l.supports(t)), e = this.sortByPriority(r)[0];
+    if (!e) {
+      if (this.fallbackHandler)
+        return {
+          supports: () => !0,
+          handle: this.fallbackHandler
+        };
+      const l = typeof t == "object" && t !== null ? JSON.stringify(t) : String(t);
+      throw new Error(`Unsupported type: ${l}`);
+    }
+    return e;
+  }
+  /**
+   * 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(t) {
+    if (this.updaters.length < 1)
+      throw new Error("Unassigned resolve target.");
+    const r = this.updaters.filter((s) => s.supports(t));
+    return r.length === 0 ? this.fallbackHandler ? [
+      {
+        supports: () => !0,
+        handle: this.fallbackHandler
+      }
+    ] : [] : this.sortByPriority(r);
+  }
+  /**
+   * 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(t, ...r) {
+    return this.resolveAll(t).map((e) => e.handle(...r));
+  }
+  /**
+   * 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
+   */
+  async handleAllAsync(t, ...r) {
+    const e = this.resolveAll(t).map((l) => l.handle(...r));
+    return Promise.all(e);
+  }
+  /**
+   * 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
+   */
+  async handleAllSequential(t, ...r) {
+    const s = this.resolveAll(t), e = [];
+    for (const l of s) {
+      const n = await l.handle(...r);
+      e.push(n);
+    }
+    return e;
+  }
+}
+module.exports = i;
+export {
+  i as default
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","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":"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"}

package/package.json

@@ -1,15 +1,37 @@
 {
   "name": "class-resolver",
-  "version": "2.1.1",
+  "version": "4.0.0",
   "description": "Simple class resolver.",
-  "main": "dist/index.js",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "tsc",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:dev": "jest --watch --silent=false --verbose false --coverage",
-    "prepublishOnly": "npm run build"
+    "build": "vite build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "prepublishOnly": "npm run build",
+    "release": "np"
   },
   "keywords": [
     "resolver",
@@ -19,29 +41,15 @@
   "author": "Hidetaka Okamoto <info@wp-kyoto.net> (https://wp-kyoto.net)",
   "license": "MIT",
   "devDependencies": {
-    "@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": [
-      "ts",
-      "tsx",
-      "js"
-    ],
-    "transform": {
-      "^.+\\.(ts|tsx)$": [
-        "ts-jest",
-        {
-          "tsconfig": "tsconfig.json"
-        }
-      ]
-    },
-    "testMatch": [
-      "**/__tests__/*.+(ts|tsx|js)"
-    ]
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^4.0.9",
+    "@vitest/ui": "^4.0.9",
+    "np": "^10.2.0",
+    "typescript": "^5.7.2",
+    "vite": "^7.2.2",
+    "vite-plugin-dts": "^4.3.0",
+    "vitest": "^4.0.9"
   },
   "repository": {
     "type": "git",
@@ -49,5 +57,8 @@
   },
   "engines": {
     "node": ">=14.0.0"
+  },
+  "np": {
+    "yarn": false
   }
 }

package/dist/index.js

@@ -1,26 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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,23 +0,0 @@
-/**
- * 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<TArgs extends any[] = any[], TReturn = any, TType = string> {
-        supports(type: TType): boolean;
-        handle(...args: TArgs): TReturn;
-    }
-}

package/dist/interface.js

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

package/dist/interface.js.map

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

package/dist/resolver.d.ts

@@ -1,48 +0,0 @@
-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,75 +0,0 @@
-"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) {
-        /**
-         * Array of registered resolver targets
-         * @private
-         */
-        this.updaters = [];
-        if (args.length > 0) {
-            this.set(args);
-        }
-    }
-    /**
-     * 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.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.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.updaters.length < 1) {
-            throw new Error('Unassigned resolve target.');
-        }
-        const target = this.updaters.find(updater => updater.supports(type));
-        if (!target) {
-            // Determine the string representation of the unsupported type
-            // If it's a non-null object, use JSON.stringify for detailed output
-            // Otherwise, use String() for basic conversion
-            const typeString = typeof type === 'object' && type !== null ? JSON.stringify(type) : String(type);
-            throw new Error(`Unsupported type: ${typeString}`);
-        }
-        return target;
-    }
-}
-exports.default = Resolver;
-//# sourceMappingURL=resolver.js.map

package/dist/resolver.js.map

@@ -1 +0,0 @@
-{"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,4BAA4B,CAAC,CAAC;QAChD,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,8DAA8D;YAC9D,oEAAoE;YACpE,+CAA+C;YAC/C,MAAM,UAAU,GAAG,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACnG,MAAM,IAAI,KAAK,CAAC,qBAAqB,UAAU,EAAE,CAAC,CAAC;QACrD,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAED,kBAAe,QAAQ,CAAC"}

package/index.js

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

package/libs/index.ts

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

package/libs/interface.ts

@@ -1,26 +0,0 @@
-/**
- * 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<TArgs extends any[] = any[], TReturn = any, TType = string> {
-    supports(type: TType): boolean
-    handle(...args: TArgs): TReturn
-  }
-}

package/libs/resolver.ts

@@ -1,84 +0,0 @@
-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);
-    }
-  }
-
-  /**
-   * Processes an array of arguments
-   * @param args Array of resolver targets
-   * @returns Processed array
-   * @private
-   */
-  private getArgs(args: TBase[]): TBase[] {
-    return [...args];
-  }
-
-  /**
-   * Sets resolver targets
-   * @param updaters Array of resolver targets
-   */
-  public set(updaters: TBase[]): void {
-    this.updaters = updaters;
-  }
-
-  /**
-   * Sets resolver targets (variadic version)
-   * @param args Resolver targets
-   */
-  public setUpdaters(...args: TBase[]): void {
-    this.set(this.getArgs(args));
-  }
-
-  /**
-   * Adds a resolver target
-   * @param updater Resolver target to add
-   */
-  public addUpdater(updater: TBase): void {
-    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
-   */
-  public resolve(type: TType): TBase {
-    if (this.updaters.length < 1) {
-      throw new Error('Unassigned resolve target.');
-    }
-    
-    const target = this.updaters.find(updater => updater.supports(type));
-    
-    if (!target) {
-      // Determine the string representation of the unsupported type
-      // If it's a non-null object, use JSON.stringify for detailed output
-      // Otherwise, use String() for basic conversion
-      const typeString = typeof type === 'object' && type !== null ? JSON.stringify(type) : String(type);
-      throw new Error(`Unsupported type: ${typeString}`);
-    }
-    
-    return target;
-  }
-}
-
-export default Resolver;