@resq-sw/decorators 0.1.0

package/lib/memoize/memoize.d.ts

@@ -0,0 +1,67 @@
+import { Memoizable, MemoizeConfig } from "./memoize.types.js";
+
+//#region src/memoize/memoize.d.ts
+/**
+ * Decorator that caches method results based on their arguments.
+ * Subsequent calls with the same arguments return the cached result.
+ *
+ * @overload
+ * @template T - The type of the class containing the decorated method
+ * @template D - The return type of the decorated method
+ * @returns {Memoizable<T, D>} The decorator function
+ *
+ * @overload
+ * @template T - The type of the class containing the decorated method
+ * @template D - The return type of the decorated method
+ * @param {MemoizeConfig<T, D>} config - Configuration for memoization
+ * @returns {Memoizable<T, D>} The decorator function
+ *
+ * @overload
+ * @template T - The type of the class containing the decorated method
+ * @template D - The return type of the decorated method
+ * @param {number} expirationTimeMs - Cache expiration time in milliseconds
+ * @returns {Memoizable<T, D>} The decorator function
+ *
+ * @throws {Error} When applied to a non-method property
+ *
+ * @example
+ * ```typescript
+ * class DataService {
+ *   // Basic usage - caches indefinitely
+ *   @memoize()
+ *   getUser(id: string): User {
+ *     return this.database.findUser(id);
+ *   }
+ *
+ *   // With TTL (time to live)
+ *   @memoize(60000) // Cache for 60 seconds
+ *   getConfig(): Config {
+ *     return this.loadConfig();
+ *   }
+ *
+ *   // With custom cache and key resolver
+ *   @memoize({
+ *     cache: new LRUCache<string, User>(100),
+ *     keyResolver: (userId, includeDetails) => `${userId}-${includeDetails}`,
+ *     expirationTimeMs: 300000 // 5 minutes
+ *   })
+ *   getUserWithDetails(userId: string, includeDetails: boolean): User {
+ *     return this.fetchUser(userId, includeDetails);
+ *   }
+ * }
+ *
+ * const service = new DataService();
+ *
+ * // First call executes the method
+ * const user1 = service.getUser('123');
+ *
+ * // Second call with same argument returns cached result
+ * const user2 = service.getUser('123'); // Instant, no database query
+ * ```
+ */
+declare function memoize<T = any, D = any>(): Memoizable<T, D>;
+declare function memoize<T = any, D = any>(config: MemoizeConfig<T, D>): Memoizable<T, D>;
+declare function memoize<T = any, D = any>(expirationTimeMs: number): Memoizable<T, D>;
+//#endregion
+export { memoize };
+//# sourceMappingURL=memoize.d.ts.map

package/lib/memoize/memoize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","names":[],"sources":["../../src/memoize/memoize.ts"],"mappings":";;;;;AAyHA;;;;;;;;;;;;;;;;;;;;;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAFgB,OAAA,kBAAA,CAAA,GAA6B,UAAA,CAAW,CAAA,EAAG,CAAA;AAAA,iBAC3C,OAAA,kBAAA,CAA0B,MAAA,EAAQ,aAAA,CAAc,CAAA,EAAG,CAAA,IAAK,UAAA,CAAW,CAAA,EAAG,CAAA;AAAA,iBACtE,OAAA,kBAAA,CAA0B,gBAAA,WAA2B,UAAA,CAAW,CAAA,EAAG,CAAA"}

package/lib/memoize/memoize.fn.d.ts

@@ -0,0 +1,69 @@
+import { Method } from "../types.js";
+import { MemoizeConfig } from "./memoize.types.js";
+
+//#region src/memoize/memoize.fn.d.ts
+/**
+ * Wraps a method to cache its results based on arguments.
+ *
+ * @overload
+ * @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 memoize
+ * @returns {Method<D, A>} The memoized method
+ *
+ * @overload
+ * @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 memoize
+ * @param {MemoizeConfig<any, D>} config - Configuration for memoization
+ * @returns {Method<D, A>} The memoized method
+ *
+ * @overload
+ * @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 memoize
+ * @param {number} expirationTimeMs - Cache expiration time in milliseconds
+ * @returns {Method<D, A>} The memoized method
+ *
+ * @example
+ * ```typescript
+ * class ExpensiveOperations {
+ *   calculatePrimes(max: number): number[] {
+ *     const primes = [];
+ *     for (let i = 2; i <= max; i++) {
+ *       if (this.isPrime(i)) primes.push(i);
+ *     }
+ *     return primes;
+ *   }
+ * }
+ *
+ * const ops = new ExpensiveOperations();
+ *
+ * // Basic memoization
+ * const memoized = memoizeFn(ops.calculatePrimes.bind(ops));
+ * const primes1 = memoized(1000); // Computes
+ * const primes2 = memoized(1000); // Returns cached result
+ *
+ * // With TTL
+ * const withTTL = memoizeFn(
+ *   ops.calculatePrimes.bind(ops),
+ *   60000 // Cache for 60 seconds
+ * );
+ *
+ * // With custom config
+ * const withConfig = memoizeFn(
+ *   ops.calculatePrimes.bind(ops),
+ *   {
+ *     cache: new Map(),
+ *     keyResolver: (max) => `primes-${max}`,
+ *     expirationTimeMs: 300000
+ *   }
+ * );
+ * ```
+ */
+declare function memoizeFn<D = any, A extends any[] = any[]>(originalMethod: Method<D, A>): Method<D, A>;
+declare function memoizeFn<D = any, A extends any[] = any[]>(originalMethod: Method<D, A>, config: MemoizeConfig<any, D>): Method<D, A>;
+declare function memoizeFn<D = any, A extends any[] = any[]>(originalMethod: Method<D, A>, expirationTimeMs: number): Method<D, A>;
+//#endregion
+export { memoizeFn };
+//# sourceMappingURL=memoize.fn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.fn.d.ts","names":[],"sources":["../../src/memoize/memoize.fn.ts"],"mappings":";;;;;;;;;;;;;AAkFA;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;iBAPgB,SAAA,kCAAA,CACd,cAAA,EAAgB,MAAA,CAAO,CAAA,EAAG,CAAA,IACzB,MAAA,CAAO,CAAA,EAAG,CAAA;AAAA,iBACG,SAAA,kCAAA,CACd,cAAA,EAAgB,MAAA,CAAO,CAAA,EAAG,CAAA,GAC1B,MAAA,EAAQ,aAAA,MAAmB,CAAA,IAC1B,MAAA,CAAO,CAAA,EAAG,CAAA;AAAA,iBACG,SAAA,kCAAA,CACd,cAAA,EAAgB,MAAA,CAAO,CAAA,EAAG,CAAA,GAC1B,gBAAA,WACC,MAAA,CAAO,CAAA,EAAG,CAAA"}

