@resq-sw/decorators 0.1.0

package/lib/bind/bind.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.types.d.ts","names":[],"sources":["../../src/bind/bind.types.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;UA0BiB,UAAA;;;;;EAKf,IAAA;AAAA"}

package/lib/bind/index.d.ts

@@ -0,0 +1,3 @@
+import { bind } from "./bind.js";
+import { BindConfig } from "./bind.types.js";
+export { BindConfig, bind };

package/lib/bind/index.js

@@ -0,0 +1,2 @@
+import { bind } from "./bind.js";
+export { bind };

package/lib/debounce/debounce.d.ts

@@ -0,0 +1,34 @@
+import { Decorator } from "../types.js";
+
+//#region src/debounce/debounce.d.ts
+/**
+ * Decorator that debounces method calls, ensuring the method only executes
+ * after the specified delay has passed since the last call.
+ *
+ * @template T - The type of the class containing the decorated method
+ * @param {number} delayMs - The debounce delay in milliseconds
+ * @returns {Decorator<T>} The decorator function
+ *
+ * @throws {Error} When applied to a non-method property
+ *
+ * @example
+ * ```typescript
+ * class AutoSave {
+ *   @debounce(1000)
+ *   saveDraft(content: string) {
+ *     // Saves only 1 second after user stops typing
+ *     localStorage.setItem('draft', content);
+ *   }
+ * }
+ *
+ * // Usage
+ * const autoSave = new AutoSave();
+ * autoSave.saveDraft('Hello'); // Won't save yet
+ * autoSave.saveDraft('Hello World'); // Resets timer
+ * // After 1 second of inactivity, saveDraft executes once
+ * ```
+ */
+declare function debounce<T = unknown>(delayMs: number): Decorator<T>;
+//#endregion
+export { debounce };
+//# sourceMappingURL=debounce.d.ts.map

package/lib/debounce/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","names":[],"sources":["../../src/debounce/debounce.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CgB,QAAA,aAAA,CAAsB,OAAA,WAAkB,SAAA,CAAU,CAAA"}

package/lib/debounce/debounce.fn.d.ts

@@ -0,0 +1,40 @@
+import { Method } from "../types.js";
+
+//#region src/debounce/debounce.fn.d.ts
+/**
+ * Wraps a method to debounce its execution.
+ * The method will only execute after the specified delay has passed
+ * since the last time it was called.
+ *
+ * @template D - The return type of the original method
+ * @template A - The argument types of the original method
+ * @param {Method<D, A>} originalMethod - The method to debounce
+ * @param {number} delayMs - The debounce delay in milliseconds
+ * @returns {Method<void, A>} The debounced method
+ *
+ * @example
+ * ```typescript
+ * class SearchService {
+ *   search(query: string): void {
+ *     console.log(`Searching for: ${query}`);
+ *   }
+ * }
+ *
+ * const service = new SearchService();
+ * const debouncedSearch = debounceFn(
+ *   service.search.bind(service),
+ *   300
+ * );
+ *
+ * // Rapid calls
+ * debouncedSearch('a');
+ * debouncedSearch('ab');
+ * debouncedSearch('abc');
+ *
+ * // Only "Searching for: abc" is logged after 300ms
+ * ```
+ */
+declare function debounceFn<D = unknown, A extends unknown[] = unknown[]>(originalMethod: Method<D, A>, delayMs: number): Method<void, A>;
+//#endregion
+export { debounceFn };
+//# sourceMappingURL=debounce.fn.d.ts.map

package/lib/debounce/debounce.fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.fn.d.ts","names":[],"sources":["../../src/debounce/debounce.fn.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDgB,UAAA,8CAAA,CACd,cAAA,EAAgB,MAAA,CAAO,CAAA,EAAG,CAAA,GAC1B,OAAA,WACC,MAAA,OAAa,CAAA"}

package/lib/debounce/debounce.fn.js

@@ -0,0 +1,47 @@
+//#region src/debounce/debounce.fn.ts
+/**
+* Wraps a method to debounce its execution.
+* The method will only execute after the specified delay has passed
+* since the last time it was called.
+*
+* @template D - The return type of the original method
+* @template A - The argument types of the original method
+* @param {Method<D, A>} originalMethod - The method to debounce
+* @param {number} delayMs - The debounce delay in milliseconds
+* @returns {Method<void, A>} The debounced method
+*
+* @example
+* ```typescript
+* class SearchService {
+*   search(query: string): void {
+*     console.log(`Searching for: ${query}`);
+*   }
+* }
+*
+* const service = new SearchService();
+* const debouncedSearch = debounceFn(
+*   service.search.bind(service),
+*   300
+* );
+*
+* // Rapid calls
+* debouncedSearch('a');
+* debouncedSearch('ab');
+* debouncedSearch('abc');
+*
+* // Only "Searching for: abc" is logged after 300ms
+* ```
+*/
+function debounceFn(originalMethod, delayMs) {
+	let handler;
+	return function(...args) {
+		clearTimeout(handler);
+		handler = setTimeout(() => {
+			originalMethod.apply(this, args);
+		}, delayMs);
+	};
+}
+//#endregion
+export { debounceFn };
+
+//# sourceMappingURL=debounce.fn.js.map