package/lib/memoize/memoize.fn.js

@@ -0,0 +1,43 @@
+import { TaskExec } from "../_utils.js";
+//#region src/memoize/memoize.fn.ts
+/**
+* Copyright 2026 ResQ
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+function memoizeFn(originalMethod, input) {
+	const defaultConfig = { cache: /* @__PURE__ */ new Map() };
+	const runner = new TaskExec();
+	let resolvedConfig = { ...defaultConfig };
+	if (typeof input === "number") resolvedConfig.expirationTimeMs = input;
+	else resolvedConfig = {
+		...resolvedConfig,
+		...input
+	};
+	return function(...args) {
+		const keyResolver = typeof resolvedConfig.keyResolver === "string" ? this[resolvedConfig.keyResolver].bind(this) : resolvedConfig.keyResolver;
+		const key = keyResolver ? keyResolver(...args) : JSON.stringify(args);
+		if (resolvedConfig.cache && !resolvedConfig.cache.has(key)) {
+			const response = originalMethod.apply(this, args);
+			if (resolvedConfig.expirationTimeMs !== void 0) runner.exec(() => {
+				resolvedConfig.cache?.delete(key);
+			}, resolvedConfig.expirationTimeMs);
+			resolvedConfig.cache.set(key, response);
+		}
+		return resolvedConfig.cache?.get(key);
+	};
+}
+//#endregion
+export { memoizeFn };
+
+//# sourceMappingURL=memoize.fn.js.map