package/lib/debounce/debounce.fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.fn.js","names":[],"sources":["../../src/debounce/debounce.fn.ts"],"sourcesContent":["/**\n * Copyright 2026 ResQ\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { Method } from '../types.js';\n\n/**\n * Wraps a method to debounce its execution.\n * The method will only execute after the specified delay has passed\n * since the last time it was called.\n *\n * @template D - The return type of the original method\n * @template A - The argument types of the original method\n * @param {Method<D, A>} originalMethod - The method to debounce\n * @param {number} delayMs - The debounce delay in milliseconds\n * @returns {Method<void, A>} The debounced method\n *\n * @example\n * ```typescript\n * class SearchService {\n *   search(query: string): void {\n *     console.log(`Searching for: ${query}`);\n *   }\n * }\n *\n * const service = new SearchService();\n * const debouncedSearch = debounceFn(\n *   service.search.bind(service),\n *   300\n * );\n *\n * // Rapid calls\n * debouncedSearch('a');\n * debouncedSearch('ab');\n * debouncedSearch('abc');\n *\n * // Only \"Searching for: abc\" is logged after 300ms\n * ```\n */\nexport function debounceFn<D = unknown, A extends unknown[] = unknown[]>(\n  originalMethod: Method<D, A>,\n  delayMs: number,\n): Method<void, A> {\n  let handler: ReturnType<typeof setTimeout> | undefined;\n\n  return function (this: unknown, ...args: A): void {\n    clearTimeout(handler);\n\n    handler = setTimeout(() => {\n      originalMethod.apply(this, args);\n    }, delayMs);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,SAAgB,WACd,gBACA,SACiB;CACjB,IAAI;AAEJ,QAAO,SAAyB,GAAG,MAAe;AAChD,eAAa,QAAQ;AAErB,YAAU,iBAAiB;AACzB,kBAAe,MAAM,MAAM,KAAK;KAC/B,QAAQ"}

package/lib/debounce/debounce.js

@@ -0,0 +1,48 @@
+import { debounceFn } from "./debounce.fn.js";
+//#region src/debounce/debounce.ts
+/**
+* Decorator that debounces method calls, ensuring the method only executes
+* after the specified delay has passed since the last call.
+*
+* @template T - The type of the class containing the decorated method
+* @param {number} delayMs - The debounce delay in milliseconds
+* @returns {Decorator<T>} The decorator function
+*
+* @throws {Error} When applied to a non-method property
+*
+* @example
+* ```typescript
+* class AutoSave {
+*   @debounce(1000)
+*   saveDraft(content: string) {
+*     // Saves only 1 second after user stops typing
+*     localStorage.setItem('draft', content);
+*   }
+* }
+*
+* // Usage
+* const autoSave = new AutoSave();
+* autoSave.saveDraft('Hello'); // Won't save yet
+* autoSave.saveDraft('Hello World'); // Resets timer
+* // After 1 second of inactivity, saveDraft executes once
+* ```
+*/
+function debounce(delayMs) {
+	return (_target, _propertyName, descriptor) => {
+		if (descriptor.value) {
+			const methodsMap = /* @__PURE__ */ new WeakMap();
+			const originalMethod = descriptor.value;
+			descriptor.value = function(...args) {
+				if (!methodsMap.has(this)) methodsMap.set(this, debounceFn(originalMethod, delayMs).bind(this));
+				const method = methodsMap.get(this);
+				if (method) method(...args);
+			};
+			return descriptor;
+		}
+		throw new Error("@debounce is applicable only on a methods.");
+	};
+}
+//#endregion
+export { debounce };
+
+//# sourceMappingURL=debounce.js.map

package/lib/debounce/debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.js","names":[],"sources":["../../src/debounce/debounce.ts"],"sourcesContent":["/**\n * Copyright 2026 ResQ\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { Decorator, Method } from '../types.js';\nimport { debounceFn } from './debounce.fn.js';\n\n/**\n * Decorator that debounces method calls, ensuring the method only executes\n * after the specified delay has passed since the last call.\n *\n * @template T - The type of the class containing the decorated method\n * @param {number} delayMs - The debounce delay in milliseconds\n * @returns {Decorator<T>} The decorator function\n *\n * @throws {Error} When applied to a non-method property\n *\n * @example\n * ```typescript\n * class AutoSave {\n *   @debounce(1000)\n *   saveDraft(content: string) {\n *     // Saves only 1 second after user stops typing\n *     localStorage.setItem('draft', content);\n *   }\n * }\n *\n * // Usage\n * const autoSave = new AutoSave();\n * autoSave.saveDraft('Hello'); // Won't save yet\n * autoSave.saveDraft('Hello World'); // Resets timer\n * // After 1 second of inactivity, saveDraft executes once\n * ```\n */\nexport function debounce<T = unknown>(delayMs: number): Decorator<T> {\n  return (\n    _target: T,\n    _propertyName: keyof T,\n    descriptor: TypedPropertyDescriptor<Method<unknown>>,\n  ): TypedPropertyDescriptor<Method<unknown>> => {\n    if (descriptor.value) {\n      const methodsMap = new WeakMap<object, Method<unknown>>();\n      const originalMethod = descriptor.value;\n\n      descriptor.value = function (this: object, ...args: unknown[]) {\n        if (!methodsMap.has(this)) {\n          methodsMap.set(this, debounceFn(originalMethod, delayMs).bind(this));\n        }\n\n        const method = methodsMap.get(this);\n        if (method) {\n          method(...args);\n        }\n      };\n\n      return descriptor;\n    }\n\n    throw new Error('@debounce is applicable only on a methods.');\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,SAAsB,SAA+B;AACnE,SACE,SACA,eACA,eAC6C;AAC7C,MAAI,WAAW,OAAO;GACpB,MAAM,6BAAa,IAAI,SAAkC;GACzD,MAAM,iBAAiB,WAAW;AAElC,cAAW,QAAQ,SAAwB,GAAG,MAAiB;AAC7D,QAAI,CAAC,WAAW,IAAI,KAAK,CACvB,YAAW,IAAI,MAAM,WAAW,gBAAgB,QAAQ,CAAC,KAAK,KAAK,CAAC;IAGtE,MAAM,SAAS,WAAW,IAAI,KAAK;AACnC,QAAI,OACF,QAAO,GAAG,KAAK;;AAInB,UAAO;;AAGT,QAAM,IAAI,MAAM,6CAA6C"}

package/lib/debounce/index.d.ts

@@ -0,0 +1,2 @@
+import { debounceFn } from "./debounce.fn.js";
+export { debounceFn };

package/lib/debounce/index.js

@@ -0,0 +1,2 @@
+import { debounceFn } from "./debounce.fn.js";
+export { debounceFn };

package/lib/delay/delay.d.ts

@@ -0,0 +1,35 @@
+import { Decorator } from "../types.js";
+
+//#region src/delay/delay.d.ts
+/**
+ * Decorator that delays the execution of a method by the specified time.
+ *
+ * @template T - The type of the class containing the decorated method
+ * @param {number} delayMs - The delay time in milliseconds
+ * @returns {Decorator<T>} The decorator function
+ *
+ * @throws {Error} When applied to a non-method property
+ *
+ * @example
+ * ```typescript
+ * class AnimationController {
+ *   @delay(500)
+ *   fadeIn(element: HTMLElement) {
+ *     element.style.opacity = '1';
+ *   }
+ *
+ *   @delay(1000)
+ *   fadeOut(element: HTMLElement) {
+ *     element.style.opacity = '0';
+ *   }
+ * }
+ *
+ * const controller = new AnimationController();
+ * controller.fadeIn(element); // Fades in after 500ms
+ * controller.fadeOut(element); // Fades out after 1000ms
+ * ```
+ */
+declare function delay<T = unknown>(delayMs: number): Decorator<T>;
+//#endregion
+export { delay };
+//# sourceMappingURL=delay.d.ts.map

package/lib/delay/delay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.d.ts","names":[],"sources":["../../src/delay/delay.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+CgB,KAAA,aAAA,CAAmB,OAAA,WAAkB,SAAA,CAAU,CAAA"}

package/lib/delay/delay.fn.d.ts

@@ -0,0 +1,33 @@
+import { Method } from "../types.js";
+
+//#region src/delay/delay.fn.d.ts
+/**
+ * Wraps a method to delay its execution by the specified time.
+ *
+ * @template D - The return type of the original method
+ * @template A - The argument types of the original method
+ * @param {Method<D, A>} originalMethod - The method to delay
+ * @param {number} delayMs - The delay time in milliseconds
+ * @returns {Method<void, A>} The delayed method
+ *
+ * @example
+ * ```typescript
+ * class MessageService {
+ *   send(message: string): void {
+ *     console.log(`Sending: ${message}`);
+ *   }
+ * }
+ *
+ * const service = new MessageService();
+ * const delayedSend = delayFn(
+ *   service.send.bind(service),
+ *   2000
+ * );
+ *
+ * delayedSend('Hello'); // "Sending: Hello" appears after 2 seconds
+ * ```
+ */
+declare function delayFn<D = unknown, A extends unknown[] = unknown[]>(originalMethod: Method<D, A>, delayMs: number): Method<void, A>;
+//#endregion
+export { delayFn };
+//# sourceMappingURL=delay.fn.d.ts.map

package/lib/delay/delay.fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.fn.d.ts","names":[],"sources":["../../src/delay/delay.fn.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4CgB,OAAA,8CAAA,CACd,cAAA,EAAgB,MAAA,CAAO,CAAA,EAAG,CAAA,GAC1B,OAAA,WACC,MAAA,OAAa,CAAA"}

package/lib/delay/delay.fn.js

@@ -0,0 +1,38 @@
+//#region src/delay/delay.fn.ts
+/**
+* Wraps a method to delay its execution by the specified time.
+*
+* @template D - The return type of the original method
+* @template A - The argument types of the original method
+* @param {Method<D, A>} originalMethod - The method to delay
+* @param {number} delayMs - The delay time in milliseconds
+* @returns {Method<void, A>} The delayed method
+*
+* @example
+* ```typescript
+* class MessageService {
+*   send(message: string): void {
+*     console.log(`Sending: ${message}`);
+*   }
+* }
+*
+* const service = new MessageService();
+* const delayedSend = delayFn(
+*   service.send.bind(service),
+*   2000
+* );
+*
+* delayedSend('Hello'); // "Sending: Hello" appears after 2 seconds
+* ```
+*/
+function delayFn(originalMethod, delayMs) {
+	return function(...args) {
+		setTimeout(() => {
+			originalMethod.apply(this, args);
+		}, delayMs);
+	};
+}
+//#endregion
+export { delayFn };
+
+//# sourceMappingURL=delay.fn.js.map

package/lib/delay/delay.fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.fn.js","names":[],"sources":["../../src/delay/delay.fn.ts"],"sourcesContent":["/**\n * Copyright 2026 ResQ\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { Method } from '../types.js';\n\n/**\n * Wraps a method to delay its execution by the specified time.\n *\n * @template D - The return type of the original method\n * @template A - The argument types of the original method\n * @param {Method<D, A>} originalMethod - The method to delay\n * @param {number} delayMs - The delay time in milliseconds\n * @returns {Method<void, A>} The delayed method\n *\n * @example\n * ```typescript\n * class MessageService {\n *   send(message: string): void {\n *     console.log(`Sending: ${message}`);\n *   }\n * }\n *\n * const service = new MessageService();\n * const delayedSend = delayFn(\n *   service.send.bind(service),\n *   2000\n * );\n *\n * delayedSend('Hello'); // \"Sending: Hello\" appears after 2 seconds\n * ```\n */\nexport function delayFn<D = unknown, A extends unknown[] = unknown[]>(\n  originalMethod: Method<D, A>,\n  delayMs: number,\n): Method<void, A> {\n  return function (this: unknown, ...args: A): void {\n    setTimeout(() => {\n      originalMethod.apply(this, args);\n    }, delayMs);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAgB,QACd,gBACA,SACiB;AACjB,QAAO,SAAyB,GAAG,MAAe;AAChD,mBAAiB;AACf,kBAAe,MAAM,MAAM,KAAK;KAC/B,QAAQ"}

package/lib/delay/delay.js

@@ -0,0 +1,43 @@
+import { delayFn } from "./delay.fn.js";
+//#region src/delay/delay.ts
+/**
+* Decorator that delays the execution of a method by the specified time.
+*
+* @template T - The type of the class containing the decorated method
+* @param {number} delayMs - The delay time in milliseconds
+* @returns {Decorator<T>} The decorator function
+*
+* @throws {Error} When applied to a non-method property
+*
+* @example
+* ```typescript
+* class AnimationController {
+*   @delay(500)
+*   fadeIn(element: HTMLElement) {
+*     element.style.opacity = '1';
+*   }
+*
+*   @delay(1000)
+*   fadeOut(element: HTMLElement) {
+*     element.style.opacity = '0';
+*   }
+* }
+*
+* const controller = new AnimationController();
+* controller.fadeIn(element); // Fades in after 500ms
+* controller.fadeOut(element); // Fades out after 1000ms
+* ```
+*/
+function delay(delayMs) {
+	return (_target, _propertyName, descriptor) => {
+		if (descriptor.value) {
+			descriptor.value = delayFn(descriptor.value, delayMs);
+			return descriptor;
+		}
+		throw new Error("@delay is applicable only on a methods.");
+	};
+}
+//#endregion
+export { delay };
+
+//# sourceMappingURL=delay.js.map

package/lib/delay/delay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.js","names":[],"sources":["../../src/delay/delay.ts"],"sourcesContent":["/**\n * Copyright 2026 ResQ\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { Decorator, Method } from '../types.js';\nimport { delayFn } from './delay.fn.js';\n\n/**\n * Decorator that delays the execution of a method by the specified time.\n *\n * @template T - The type of the class containing the decorated method\n * @param {number} delayMs - The delay time in milliseconds\n * @returns {Decorator<T>} The decorator function\n *\n * @throws {Error} When applied to a non-method property\n *\n * @example\n * ```typescript\n * class AnimationController {\n *   @delay(500)\n *   fadeIn(element: HTMLElement) {\n *     element.style.opacity = '1';\n *   }\n *\n *   @delay(1000)\n *   fadeOut(element: HTMLElement) {\n *     element.style.opacity = '0';\n *   }\n * }\n *\n * const controller = new AnimationController();\n * controller.fadeIn(element); // Fades in after 500ms\n * controller.fadeOut(element); // Fades out after 1000ms\n * ```\n */\nexport function delay<T = unknown>(delayMs: number): Decorator<T> {\n  return (\n    _target: T,\n    _propertyName: keyof T,\n    descriptor: TypedPropertyDescriptor<Method<unknown>>,\n  ): TypedPropertyDescriptor<Method<unknown>> => {\n    if (descriptor.value) {\n      descriptor.value = delayFn(descriptor.value, delayMs);\n\n      return descriptor;\n    }\n    throw new Error('@delay is applicable only on a methods.');\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,MAAmB,SAA+B;AAChE,SACE,SACA,eACA,eAC6C;AAC7C,MAAI,WAAW,OAAO;AACpB,cAAW,QAAQ,QAAQ,WAAW,OAAO,QAAQ;AAErD,UAAO;;AAET,QAAM,IAAI,MAAM,0CAA0C"}

package/lib/delay/index.d.ts

@@ -0,0 +1,2 @@
+import { delay } from "./delay.js";
+export { delay };

package/lib/delay/index.js

@@ -0,0 +1,2 @@
+import { delay } from "./delay.js";
+export { delay };

package/lib/delegate/delegate.d.ts

@@ -0,0 +1,48 @@
+import { Delegatable } from "./delegate.types.js";
+
+//#region src/delegate/delegate.d.ts
+/**
+ * Decorator that deduplicates concurrent async method calls.
+ * Multiple calls with the same arguments will share the same promise
+ * until the first one resolves or rejects.
+ *
+ * @template T - The type of the class containing the decorated method
+ * @template D - The return type of the decorated method (wrapped in Promise)
+ * @param {(...args: any[]) => string} [keyResolver] - Optional function to generate cache keys from arguments
+ * @returns {Delegatable<T, D>} The decorator function
+ *
+ * @throws {Error} When applied to a non-method property
+ *
+ * @example
+ * ```typescript
+ * class ApiService {
+ *   // Basic usage - uses JSON.stringify(args) as key
+ *   @delegate()
+ *   async fetchData(id: string): Promise<Data> {
+ *     return this.http.get(`/data/${id}`);
+ *   }
+ *
+ *   // Custom key resolver for complex arguments
+ *   @delegate((userId, options) => `${userId}-${options.cacheKey}`)
+ *   async getUser(userId: string, options: { cacheKey: string }): Promise<User> {
+ *     return this.http.get(`/users/${userId}`);
+ *   }
+ * }
+ *
+ * // Usage - concurrent calls with same args share the promise
+ * const api = new ApiService();
+ *
+ * // These share the same underlying promise
+ * const [user1, user2] = await Promise.all([
+ *   api.getUser('123', { cacheKey: 'v1' }),
+ *   api.getUser('123', { cacheKey: 'v1' }) // Same key, returns cached promise
+ * ]);
+ *
+ * // This creates a new promise (different cache key)
+ * const user3 = await api.getUser('123', { cacheKey: 'v2' });
+ * ```
+ */
+declare function delegate<T = any, D = any>(keyResolver?: (...args: unknown[]) => string): Delegatable<T, D>;
+//#endregion
+export { delegate };
+//# sourceMappingURL=delegate.d.ts.map

package/lib/delegate/delegate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate.d.ts","names":[],"sources":["../../src/delegate/delegate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyFgB,QAAA,kBAAA,CACd,WAAA,OAAkB,IAAA,yBACjB,WAAA,CAAY,CAAA,EAAG,CAAA"}

package/lib/delegate/delegate.fn.d.ts

@@ -0,0 +1,57 @@
+import { AsyncMethod } from "../types.js";
+
+//#region src/delegate/delegate.fn.d.ts
+/**
+* @fileoverview Delegate function implementation - wraps an async method to
+* deduplicate concurrent calls with the same arguments.
+*
+* @module @resq/typescript/decorators/delegate.fn
+*
+* @copyright Copyright (c) 2026 ResQ
+* @license MIT
+*/
+/**
+ * @fileoverview Delegate function implementation - wraps an async method to
+ * deduplicate concurrent calls with the same arguments.
+ *
+ * @module @resq/typescript/decorators/delegate.fn
+ *
+ * @copyright Copyright (c) 2026 ResQ
+ * @license MIT
+ */
+/**
+ * Wraps an async method to deduplicate concurrent calls.
+ * Multiple calls with the same key will share the same promise
+ * until the first one completes.
+ *
+ * @template D - The resolved type of the promise
+ * @template A - The argument types of the original method
+ * @param {AsyncMethod<D, A>} originalMethod - The async method to wrap
+ * @param {(...args: A) => string} [keyResolver] - Optional function to generate cache keys
+ * @returns {AsyncMethod<D, A>} The delegated method
+ *
+ * @example
+ * ```typescript
+ * class Service {
+ *   async fetchData(id: string): Promise<Data> {
+ *     console.log(`Fetching ${id}`);
+ *     return fetch(`/api/data/${id}`).then(r => r.json());
+ *   }
+ * }
+ *
+ * const service = new Service();
+ * const delegated = delegateFn(
+ *   service.fetchData.bind(service),
+ *   (id) => id // Use id directly as key
+ * );
+ *
+ * // These share the same promise - "Fetching 123" is logged only once
+ * const p1 = delegated('123');
+ * const p2 = delegated('123');
+ * const [d1, d2] = await Promise.all([p1, p2]);
+ * ```
+ */
+declare function delegateFn<D = any, A extends any[] = any[]>(originalMethod: AsyncMethod<D, A>, keyResolver?: (...args: A) => string): AsyncMethod<D, A>;
+//#endregion
+export { delegateFn };
+//# sourceMappingURL=delegate.fn.d.ts.map

package/lib/delegate/delegate.fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate.fn.d.ts","names":[],"sources":["../../src/delegate/delegate.fn.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4EgB,UAAA,kCAAA,CACd,cAAA,EAAgB,WAAA,CAAY,CAAA,EAAG,CAAA,GAC/B,WAAA,OAAkB,IAAA,EAAM,CAAA,cACvB,WAAA,CAAY,CAAA,EAAG,CAAA"}

package/lib/delegate/delegate.fn.js

@@ -0,0 +1,55 @@
+//#region src/delegate/delegate.fn.ts
+/**
+* @fileoverview Delegate function implementation - wraps an async method to
+* deduplicate concurrent calls with the same arguments.
+*
+* @module @resq/typescript/decorators/delegate.fn
+*
+* @copyright Copyright (c) 2026 ResQ
+* @license MIT
+*/
+/**
+* Wraps an async method to deduplicate concurrent calls.
+* Multiple calls with the same key will share the same promise
+* until the first one completes.
+*
+* @template D - The resolved type of the promise
+* @template A - The argument types of the original method
+* @param {AsyncMethod<D, A>} originalMethod - The async method to wrap
+* @param {(...args: A) => string} [keyResolver] - Optional function to generate cache keys
+* @returns {AsyncMethod<D, A>} The delegated method
+*
+* @example
+* ```typescript
+* class Service {
+*   async fetchData(id: string): Promise<Data> {
+*     console.log(`Fetching ${id}`);
+*     return fetch(`/api/data/${id}`).then(r => r.json());
+*   }
+* }
+*
+* const service = new Service();
+* const delegated = delegateFn(
+*   service.fetchData.bind(service),
+*   (id) => id // Use id directly as key
+* );
+*
+* // These share the same promise - "Fetching 123" is logged only once
+* const p1 = delegated('123');
+* const p2 = delegated('123');
+* const [d1, d2] = await Promise.all([p1, p2]);
+* ```
+*/
+function delegateFn(originalMethod, keyResolver) {
+	const delegatedKeysMap = /* @__PURE__ */ new Map();
+	const keyGenerator = keyResolver ?? ((...args) => JSON.stringify(args));
+	return function(...args) {
+		const key = keyGenerator(...args);
+		if (!delegatedKeysMap.has(key)) delegatedKeysMap.set(key, originalMethod.apply(this, args).finally(() => delegatedKeysMap.delete(key)));
+		return delegatedKeysMap.get(key);
+	};
+}
+//#endregion
+export { delegateFn };
+
+//# sourceMappingURL=delegate.fn.js.map

package/lib/delegate/delegate.fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate.fn.js","names":[],"sources":["../../src/delegate/delegate.fn.ts"],"sourcesContent":["/**\n * Copyright 2026 ResQ\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { AsyncMethod } from '../types.js';\n\n/*\n * Copyright 2026 ResQ\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Delegate function implementation - wraps an async method to\n * deduplicate concurrent calls with the same arguments.\n *\n * @module @resq/typescript/decorators/delegate.fn\n *\n * @copyright Copyright (c) 2026 ResQ\n * @license MIT\n */\n\n/**\n * Wraps an async method to deduplicate concurrent calls.\n * Multiple calls with the same key will share the same promise\n * until the first one completes.\n *\n * @template D - The resolved type of the promise\n * @template A - The argument types of the original method\n * @param {AsyncMethod<D, A>} originalMethod - The async method to wrap\n * @param {(...args: A) => string} [keyResolver] - Optional function to generate cache keys\n * @returns {AsyncMethod<D, A>} The delegated method\n *\n * @example\n * ```typescript\n * class Service {\n *   async fetchData(id: string): Promise<Data> {\n *     console.log(`Fetching ${id}`);\n *     return fetch(`/api/data/${id}`).then(r => r.json());\n *   }\n * }\n *\n * const service = new Service();\n * const delegated = delegateFn(\n *   service.fetchData.bind(service),\n *   (id) => id // Use id directly as key\n * );\n *\n * // These share the same promise - \"Fetching 123\" is logged only once\n * const p1 = delegated('123');\n * const p2 = delegated('123');\n * const [d1, d2] = await Promise.all([p1, p2]);\n * ```\n */\nexport function delegateFn<D = any, A extends any[] = any[]>(\n  originalMethod: AsyncMethod<D, A>,\n  keyResolver?: (...args: A) => string,\n): AsyncMethod<D, A> {\n  const delegatedKeysMap = new Map<string, Promise<D>>();\n  const keyGenerator: (...args: unknown[]) => string =\n    keyResolver ?? ((...args) => JSON.stringify(args));\n\n  return function (this: any, ...args: A): Promise<D> {\n    const key = keyGenerator(...args);\n\n    if (!delegatedKeysMap.has(key)) {\n      delegatedKeysMap.set(\n        key,\n        originalMethod.apply(this, args).finally(() => delegatedKeysMap.delete(key)),\n      );\n    }\n\n    return delegatedKeysMap.get(key) as Promise<D>;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EA,SAAgB,WACd,gBACA,aACmB;CACnB,MAAM,mCAAmB,IAAI,KAAyB;CACtD,MAAM,eACJ,iBAAiB,GAAG,SAAS,KAAK,UAAU,KAAK;AAEnD,QAAO,SAAqB,GAAG,MAAqB;EAClD,MAAM,MAAM,aAAa,GAAG,KAAK;AAEjC,MAAI,CAAC,iBAAiB,IAAI,IAAI,CAC5B,kBAAiB,IACf,KACA,eAAe,MAAM,MAAM,KAAK,CAAC,cAAc,iBAAiB,OAAO,IAAI,CAAC,CAC7E;AAGH,SAAO,iBAAiB,IAAI,IAAI"}

package/lib/delegate/delegate.js

@@ -0,0 +1,56 @@
+import { delegateFn } from "./delegate.fn.js";
+//#region src/delegate/delegate.ts
+/**
+* Decorator that deduplicates concurrent async method calls.
+* Multiple calls with the same arguments will share the same promise
+* until the first one resolves or rejects.
+*
+* @template T - The type of the class containing the decorated method
+* @template D - The return type of the decorated method (wrapped in Promise)
+* @param {(...args: any[]) => string} [keyResolver] - Optional function to generate cache keys from arguments
+* @returns {Delegatable<T, D>} The decorator function
+*
+* @throws {Error} When applied to a non-method property
+*
+* @example
+* ```typescript
+* class ApiService {
+*   // Basic usage - uses JSON.stringify(args) as key
+*   @delegate()
+*   async fetchData(id: string): Promise<Data> {
+*     return this.http.get(`/data/${id}`);
+*   }
+*
+*   // Custom key resolver for complex arguments
+*   @delegate((userId, options) => `${userId}-${options.cacheKey}`)
+*   async getUser(userId: string, options: { cacheKey: string }): Promise<User> {
+*     return this.http.get(`/users/${userId}`);
+*   }
+* }
+*
+* // Usage - concurrent calls with same args share the promise
+* const api = new ApiService();
+*
+* // These share the same underlying promise
+* const [user1, user2] = await Promise.all([
+*   api.getUser('123', { cacheKey: 'v1' }),
+*   api.getUser('123', { cacheKey: 'v1' }) // Same key, returns cached promise
+* ]);
+*
+* // This creates a new promise (different cache key)
+* const user3 = await api.getUser('123', { cacheKey: 'v2' });
+* ```
+*/
+function delegate(keyResolver) {
+	return (target, propertyName, descriptor) => {
+		if (descriptor.value) {
+			descriptor.value = delegateFn(descriptor.value, keyResolver);
+			return descriptor;
+		}
+		throw new Error("@delegate is applicable only on a methods.");
+	};
+}
+//#endregion
+export { delegate };
+
+//# sourceMappingURL=delegate.js.map

package/lib/delegate/delegate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate.js","names":[],"sources":["../../src/delegate/delegate.ts"],"sourcesContent":["/**\n * Copyright 2026 ResQ\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Delegate decorator - deduplicates concurrent async method calls\n * with the same arguments. If a method is called while another identical call\n * is in progress, it returns the same promise instead of making a new call.\n *\n * @module @resq/typescript/decorators/delegate\n *\n * @example\n * ```typescript\n * class DataService {\n *   @delegate()\n *   async fetchUser(userId: string): Promise<User> {\n *     return fetch(`/api/users/${userId}`).then(r => r.json());\n *   }\n * }\n *\n * const service = new DataService();\n *\n * // These two calls will share the same promise\n * const promise1 = service.fetchUser('123');\n * const promise2 = service.fetchUser('123');\n * console.log(promise1 === promise2); // true\n * ```\n *\n * @copyright Copyright (c) 2026 ResQ\n * @license MIT\n */\n\nimport type { AsyncMethod } from '../types.js';\nimport { delegateFn } from './delegate.fn.js';\nimport type { Delegatable } from './delegate.types.js';\n\n/**\n * Decorator that deduplicates concurrent async method calls.\n * Multiple calls with the same arguments will share the same promise\n * until the first one resolves or rejects.\n *\n * @template T - The type of the class containing the decorated method\n * @template D - The return type of the decorated method (wrapped in Promise)\n * @param {(...args: any[]) => string} [keyResolver] - Optional function to generate cache keys from arguments\n * @returns {Delegatable<T, D>} The decorator function\n *\n * @throws {Error} When applied to a non-method property\n *\n * @example\n * ```typescript\n * class ApiService {\n *   // Basic usage - uses JSON.stringify(args) as key\n *   @delegate()\n *   async fetchData(id: string): Promise<Data> {\n *     return this.http.get(`/data/${id}`);\n *   }\n *\n *   // Custom key resolver for complex arguments\n *   @delegate((userId, options) => `${userId}-${options.cacheKey}`)\n *   async getUser(userId: string, options: { cacheKey: string }): Promise<User> {\n *     return this.http.get(`/users/${userId}`);\n *   }\n * }\n *\n * // Usage - concurrent calls with same args share the promise\n * const api = new ApiService();\n *\n * // These share the same underlying promise\n * const [user1, user2] = await Promise.all([\n *   api.getUser('123', { cacheKey: 'v1' }),\n *   api.getUser('123', { cacheKey: 'v1' }) // Same key, returns cached promise\n * ]);\n *\n * // This creates a new promise (different cache key)\n * const user3 = await api.getUser('123', { cacheKey: 'v2' });\n * ```\n */\nexport function delegate<T = any, D = any>(\n  keyResolver?: (...args: unknown[]) => string,\n): Delegatable<T, D> {\n  return (\n    target: T,\n    propertyName: keyof T,\n    descriptor: TypedPropertyDescriptor<AsyncMethod<D>>,\n  ): TypedPropertyDescriptor<AsyncMethod<any>> => {\n    if (descriptor.value) {\n      descriptor.value = delegateFn(descriptor.value, keyResolver);\n\n      return descriptor;\n    }\n\n    throw new Error('@delegate is applicable only on a methods.');\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyFA,SAAgB,SACd,aACmB;AACnB,SACE,QACA,cACA,eAC8C;AAC9C,MAAI,WAAW,OAAO;AACpB,cAAW,QAAQ,WAAW,WAAW,OAAO,YAAY;AAE5D,UAAO;;AAGT,QAAM,IAAI,MAAM,6CAA6C"}