package/lib/memoize/memoize.fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.fn.js","names":[],"sources":["../../src/memoize/memoize.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 { TaskExec } from '../_utils.js';\nimport type { Method } from '../types.js';\nimport type { MemoizeConfig } from './memoize.types.js';\n\n/**\n * Wraps a method to cache its results based on arguments.\n *\n * @overload\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 memoize\n * @returns {Method<D, A>} The memoized method\n *\n * @overload\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 memoize\n * @param {MemoizeConfig<any, D>} config - Configuration for memoization\n * @returns {Method<D, A>} The memoized method\n *\n * @overload\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 memoize\n * @param {number} expirationTimeMs - Cache expiration time in milliseconds\n * @returns {Method<D, A>} The memoized method\n *\n * @example\n * ```typescript\n * class ExpensiveOperations {\n *   calculatePrimes(max: number): number[] {\n *     const primes = [];\n *     for (let i = 2; i <= max; i++) {\n *       if (this.isPrime(i)) primes.push(i);\n *     }\n *     return primes;\n *   }\n * }\n *\n * const ops = new ExpensiveOperations();\n *\n * // Basic memoization\n * const memoized = memoizeFn(ops.calculatePrimes.bind(ops));\n * const primes1 = memoized(1000); // Computes\n * const primes2 = memoized(1000); // Returns cached result\n *\n * // With TTL\n * const withTTL = memoizeFn(\n *   ops.calculatePrimes.bind(ops),\n *   60000 // Cache for 60 seconds\n * );\n *\n * // With custom config\n * const withConfig = memoizeFn(\n *   ops.calculatePrimes.bind(ops),\n *   {\n *     cache: new Map(),\n *     keyResolver: (max) => `primes-${max}`,\n *     expirationTimeMs: 300000\n *   }\n * );\n * ```\n */\nexport function memoizeFn<D = any, A extends any[] = any[]>(\n  originalMethod: Method<D, A>,\n): Method<D, A>;\nexport function memoizeFn<D = any, A extends any[] = any[]>(\n  originalMethod: Method<D, A>,\n  config: MemoizeConfig<any, D>,\n): Method<D, A>;\nexport function memoizeFn<D = any, A extends any[] = any[]>(\n  originalMethod: Method<D, A>,\n  expirationTimeMs: number,\n): Method<D, A>;\nexport function memoizeFn<D = any, A extends any[] = any[]>(\n  originalMethod: Method<D, A>,\n  input?: MemoizeConfig<any, D> | number,\n): Method<D, A> {\n  const defaultConfig: MemoizeConfig<any, D> = {\n    cache: new Map<string, D>(),\n  };\n\n  const runner = new TaskExec();\n  let resolvedConfig = {\n    ...defaultConfig,\n  } as MemoizeConfig<any, D>;\n\n  if (typeof input === 'number') {\n    resolvedConfig.expirationTimeMs = input;\n  } else {\n    resolvedConfig = {\n      ...resolvedConfig,\n      ...input,\n    };\n  }\n\n  return function (this: any, ...args: A): D {\n    const keyResolver =\n      typeof resolvedConfig.keyResolver === 'string'\n        ? this[resolvedConfig.keyResolver].bind(this)\n        : resolvedConfig.keyResolver;\n\n    const key = keyResolver ? keyResolver(...args) : JSON.stringify(args);\n\n    if (resolvedConfig.cache && !resolvedConfig.cache.has(key)) {\n      const response = originalMethod.apply(this, args);\n\n      if (resolvedConfig.expirationTimeMs !== undefined) {\n        runner.exec(() => {\n          resolvedConfig.cache?.delete(key);\n        }, resolvedConfig.expirationTimeMs);\n      }\n\n      resolvedConfig.cache.set(key, response);\n    }\n\n    return resolvedConfig.cache?.get(key) as D;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA0FA,SAAgB,UACd,gBACA,OACc;CACd,MAAM,gBAAuC,EAC3C,uBAAO,IAAI,KAAgB,EAC5B;CAED,MAAM,SAAS,IAAI,UAAU;CAC7B,IAAI,iBAAiB,EACnB,GAAG,eACJ;AAED,KAAI,OAAO,UAAU,SACnB,gBAAe,mBAAmB;KAElC,kBAAiB;EACf,GAAG;EACH,GAAG;EACJ;AAGH,QAAO,SAAqB,GAAG,MAAY;EACzC,MAAM,cACJ,OAAO,eAAe,gBAAgB,WAClC,KAAK,eAAe,aAAa,KAAK,KAAK,GAC3C,eAAe;EAErB,MAAM,MAAM,cAAc,YAAY,GAAG,KAAK,GAAG,KAAK,UAAU,KAAK;AAErE,MAAI,eAAe,SAAS,CAAC,eAAe,MAAM,IAAI,IAAI,EAAE;GAC1D,MAAM,WAAW,eAAe,MAAM,MAAM,KAAK;AAEjD,OAAI,eAAe,qBAAqB,KAAA,EACtC,QAAO,WAAW;AAChB,mBAAe,OAAO,OAAO,IAAI;MAChC,eAAe,iBAAiB;AAGrC,kBAAe,MAAM,IAAI,KAAK,SAAS;;AAGzC,SAAO,eAAe,OAAO,IAAI,IAAI"}

package/lib/memoize/memoize.js

@@ -0,0 +1,40 @@
+import { memoizeFn } from "./memoize.fn.js";
+//#region src/memoize/memoize.ts
+/**
+* @fileoverview Memoize decorator - caches method results based on arguments.
+* Subsequent calls with the same arguments return the cached result instead of
+* re-executing the method.
+*
+* @module @resq/typescript/decorators/memoize
+*
+* @example
+* ```typescript
+* class Calculator {
+*   @memoize()
+*   fibonacci(n: number): number {
+*     if (n <= 1) return n;
+*     return this.fibonacci(n - 1) + this.fibonacci(n - 2);
+*   }
+* }
+*
+* const calc = new Calculator();
+* console.log(calc.fibonacci(40)); // Computes and caches
+* console.log(calc.fibonacci(40)); // Returns cached result instantly
+* ```
+*
+* @copyright Copyright (c) 2026 ResQ
+* @license MIT
+*/
+function memoize(input) {
+	return (target, propertyName, descriptor) => {
+		if (descriptor.value) {
+			descriptor.value = input === void 0 ? memoizeFn(descriptor.value) : memoizeFn(descriptor.value, input);
+			return descriptor;
+		}
+		throw new Error("@memoize is applicable only on a methods.");
+	};
+}
+//#endregion
+export { memoize };
+
+//# sourceMappingURL=memoize.js.map

package/lib/memoize/memoize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.js","names":[],"sources":["../../src/memoize/memoize.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 * 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 Memoize decorator - caches method results based on arguments.\n * Subsequent calls with the same arguments return the cached result instead of\n * re-executing the method.\n *\n * @module @resq/typescript/decorators/memoize\n *\n * @example\n * ```typescript\n * class Calculator {\n *   @memoize()\n *   fibonacci(n: number): number {\n *     if (n <= 1) return n;\n *     return this.fibonacci(n - 1) + this.fibonacci(n - 2);\n *   }\n * }\n *\n * const calc = new Calculator();\n * console.log(calc.fibonacci(40)); // Computes and caches\n * console.log(calc.fibonacci(40)); // Returns cached result instantly\n * ```\n *\n * @copyright Copyright (c) 2026 ResQ\n * @license MIT\n */\n\nimport { memoizeFn } from './memoize.fn.js';\nimport type { Memoizable, MemoizeConfig } from './memoize.types.js';\n\n/**\n * Decorator that caches method results based on their arguments.\n * Subsequent calls with the same arguments return the cached result.\n *\n * @overload\n * @template T - The type of the class containing the decorated method\n * @template D - The return type of the decorated method\n * @returns {Memoizable<T, D>} The decorator function\n *\n * @overload\n * @template T - The type of the class containing the decorated method\n * @template D - The return type of the decorated method\n * @param {MemoizeConfig<T, D>} config - Configuration for memoization\n * @returns {Memoizable<T, D>} The decorator function\n *\n * @overload\n * @template T - The type of the class containing the decorated method\n * @template D - The return type of the decorated method\n * @param {number} expirationTimeMs - Cache expiration time in milliseconds\n * @returns {Memoizable<T, D>} The decorator function\n *\n * @throws {Error} When applied to a non-method property\n *\n * @example\n * ```typescript\n * class DataService {\n *   // Basic usage - caches indefinitely\n *   @memoize()\n *   getUser(id: string): User {\n *     return this.database.findUser(id);\n *   }\n *\n *   // With TTL (time to live)\n *   @memoize(60000) // Cache for 60 seconds\n *   getConfig(): Config {\n *     return this.loadConfig();\n *   }\n *\n *   // With custom cache and key resolver\n *   @memoize({\n *     cache: new LRUCache<string, User>(100),\n *     keyResolver: (userId, includeDetails) => `${userId}-${includeDetails}`,\n *     expirationTimeMs: 300000 // 5 minutes\n *   })\n *   getUserWithDetails(userId: string, includeDetails: boolean): User {\n *     return this.fetchUser(userId, includeDetails);\n *   }\n * }\n *\n * const service = new DataService();\n *\n * // First call executes the method\n * const user1 = service.getUser('123');\n *\n * // Second call with same argument returns cached result\n * const user2 = service.getUser('123'); // Instant, no database query\n * ```\n */\nexport function memoize<T = any, D = any>(): Memoizable<T, D>;\nexport function memoize<T = any, D = any>(config: MemoizeConfig<T, D>): Memoizable<T, D>;\nexport function memoize<T = any, D = any>(expirationTimeMs: number): Memoizable<T, D>;\nexport function memoize<T = any, D = any>(input?: MemoizeConfig<T, D> | number): Memoizable<T, D> {\n  return (\n    target: T,\n    propertyName: keyof T,\n    descriptor: TypedPropertyDescriptor<Method<D>>,\n  ): TypedPropertyDescriptor<Method<D>> => {\n    if (descriptor.value) {\n      descriptor.value = input === undefined ? memoizeFn(descriptor.value) : memoizeFn(descriptor.value, input as any);\n\n      return descriptor;\n    }\n    throw new Error('@memoize is applicable only on a methods.');\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2HA,SAAgB,QAA0B,OAAwD;AAChG,SACE,QACA,cACA,eACuC;AACvC,MAAI,WAAW,OAAO;AACpB,cAAW,QAAQ,UAAU,KAAA,IAAY,UAAU,WAAW,MAAM,GAAG,UAAU,WAAW,OAAO,MAAa;AAEhH,UAAO;;AAET,QAAM,IAAI,MAAM,4CAA4C"}

package/lib/memoize/memoize.types.d.ts

@@ -0,0 +1,107 @@
+import { Method } from "../types.js";
+
+//#region src/memoize/memoize.types.d.ts
+/**
+* @fileoverview Type definitions for the Memoize decorator.
+* Provides types for caching method results.
+*
+* @module @resq/typescript/decorators/memoize/types
+*
+* @copyright Copyright (c) 2026 ResQ
+* @license MIT
+*/
+/**
+ * @fileoverview Type definitions for the Memoize decorator.
+ * Provides types for caching method results.
+ *
+ * @module @resq/typescript/decorators/memoize/types
+ *
+ * @copyright Copyright (c) 2026 ResQ
+ * @license MIT
+ */
+/**
+ * Function type for resolving cache keys from method arguments.
+ *
+ * @param {...any[]} args - The method arguments
+ * @returns {string} The cache key string
+ *
+ * @example
+ * ```typescript
+ * const keyResolver: KeyResolver = (userId, includeDetails) => {
+ *   return `${userId}-${includeDetails}`;
+ * };
+ * ```
+ */
+type KeyResolver = (...args: unknown[]) => string;
+/**
+ * Interface for cache implementations used by the memoize decorator.
+ *
+ * @interface Cache
+ * @template D - The type of values stored in the cache
+ * @property {(key: string, value: D) => void} set - Store a value in the cache
+ * @property {(key: string) => D | null | undefined} get - Retrieve a value from the cache
+ * @property {(key: string) => void} delete - Remove a value from the cache
+ * @property {(key: string) => boolean} has - Check if a key exists in the cache
+ *
+ * @example
+ * ```typescript
+ * const cache: Cache<User> = {
+ *   set: (key, value) => storage.set(key, value),
+ *   get: (key) => storage.get(key),
+ *   delete: (key) => storage.delete(key),
+ *   has: (key) => storage.has(key)
+ * };
+ * ```
+ */
+interface Cache<D> {
+  /** Store a value in the cache */
+  set: (key: string, value: D) => void;
+  /** Retrieve a value from the cache */
+  get: (key: string) => D | null | undefined;
+  /** Remove a value from the cache */
+  delete: (key: string) => void;
+  /** Check if a key exists in the cache */
+  has: (key: string) => boolean;
+}
+/**
+ * Configuration options for the @memoize decorator.
+ *
+ * @interface MemoizeConfig
+ * @template T - The type of the class containing the decorated method
+ * @template D - The return type of the decorated method
+ * @property {Cache<D>} [cache] - Custom cache implementation (defaults to Map)
+ * @property {KeyResolver | keyof T} [keyResolver] - Function or method name for generating cache keys
+ * @property {number} [expirationTimeMs] - Time in milliseconds after which cached values expire
+ *
+ * @example
+ * ```typescript
+ * const config: MemoizeConfig<MyService, User> = {
+ *   cache: new LRUCache<string, User>(100),
+ *   keyResolver: (id) => `user-${id}`,
+ *   expirationTimeMs: 300000 // 5 minutes
+ * };
+ * ```
+ */
+interface MemoizeConfig<T, D> {
+  /** Custom cache implementation (defaults to Map) */
+  cache?: Cache<D>;
+  /** Function or method name for generating cache keys */
+  keyResolver?: KeyResolver | keyof T;
+  /** Time in milliseconds after which cached values expire */
+  expirationTimeMs?: number;
+}
+/**
+ * Type for the @memoize decorator function.
+ *
+ * @template T - The type of the class containing the decorated method
+ * @template D - The return type of the decorated method
+ *
+ * @param {T} target - The class prototype
+ * @param {keyof T} propertyName - The name of the method being decorated
+ * @param {TypedPropertyDescriptor<Method<D>>} descriptor - The property descriptor
+ * @returns {TypedPropertyDescriptor<Method<D>>} The modified descriptor
+ */
+type Memoizable<T, D> = (target: T, propertyName: keyof T, descriptor: TypedPropertyDescriptor<Method<D>>) => TypedPropertyDescriptor<Method<D>>;
+//#endregion
+export { Cache, KeyResolver, Memoizable, MemoizeConfig };
+//# sourceMappingURL=memoize.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.types.d.ts","names":[],"sources":["../../src/memoize/memoize.types.ts"],"mappings":";;;;;;;;;;;;;AA8EA;;;;;;;;;;;;;;;;;;AA8BA;;;KApDY,WAAA,OAAkB,IAAA;;;;;;;;;;;;;;;;;AAwE9B;;;;UAlDiB,KAAA;EAqD4B;EAnD3C,GAAA,GAAM,GAAA,UAAa,KAAA,EAAO,CAAA;EAmDd;EAjDZ,GAAA,GAAM,GAAA,aAAgB,CAAA;EAkDK;EAhD3B,MAAA,GAAS,GAAA;EAgDiB;EA9C1B,GAAA,GAAM,GAAA;AAAA;;;;;;;;;;;;;;;;;;;;UAsBS,aAAA;;EAEf,KAAA,GAAQ,KAAA,CAAM,CAAA;;EAEd,WAAA,GAAc,WAAA,SAAoB,CAAA;;EAElC,gBAAA;AAAA;;;;;;;;;;;;KAcU,UAAA,UACV,MAAA,EAAQ,CAAA,EACR,YAAA,QAAoB,CAAA,EACpB,UAAA,EAAY,uBAAA,CAAwB,MAAA,CAAO,CAAA,OACxC,uBAAA,CAAwB,MAAA,CAAO,CAAA"}

package/lib/memoize-async/index.d.ts

@@ -0,0 +1,4 @@
+import { AsyncCache, AsyncMemoizable, AsyncMemoizeConfig } from "./memoize-async.types.js";
+import { memoizeAsyncFn } from "./memoize-async.fn.js";
+import { memoizeAsync } from "./memoize-async.js";
+export { AsyncCache, AsyncMemoizable, AsyncMemoizeConfig, memoizeAsync, memoizeAsyncFn };

package/lib/memoize-async/index.js

@@ -0,0 +1,3 @@
+import { memoizeAsyncFn } from "./memoize-async.fn.js";
+import { memoizeAsync } from "./memoize-async.js";
+export { memoizeAsync, memoizeAsyncFn };

package/lib/memoize-async/memoize-async.d.ts

@@ -0,0 +1,68 @@
+import { AsyncMemoizable, AsyncMemoizeConfig } from "./memoize-async.types.js";
+
+//#region src/memoize-async/memoize-async.d.ts
+/**
+ * Decorator that caches async method results based on their arguments.
+ * Prevents duplicate concurrent requests by returning the same promise
+ * for identical calls until the first one resolves.
+ *
+ * @overload
+ * @template T - The type of the class containing the decorated method
+ * @template D - The resolved type of the async method
+ * @returns {AsyncMemoizable<T, D>} The decorator function
+ *
+ * @overload
+ * @template T - The type of the class containing the decorated method
+ * @template D - The resolved type of the async method
+ * @param {AsyncMemoizeConfig<T, D>} config - Configuration for memoization
+ * @returns {AsyncMemoizable<T, D>} The decorator function
+ *
+ * @overload
+ * @template T - The type of the class containing the decorated method
+ * @template D - The resolved type of the async method
+ * @param {number} expirationTimeMs - Cache expiration time in milliseconds
+ * @returns {AsyncMemoizable<T, D>} The decorator function
+ *
+ * @throws {Error} When applied to a non-method property
+ *
+ * @example
+ * ```typescript
+ * class DataService {
+ *   // Basic usage - caches indefinitely
+ *   @memoizeAsync()
+ *   async fetchConfig(): Promise<Config> {
+ *     return fetch('/api/config').then(r => r.json());
+ *   }
+ *
+ *   // With TTL
+ *   @memoizeAsync(60000) // Cache for 60 seconds
+ *   async getExchangeRates(): Promise<Rates> {
+ *     return fetch('/api/rates').then(r => r.json());
+ *   }
+ *
+ *   // With custom cache and key resolver
+ *   @memoizeAsync({
+ *     cache: new RedisCache<string, Product>(),
+ *     keyResolver: (productId, includeDetails) => `product-${productId}-${includeDetails}`,
+ *     expirationTimeMs: 300000
+ *   })
+ *   async getProduct(productId: string, includeDetails: boolean): Promise<Product> {
+ *     return this.fetchProduct(productId, includeDetails);
+ *   }
+ * }
+ *
+ * const service = new DataService();
+ *
+ * // Concurrent calls with same args share the same promise
+ * const [product1, product2] = await Promise.all([
+ *   service.getProduct('123', true),
+ *   service.getProduct('123', true) // Same promise as above
+ * ]);
+ * ```
+ */
+declare function memoizeAsync<T = any, D = any>(): AsyncMemoizable<T, D>;
+declare function memoizeAsync<T = any, D = any>(config: AsyncMemoizeConfig<T, D>): AsyncMemoizable<T, D>;
+declare function memoizeAsync<T = any, D = any>(expirationTimeMs: number): AsyncMemoizable<T, D>;
+//#endregion
+export { memoizeAsync };
+//# sourceMappingURL=memoize-async.d.ts.map

package/lib/memoize-async/memoize-async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize-async.d.ts","names":[],"sources":["../../src/memoize-async/memoize-async.ts"],"mappings":";;;;;AAyGA;;;;;;;;;;;;;;;;;;;;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAJgB,YAAA,kBAAA,CAAA,GAAkC,eAAA,CAAgB,CAAA,EAAG,CAAA;AAAA,iBACrD,YAAA,kBAAA,CACd,MAAA,EAAQ,kBAAA,CAAmB,CAAA,EAAG,CAAA,IAC7B,eAAA,CAAgB,CAAA,EAAG,CAAA;AAAA,iBACN,YAAA,kBAAA,CAA+B,gBAAA,WAA2B,eAAA,CAAgB,CAAA,EAAG,CAAA"}

package/lib/memoize-async/memoize-async.fn.d.ts

@@ -0,0 +1,69 @@
+import { AsyncMethod } from "../types.js";
+import { AsyncMemoizeConfig } from "./memoize-async.types.js";
+
+//#region src/memoize-async/memoize-async.fn.d.ts
+/**
+ * Wraps an async method to cache its results and deduplicate concurrent calls.
+ *
+ * @overload
+ * @template D - The resolved type of the async method
+ * @template A - The argument types of the original method
+ * @param {AsyncMethod<D, A>} originalMethod - The async method to memoize
+ * @returns {AsyncMethod<D, A>} The memoized method
+ *
+ * @overload
+ * @template D - The resolved type of the async method
+ * @template A - The argument types of the original method
+ * @param {AsyncMethod<D, A>} originalMethod - The async method to memoize
+ * @param {AsyncMemoizeConfig<any, D>} config - Configuration for memoization
+ * @returns {AsyncMethod<D, A>} The memoized method
+ *
+ * @overload
+ * @template D - The resolved type of the async method
+ * @template A - The argument types of the original method
+ * @param {AsyncMethod<D, A>} originalMethod - The async method to memoize
+ * @param {number} expirationTimeMs - Cache expiration time in milliseconds
+ * @returns {AsyncMethod<D, A>} The memoized method
+ *
+ * @example
+ * ```typescript
+ * class ApiClient {
+ *   async fetchData(endpoint: string): Promise<Data> {
+ *     const response = await fetch(endpoint);
+ *     return response.json();
+ *   }
+ * }
+ *
+ * const client = new ApiClient();
+ *
+ * // Basic memoization
+ * const memoized = memoizeAsyncFn(client.fetchData.bind(client));
+ *
+ * // Concurrent calls share the same promise
+ * const promise1 = memoized('/api/data');
+ * const promise2 = memoized('/api/data'); // Same promise as above
+ * const [data1, data2] = await Promise.all([promise1, promise2]);
+ *
+ * // With TTL
+ * const withTTL = memoizeAsyncFn(
+ *   client.fetchData.bind(client),
+ *   60000 // Cache for 60 seconds
+ * );
+ *
+ * // With custom config
+ * const withConfig = memoizeAsyncFn(
+ *   client.fetchData.bind(client),
+ *   {
+ *     cache: new Map(),
+ *     keyResolver: (endpoint) => endpoint,
+ *     expirationTimeMs: 300000
+ *   }
+ * );
+ * ```
+ */
+declare function memoizeAsyncFn<D = any, A extends any[] = any[]>(originalMethod: AsyncMethod<D, A>): AsyncMethod<D, A>;
+declare function memoizeAsyncFn<D = any, A extends any[] = any[]>(originalMethod: AsyncMethod<D, A>, config: AsyncMemoizeConfig<any, D>): AsyncMethod<D, A>;
+declare function memoizeAsyncFn<D = any, A extends any[] = any[]>(originalMethod: AsyncMethod<D, A>, expirationTimeMs: number): AsyncMethod<D, A>;
+//#endregion
+export { memoizeAsyncFn };
+//# sourceMappingURL=memoize-async.fn.d.ts.map

package/lib/memoize-async/memoize-async.fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize-async.fn.d.ts","names":[],"sources":["../../src/memoize-async/memoize-async.fn.ts"],"mappings":";;;;;;;;;;;;;AAkFA;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;iBAPgB,cAAA,kCAAA,CACd,cAAA,EAAgB,WAAA,CAAY,CAAA,EAAG,CAAA,IAC9B,WAAA,CAAY,CAAA,EAAG,CAAA;AAAA,iBACF,cAAA,kCAAA,CACd,cAAA,EAAgB,WAAA,CAAY,CAAA,EAAG,CAAA,GAC/B,MAAA,EAAQ,kBAAA,MAAwB,CAAA,IAC/B,WAAA,CAAY,CAAA,EAAG,CAAA;AAAA,iBACF,cAAA,kCAAA,CACd,cAAA,EAAgB,WAAA,CAAY,CAAA,EAAG,CAAA,GAC/B,gBAAA,WACC,WAAA,CAAY,CAAA,EAAG,CAAA"}

package/lib/memoize-async/memoize-async.fn.js

@@ -0,0 +1,52 @@
+import { TaskExec, isNumber, isString } from "../_utils.js";
+//#region src/memoize-async/memoize-async.fn.ts
+/**
+* Copyright 2026 ResQ
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+function memoizeAsyncFn(originalMethod, input) {
+	const defaultConfig = { cache: /* @__PURE__ */ new Map() };
+	const runner = new TaskExec();
+	const promCache = /* @__PURE__ */ new Map();
+	let resolvedConfig = { ...defaultConfig };
+	if (isNumber(input)) resolvedConfig.expirationTimeMs = input;
+	else resolvedConfig = {
+		...resolvedConfig,
+		...input
+	};
+	return async function(...args) {
+		const keyResolver = isString(resolvedConfig.keyResolver) ? this[resolvedConfig.keyResolver].bind(this) : resolvedConfig.keyResolver;
+		let key;
+		if (keyResolver) key = keyResolver(...args);
+		else key = JSON.stringify(args);
+		if (promCache.has(key)) return promCache.get(key);
+		const prom = (async () => {
+			if (await resolvedConfig.cache?.has(key) ?? false) return await resolvedConfig.cache?.get(key);
+			const data = await originalMethod.apply(this, args);
+			await resolvedConfig.cache?.set(key, data);
+			if (resolvedConfig.expirationTimeMs !== void 0) runner.exec(() => {
+				resolvedConfig.cache?.delete(key);
+			}, resolvedConfig.expirationTimeMs);
+			return data;
+		})().finally(() => {
+			promCache.delete(key);
+		});
+		promCache.set(key, prom);
+		return prom;
+	};
+}
+//#endregion
+export { memoizeAsyncFn };
+
+//# sourceMappingURL=memoize-async.fn.js.map

package/lib/memoize-async/memoize-async.fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize-async.fn.js","names":[],"sources":["../../src/memoize-async/memoize-async.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 { isNumber, isString, TaskExec } from '../_utils.js';\nimport type { AsyncMethod } from '../types.js';\nimport type { AsyncMemoizeConfig } from './memoize-async.types.js';\n\n/**\n * Wraps an async method to cache its results and deduplicate concurrent calls.\n *\n * @overload\n * @template D - The resolved type of the async method\n * @template A - The argument types of the original method\n * @param {AsyncMethod<D, A>} originalMethod - The async method to memoize\n * @returns {AsyncMethod<D, A>} The memoized method\n *\n * @overload\n * @template D - The resolved type of the async method\n * @template A - The argument types of the original method\n * @param {AsyncMethod<D, A>} originalMethod - The async method to memoize\n * @param {AsyncMemoizeConfig<any, D>} config - Configuration for memoization\n * @returns {AsyncMethod<D, A>} The memoized method\n *\n * @overload\n * @template D - The resolved type of the async method\n * @template A - The argument types of the original method\n * @param {AsyncMethod<D, A>} originalMethod - The async method to memoize\n * @param {number} expirationTimeMs - Cache expiration time in milliseconds\n * @returns {AsyncMethod<D, A>} The memoized method\n *\n * @example\n * ```typescript\n * class ApiClient {\n *   async fetchData(endpoint: string): Promise<Data> {\n *     const response = await fetch(endpoint);\n *     return response.json();\n *   }\n * }\n *\n * const client = new ApiClient();\n *\n * // Basic memoization\n * const memoized = memoizeAsyncFn(client.fetchData.bind(client));\n *\n * // Concurrent calls share the same promise\n * const promise1 = memoized('/api/data');\n * const promise2 = memoized('/api/data'); // Same promise as above\n * const [data1, data2] = await Promise.all([promise1, promise2]);\n *\n * // With TTL\n * const withTTL = memoizeAsyncFn(\n *   client.fetchData.bind(client),\n *   60000 // Cache for 60 seconds\n * );\n *\n * // With custom config\n * const withConfig = memoizeAsyncFn(\n *   client.fetchData.bind(client),\n *   {\n *     cache: new Map(),\n *     keyResolver: (endpoint) => endpoint,\n *     expirationTimeMs: 300000\n *   }\n * );\n * ```\n */\nexport function memoizeAsyncFn<D = any, A extends any[] = any[]>(\n  originalMethod: AsyncMethod<D, A>,\n): AsyncMethod<D, A>;\nexport function memoizeAsyncFn<D = any, A extends any[] = any[]>(\n  originalMethod: AsyncMethod<D, A>,\n  config: AsyncMemoizeConfig<any, D>,\n): AsyncMethod<D, A>;\nexport function memoizeAsyncFn<D = any, A extends any[] = any[]>(\n  originalMethod: AsyncMethod<D, A>,\n  expirationTimeMs: number,\n): AsyncMethod<D, A>;\n\nexport function memoizeAsyncFn<D = any, A extends any[] = any[]>(\n  originalMethod: AsyncMethod<D, A>,\n  input?: AsyncMemoizeConfig<any, D> | number,\n): AsyncMethod<D, A> {\n  const defaultConfig: AsyncMemoizeConfig<any, D> = {\n    cache: new Map<string, D>(),\n  };\n  const runner = new TaskExec();\n  const promCache = new Map<string, Promise<D>>();\n  let resolvedConfig = {\n    ...defaultConfig,\n  } as AsyncMemoizeConfig<any, D>;\n\n  if (isNumber(input)) {\n    resolvedConfig.expirationTimeMs = input;\n  } else {\n    resolvedConfig = {\n      ...resolvedConfig,\n      ...input,\n    };\n  }\n\n  return async function (this: any, ...args: A): Promise<D> {\n    const keyResolver = isString(resolvedConfig.keyResolver)\n      ? this[resolvedConfig.keyResolver].bind(this)\n      : resolvedConfig.keyResolver;\n\n    let key;\n\n    if (keyResolver) {\n      key = keyResolver(...args);\n    } else {\n      key = JSON.stringify(args);\n    }\n\n    if (promCache.has(key)) {\n      return promCache.get(key) as Promise<D>;\n    }\n\n    const prom = (async (): Promise<D> => {\n      const inCache = (await resolvedConfig.cache?.has(key)) ?? false;\n\n      if (inCache) {\n        return (await resolvedConfig.cache?.get(key)) as D;\n      }\n\n      const data = await originalMethod.apply(this, args);\n      await resolvedConfig.cache?.set(key, data);\n\n      if (resolvedConfig.expirationTimeMs !== undefined) {\n        runner.exec(() => {\n          resolvedConfig.cache?.delete(key);\n        }, resolvedConfig.expirationTimeMs);\n      }\n\n      return data;\n    })().finally(() => {\n      promCache.delete(key);\n    });\n\n    promCache.set(key, prom);\n\n    return prom;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA2FA,SAAgB,eACd,gBACA,OACmB;CACnB,MAAM,gBAA4C,EAChD,uBAAO,IAAI,KAAgB,EAC5B;CACD,MAAM,SAAS,IAAI,UAAU;CAC7B,MAAM,4BAAY,IAAI,KAAyB;CAC/C,IAAI,iBAAiB,EACnB,GAAG,eACJ;AAED,KAAI,SAAS,MAAM,CACjB,gBAAe,mBAAmB;KAElC,kBAAiB;EACf,GAAG;EACH,GAAG;EACJ;AAGH,QAAO,eAA2B,GAAG,MAAqB;EACxD,MAAM,cAAc,SAAS,eAAe,YAAY,GACpD,KAAK,eAAe,aAAa,KAAK,KAAK,GAC3C,eAAe;EAEnB,IAAI;AAEJ,MAAI,YACF,OAAM,YAAY,GAAG,KAAK;MAE1B,OAAM,KAAK,UAAU,KAAK;AAG5B,MAAI,UAAU,IAAI,IAAI,CACpB,QAAO,UAAU,IAAI,IAAI;EAG3B,MAAM,QAAQ,YAAwB;AAGpC,OAFiB,MAAM,eAAe,OAAO,IAAI,IAAI,IAAK,MAGxD,QAAQ,MAAM,eAAe,OAAO,IAAI,IAAI;GAG9C,MAAM,OAAO,MAAM,eAAe,MAAM,MAAM,KAAK;AACnD,SAAM,eAAe,OAAO,IAAI,KAAK,KAAK;AAE1C,OAAI,eAAe,qBAAqB,KAAA,EACtC,QAAO,WAAW;AAChB,mBAAe,OAAO,OAAO,IAAI;MAChC,eAAe,iBAAiB;AAGrC,UAAO;MACL,CAAC,cAAc;AACjB,aAAU,OAAO,IAAI;IACrB;AAEF,YAAU,IAAI,KAAK,KAAK;AAExB,SAAO"}

package/lib/memoize-async/memoize-async.js

@@ -0,0 +1,15 @@
+import { memoizeAsyncFn } from "./memoize-async.fn.js";
+//#region src/memoize-async/memoize-async.ts
+function memoizeAsync(input) {
+	return (target, propertyName, descriptor) => {
+		if (descriptor.value) {
+			descriptor.value = input === void 0 ? memoizeAsyncFn(descriptor.value) : memoizeAsyncFn(descriptor.value, input);
+			return descriptor;
+		}
+		throw new Error("@memoizeAsync is applicable only on a methods.");
+	};
+}
+//#endregion
+export { memoizeAsync };
+
+//# sourceMappingURL=memoize-async.js.map

package/lib/memoize-async/memoize-async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize-async.js","names":[],"sources":["../../src/memoize-async/memoize-async.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 MemoizeAsync decorator - caches async method results based on arguments.\n * Similar to @memoize but designed for async methods with support for promise deduplication.\n *\n * @module @resq/typescript/decorators/memoize-async\n *\n * @example\n * ```typescript\n * class ApiService {\n *   @memoizeAsync()\n *   async fetchUser(userId: string): Promise<User> {\n *     const response = await fetch(`/api/users/${userId}`);\n *     return response.json();\n *   }\n * }\n *\n * const api = new ApiService();\n * const user1 = await api.fetchUser('123'); // Fetches from API\n * const user2 = await api.fetchUser('123'); // Returns cached promise\n * ```\n *\n * @copyright Copyright (c) 2026 ResQ\n * @license MIT\n */\n\nimport type { AsyncMethod } from '../types.js';\nimport { memoizeAsyncFn } from './memoize-async.fn.js';\nimport type { AsyncMemoizable, AsyncMemoizeConfig } from './memoize-async.types.js';\n\n/**\n * Decorator that caches async method results based on their arguments.\n * Prevents duplicate concurrent requests by returning the same promise\n * for identical calls until the first one resolves.\n *\n * @overload\n * @template T - The type of the class containing the decorated method\n * @template D - The resolved type of the async method\n * @returns {AsyncMemoizable<T, D>} The decorator function\n *\n * @overload\n * @template T - The type of the class containing the decorated method\n * @template D - The resolved type of the async method\n * @param {AsyncMemoizeConfig<T, D>} config - Configuration for memoization\n * @returns {AsyncMemoizable<T, D>} The decorator function\n *\n * @overload\n * @template T - The type of the class containing the decorated method\n * @template D - The resolved type of the async method\n * @param {number} expirationTimeMs - Cache expiration time in milliseconds\n * @returns {AsyncMemoizable<T, D>} The decorator function\n *\n * @throws {Error} When applied to a non-method property\n *\n * @example\n * ```typescript\n * class DataService {\n *   // Basic usage - caches indefinitely\n *   @memoizeAsync()\n *   async fetchConfig(): Promise<Config> {\n *     return fetch('/api/config').then(r => r.json());\n *   }\n *\n *   // With TTL\n *   @memoizeAsync(60000) // Cache for 60 seconds\n *   async getExchangeRates(): Promise<Rates> {\n *     return fetch('/api/rates').then(r => r.json());\n *   }\n *\n *   // With custom cache and key resolver\n *   @memoizeAsync({\n *     cache: new RedisCache<string, Product>(),\n *     keyResolver: (productId, includeDetails) => `product-${productId}-${includeDetails}`,\n *     expirationTimeMs: 300000\n *   })\n *   async getProduct(productId: string, includeDetails: boolean): Promise<Product> {\n *     return this.fetchProduct(productId, includeDetails);\n *   }\n * }\n *\n * const service = new DataService();\n *\n * // Concurrent calls with same args share the same promise\n * const [product1, product2] = await Promise.all([\n *   service.getProduct('123', true),\n *   service.getProduct('123', true) // Same promise as above\n * ]);\n * ```\n */\nexport function memoizeAsync<T = any, D = any>(): AsyncMemoizable<T, D>;\nexport function memoizeAsync<T = any, D = any>(\n  config: AsyncMemoizeConfig<T, D>,\n): AsyncMemoizable<T, D>;\nexport function memoizeAsync<T = any, D = any>(expirationTimeMs: number): AsyncMemoizable<T, D>;\nexport function memoizeAsync<T = any, D = any>(\n  input?: AsyncMemoizeConfig<T, D> | number,\n): AsyncMemoizable<T, D> {\n  return (\n    target: T,\n    propertyName: keyof T,\n    descriptor: TypedPropertyDescriptor<AsyncMethod<D>>,\n  ): TypedPropertyDescriptor<AsyncMethod<D>> => {\n    if (descriptor.value) {\n      descriptor.value = input === undefined ? memoizeAsyncFn(descriptor.value) : memoizeAsyncFn(descriptor.value, input as any);\n\n      return descriptor;\n    }\n\n    throw new Error('@memoizeAsync is applicable only on a methods.');\n  };\n}\n"],"mappings":";;AA6GA,SAAgB,aACd,OACuB;AACvB,SACE,QACA,cACA,eAC4C;AAC5C,MAAI,WAAW,OAAO;AACpB,cAAW,QAAQ,UAAU,KAAA,IAAY,eAAe,WAAW,MAAM,GAAG,eAAe,WAAW,OAAO,MAAa;AAE1H,UAAO;;AAGT,QAAM,IAAI,MAAM,iDAAiD"}