@resq-sw/decorators 0.1.0

package/lib/delegate/delegate.types.d.ts

@@ -0,0 +1,45 @@
+import { AsyncMethod } from "../types.js";
+
+//#region src/delegate/delegate.types.d.ts
+/**
+* @fileoverview Type definitions for the Delegate decorator.
+* Provides the Delegatable type for method decorators that deduplicate async calls.
+*
+* @module @resq/typescript/decorators/delegate/types
+*
+* @copyright Copyright (c) 2026 ResQ
+* @license MIT
+*/
+/**
+ * @fileoverview Type definitions for the Delegate decorator.
+ * Provides the Delegatable type for method decorators that deduplicate async calls.
+ *
+ * @module @resq/typescript/decorators/delegate/types
+ *
+ * @copyright Copyright (c) 2026 ResQ
+ * @license MIT
+ */
+/**
+ * Type for the @delegate decorator function.
+ * Transforms an async method into one that deduplicates concurrent calls.
+ *
+ * @template T - The type of the class containing the decorated method
+ * @template D - The return type of the decorated async method
+ *
+ * @param {T} target - The class prototype
+ * @param {keyof T} propertyName - The name of the method being decorated
+ * @param {TypedPropertyDescriptor<AsyncMethod<D>>} descriptor - The property descriptor
+ * @returns {TypedPropertyDescriptor<AsyncMethod<D>>} The modified descriptor
+ *
+ * @example
+ * ```typescript
+ * type MyDelegatable = Delegatable<MyService, User>;
+ *
+ * // Usage in decorator factory
+ * const decorator: MyDelegatable = delegate((id) => id);
+ * ```
+ */
+type Delegatable<T, D> = (target: T, propertyName: keyof T, descriptor: TypedPropertyDescriptor<AsyncMethod<D>>) => TypedPropertyDescriptor<AsyncMethod<D>>;
+//#endregion
+export { Delegatable };
+//# sourceMappingURL=delegate.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delegate.types.d.ts","names":[],"sources":["../../src/delegate/delegate.types.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+DY,WAAA,UACV,MAAA,EAAQ,CAAA,EACR,YAAA,QAAoB,CAAA,EACpB,UAAA,EAAY,uBAAA,CAAwB,WAAA,CAAY,CAAA,OAC7C,uBAAA,CAAwB,WAAA,CAAY,CAAA"}

package/lib/delegate/index.d.ts

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

package/lib/delegate/index.js

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

package/lib/exec-time/exec-time.d.ts

@@ -0,0 +1,42 @@
+import { ReportFunction } from "./exec-time.types.js";
+
+//#region src/exec-time/exec-time.d.ts
+/**
+ * Decorator that measures and reports the execution time of methods.
+ * Supports both legacy (TypeScript) and standard (Stage 3) decorator formats.
+ *
+ * @param {ReportFunction | string} [arg] - Optional reporter function or label string
+ * @returns {any} The decorator function
+ *
+ * @throws {Error} When applied to a non-method property
+ *
+ * @example
+ * ```typescript
+ * class PerformanceMonitor {
+ *   // Uses default console reporter
+ *   @execTime()
+ *   processData(data: any[]): void {
+ *     // Processing...
+ *   }
+ *
+ *   // Uses custom label
+ *   @execTime('Database Query')
+ *   async fetchUsers(): Promise<User[]> {
+ *     return db.users.findAll();
+ *   }
+ *
+ *   // Uses custom reporter function
+ *   @execTime((data) => {
+ *     metrics.histogram('method_duration', data.execTime);
+ *     console.log(`${data.execTime}ms: ${data.args.join(', ')}`);
+ *   })
+ *   heavyCalculation(input: number): number {
+ *     return input ** 2;
+ *   }
+ * }
+ * ```
+ */
+declare function execTime<T = any>(arg?: ReportFunction | string): any;
+//#endregion
+export { execTime };
+//# sourceMappingURL=exec-time.d.ts.map

package/lib/exec-time/exec-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-time.d.ts","names":[],"sources":["../../src/exec-time/exec-time.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgFgB,QAAA,SAAA,CAAkB,GAAA,GAAM,cAAA"}

package/lib/exec-time/exec-time.fn.d.ts

@@ -0,0 +1,50 @@
+import { AsyncMethod, Method } from "../types.js";
+import { ReportFunction } from "./exec-time.types.js";
+
+//#region src/exec-time/exec-time.fn.d.ts
+/**
+ * Wraps a method to measure and report its execution time.
+ * Handles both synchronous and asynchronous methods.
+ *
+ * @template D - The return type of the original method
+ * @template A - The argument types of the original method
+ * @param {Method<D, A> | AsyncMethod<D, A>} originalMethod - The method to wrap
+ * @param {ReportFunction | string} [arg] - Optional reporter function or label
+ * @returns {AsyncMethod<void, A>} The wrapped method
+ *
+ * @example
+ * ```typescript
+ * class Calculator {
+ *   fibonacci(n: number): number {
+ *     if (n <= 1) return n;
+ *     return this.fibonacci(n - 1) + this.fibonacci(n - 2);
+ *   }
+ * }
+ *
+ * const calc = new Calculator();
+ *
+ * // Wrap with default reporter
+ * const timed = execTimeFn(calc.fibonacci.bind(calc));
+ * await timed(40); // Logs: "Execution time: 450ms"
+ *
+ * // Wrap with custom label
+ * const labeled = execTimeFn(
+ *   calc.fibonacci.bind(calc),
+ *   'Fibonacci calculation'
+ * );
+ * await labeled(40); // Logs: "Fibonacci calculation execution time: 450ms"
+ *
+ * // Wrap with custom reporter
+ * const custom = execTimeFn(
+ *   calc.fibonacci.bind(calc),
+ *   (data) => {
+ *     console.log(`Took ${data.execTime}ms for n=${data.args[0]}`);
+ *   }
+ * );
+ * await custom(40); // Logs: "Took 450ms for n=40"
+ * ```
+ */
+declare function execTimeFn<D = any, A extends any[] = any[]>(originalMethod: Method<D, A> | AsyncMethod<D, A>, arg?: ReportFunction | string): AsyncMethod<void, A>;
+//#endregion
+export { execTimeFn };
+//# sourceMappingURL=exec-time.fn.d.ts.map

package/lib/exec-time/exec-time.fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-time.fn.d.ts","names":[],"sources":["../../src/exec-time/exec-time.fn.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwEgB,UAAA,kCAAA,CACd,cAAA,EAAgB,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,WAAA,CAAY,CAAA,EAAG,CAAA,GAC9C,GAAA,GAAM,cAAA,YACL,WAAA,OAAkB,CAAA"}

package/lib/exec-time/exec-time.fn.js

@@ -0,0 +1,91 @@
+import { isPromise, logger } from "../_utils.js";
+//#region src/exec-time/exec-time.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.
+*/
+/**
+* Default reporter function that logs execution time using the logger.
+*
+* @param {ExactTimeReportData} data - The execution data
+* @returns {void}
+*/
+const reporter = (data) => {
+	logger.info(`Execution time: ${data.execTime}ms`);
+};
+/**
+* Wraps a method to measure and report its execution time.
+* Handles both synchronous and asynchronous methods.
+*
+* @template D - The return type of the original method
+* @template A - The argument types of the original method
+* @param {Method<D, A> | AsyncMethod<D, A>} originalMethod - The method to wrap
+* @param {ReportFunction | string} [arg] - Optional reporter function or label
+* @returns {AsyncMethod<void, A>} The wrapped method
+*
+* @example
+* ```typescript
+* class Calculator {
+*   fibonacci(n: number): number {
+*     if (n <= 1) return n;
+*     return this.fibonacci(n - 1) + this.fibonacci(n - 2);
+*   }
+* }
+*
+* const calc = new Calculator();
+*
+* // Wrap with default reporter
+* const timed = execTimeFn(calc.fibonacci.bind(calc));
+* await timed(40); // Logs: "Execution time: 450ms"
+*
+* // Wrap with custom label
+* const labeled = execTimeFn(
+*   calc.fibonacci.bind(calc),
+*   'Fibonacci calculation'
+* );
+* await labeled(40); // Logs: "Fibonacci calculation execution time: 450ms"
+*
+* // Wrap with custom reporter
+* const custom = execTimeFn(
+*   calc.fibonacci.bind(calc),
+*   (data) => {
+*     console.log(`Took ${data.execTime}ms for n=${data.args[0]}`);
+*   }
+* );
+* await custom(40); // Logs: "Took 450ms for n=40"
+* ```
+*/
+function execTimeFn(originalMethod, arg) {
+	const input = arg ?? reporter;
+	return async function(...args) {
+		let repFunc;
+		if (typeof input === "string") if (typeof this[input] === "function") repFunc = this[input].bind(this);
+		else repFunc = (data) => {
+			logger.info(`${input} execution time`, { duration: `${data.execTime}ms` });
+		};
+		else repFunc = input;
+		const start = Date.now();
+		let result = originalMethod.apply(this, args);
+		if (isPromise(result)) result = await result;
+		repFunc({
+			args,
+			result,
+			execTime: Date.now() - start
+		});
+	};
+}
+//#endregion
+export { execTimeFn };
+
+//# sourceMappingURL=exec-time.fn.js.map

package/lib/exec-time/exec-time.fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-time.fn.js","names":[],"sources":["../../src/exec-time/exec-time.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 { isPromise, logger } from '../_utils.js';\nimport type { AsyncMethod, Method } from '../types.js';\nimport type { ExactTimeReportData, ReportFunction } from './exec-time.types.js';\n\n/**\n * Default reporter function that logs execution time using the logger.\n *\n * @param {ExactTimeReportData} data - The execution data\n * @returns {void}\n */\nconst reporter: ReportFunction = (data: ExactTimeReportData): void => {\n  logger.info(`Execution time: ${data.execTime}ms`);\n};\n\n/**\n * Wraps a method to measure and report its execution time.\n * Handles both synchronous and asynchronous methods.\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> | AsyncMethod<D, A>} originalMethod - The method to wrap\n * @param {ReportFunction | string} [arg] - Optional reporter function or label\n * @returns {AsyncMethod<void, A>} The wrapped method\n *\n * @example\n * ```typescript\n * class Calculator {\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 *\n * // Wrap with default reporter\n * const timed = execTimeFn(calc.fibonacci.bind(calc));\n * await timed(40); // Logs: \"Execution time: 450ms\"\n *\n * // Wrap with custom label\n * const labeled = execTimeFn(\n *   calc.fibonacci.bind(calc),\n *   'Fibonacci calculation'\n * );\n * await labeled(40); // Logs: \"Fibonacci calculation execution time: 450ms\"\n *\n * // Wrap with custom reporter\n * const custom = execTimeFn(\n *   calc.fibonacci.bind(calc),\n *   (data) => {\n *     console.log(`Took ${data.execTime}ms for n=${data.args[0]}`);\n *   }\n * );\n * await custom(40); // Logs: \"Took 450ms for n=40\"\n * ```\n */\nexport function execTimeFn<D = any, A extends any[] = any[]>(\n  originalMethod: Method<D, A> | AsyncMethod<D, A>,\n  arg?: ReportFunction | string,\n): AsyncMethod<void, A> {\n  const input: ReportFunction | string = arg ?? reporter;\n\n  return async function (this: any, ...args: A): Promise<void> {\n    let repFunc: ReportFunction;\n\n    if (typeof input === 'string') {\n      if (typeof this[input] === 'function') {\n        repFunc = this[input].bind(this);\n      } else {\n        repFunc = (data) => {\n          logger.info(`${input} execution time`, { duration: `${data.execTime}ms` });\n        };\n      }\n    } else {\n      repFunc = input;\n    }\n\n    const start = Date.now();\n    let result = (originalMethod as Function).apply(this, args);\n\n    if (isPromise(result)) {\n      result = await result;\n    }\n\n    repFunc({\n      args,\n      result,\n      execTime: Date.now() - start,\n    });\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAM,YAA4B,SAAoC;AACpE,QAAO,KAAK,mBAAmB,KAAK,SAAS,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CnD,SAAgB,WACd,gBACA,KACsB;CACtB,MAAM,QAAiC,OAAO;AAE9C,QAAO,eAA2B,GAAG,MAAwB;EAC3D,IAAI;AAEJ,MAAI,OAAO,UAAU,SACnB,KAAI,OAAO,KAAK,WAAW,WACzB,WAAU,KAAK,OAAO,KAAK,KAAK;MAEhC,YAAW,SAAS;AAClB,UAAO,KAAK,GAAG,MAAM,kBAAkB,EAAE,UAAU,GAAG,KAAK,SAAS,KAAK,CAAC;;MAI9E,WAAU;EAGZ,MAAM,QAAQ,KAAK,KAAK;EACxB,IAAI,SAAU,eAA4B,MAAM,MAAM,KAAK;AAE3D,MAAI,UAAU,OAAO,CACnB,UAAS,MAAM;AAGjB,UAAQ;GACN;GACA;GACA,UAAU,KAAK,KAAK,GAAG;GACxB,CAAC"}

package/lib/exec-time/exec-time.js

@@ -0,0 +1,55 @@
+import { execTimeFn } from "./exec-time.fn.js";
+//#region src/exec-time/exec-time.ts
+/**
+* Decorator that measures and reports the execution time of methods.
+* Supports both legacy (TypeScript) and standard (Stage 3) decorator formats.
+*
+* @param {ReportFunction | string} [arg] - Optional reporter function or label string
+* @returns {any} The decorator function
+*
+* @throws {Error} When applied to a non-method property
+*
+* @example
+* ```typescript
+* class PerformanceMonitor {
+*   // Uses default console reporter
+*   @execTime()
+*   processData(data: any[]): void {
+*     // Processing...
+*   }
+*
+*   // Uses custom label
+*   @execTime('Database Query')
+*   async fetchUsers(): Promise<User[]> {
+*     return db.users.findAll();
+*   }
+*
+*   // Uses custom reporter function
+*   @execTime((data) => {
+*     metrics.histogram('method_duration', data.execTime);
+*     console.log(`${data.execTime}ms: ${data.args.join(', ')}`);
+*   })
+*   heavyCalculation(input: number): number {
+*     return input ** 2;
+*   }
+* }
+* ```
+*/
+function execTime(arg) {
+	return (targetOrValue, propertyNameOrContext, descriptor) => {
+		if (descriptor) {
+			if (descriptor.value) {
+				descriptor.value = execTimeFn(descriptor.value, arg);
+				return descriptor;
+			}
+			throw new Error("@execTime is applicable only on methods.");
+		}
+		const method = targetOrValue;
+		if (propertyNameOrContext.kind === "method") return execTimeFn(method, arg);
+		throw new Error("@execTime is applicable only on methods.");
+	};
+}
+//#endregion
+export { execTime };
+
+//# sourceMappingURL=exec-time.js.map

package/lib/exec-time/exec-time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-time.js","names":[],"sources":["../../src/exec-time/exec-time.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 ExecTime decorator - measures and reports the execution time of methods.\n * Useful for performance monitoring and debugging slow operations.\n *\n * @module @resq/typescript/decorators/exec-time\n *\n * @example\n * ```typescript\n * class DataService {\n *   @execTime()\n *   async fetchLargeDataset(): Promise<Data[]> {\n *     return await database.query('SELECT * FROM large_table');\n *   }\n *\n *   @execTime('Heavy computation')\n *   computePrimes(n: number): number[] {\n *     // ... computation\n *   }\n * }\n * ```\n *\n * @copyright Copyright (c) 2026 ResQ\n * @license MIT\n */\n\nimport type { AsyncMethod, Method } from '../types.js';\nimport { execTimeFn } from './exec-time.fn.js';\nimport type { ReportFunction } from './exec-time.types.js';\n\n/**\n * Decorator that measures and reports the execution time of methods.\n * Supports both legacy (TypeScript) and standard (Stage 3) decorator formats.\n *\n * @param {ReportFunction | string} [arg] - Optional reporter function or label string\n * @returns {any} The decorator function\n *\n * @throws {Error} When applied to a non-method property\n *\n * @example\n * ```typescript\n * class PerformanceMonitor {\n *   // Uses default console reporter\n *   @execTime()\n *   processData(data: any[]): void {\n *     // Processing...\n *   }\n *\n *   // Uses custom label\n *   @execTime('Database Query')\n *   async fetchUsers(): Promise<User[]> {\n *     return db.users.findAll();\n *   }\n *\n *   // Uses custom reporter function\n *   @execTime((data) => {\n *     metrics.histogram('method_duration', data.execTime);\n *     console.log(`${data.execTime}ms: ${data.args.join(', ')}`);\n *   })\n *   heavyCalculation(input: number): number {\n *     return input ** 2;\n *   }\n * }\n * ```\n */\nexport function execTime<T = any>(arg?: ReportFunction | string): any {\n  return (\n    targetOrValue: unknown,\n    propertyNameOrContext: keyof T | ClassMethodDecoratorContext,\n    descriptor?: TypedPropertyDescriptor<any>,\n  ): any => {\n    // Legacy decorator\n    if (descriptor) {\n      if (descriptor.value) {\n        descriptor.value = execTimeFn(descriptor.value, arg);\n        return descriptor;\n      }\n      throw new Error('@execTime is applicable only on methods.');\n    }\n\n    // Standard decorator (Stage 3)\n    // targetOrValue is the method itself\n    // propertyNameOrContext is the context\n    const method = targetOrValue as Method | AsyncMethod;\n    const context = propertyNameOrContext as ClassMethodDecoratorContext;\n\n    if (context.kind === 'method') {\n      return execTimeFn(method, arg);\n    }\n\n    throw new Error('@execTime is applicable only on methods.');\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,SAAgB,SAAkB,KAAoC;AACpE,SACE,eACA,uBACA,eACQ;AAER,MAAI,YAAY;AACd,OAAI,WAAW,OAAO;AACpB,eAAW,QAAQ,WAAW,WAAW,OAAO,IAAI;AACpD,WAAO;;AAET,SAAM,IAAI,MAAM,2CAA2C;;EAM7D,MAAM,SAAS;AAGf,MAFgB,sBAEJ,SAAS,SACnB,QAAO,WAAW,QAAQ,IAAI;AAGhC,QAAM,IAAI,MAAM,2CAA2C"}

package/lib/exec-time/exec-time.types.d.ts

@@ -0,0 +1,70 @@
+//#region src/exec-time/exec-time.types.d.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 type for reporting execution time data.
+ *
+ * @param {ExactTimeReportData} data - The execution time report data
+ * @returns {any} Can return any value (typically void)
+ *
+ * @example
+ * ```typescript
+ * const customReporter: ReportFunction = (data) => {
+ *   console.log(`Method took ${data.execTime}ms with args:`, data.args);
+ *   metrics.timing('method.duration', data.execTime);
+ * };
+ * ```
+ */
+type ReportFunction = (data: ExactTimeReportData) => unknown;
+/**
+ * Data structure containing execution time information.
+ *
+ * @interface ExactTimeReportData
+ * @property {any[]} args - The arguments passed to the method
+ * @property {any} result - The return value of the method
+ * @property {number} execTime - The execution time in milliseconds
+ *
+ * @example
+ * ```typescript
+ * const reportData: ExactTimeReportData = {
+ *   args: [42, 'test'],
+ *   result: 'success',
+ *   execTime: 150
+ * };
+ * ```
+ */
+interface ExactTimeReportData {
+  /** The arguments passed to the method */
+  args: unknown[];
+  /** The return value of the method */
+  result: unknown;
+  /** The execution time in milliseconds */
+  execTime: number;
+}
+/**
+ * Type for methods that can have their execution time reported.
+ *
+ * @template T - The type of the class containing the method
+ *
+ * @param {T} target - The class prototype
+ * @param {keyof T} propertyName - The name of the method
+ * @param {TypedPropertyDescriptor<any>} descriptor - The property descriptor
+ * @returns {any} The modified descriptor
+ */
+type ExactTimeReportable<T> = (target: T, propertyName: keyof T, descriptor: TypedPropertyDescriptor<any>) => any;
+//#endregion
+export { ExactTimeReportData, ExactTimeReportable, ReportFunction };
+//# sourceMappingURL=exec-time.types.d.ts.map

package/lib/exec-time/exec-time.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-time.types.d.ts","names":[],"sources":["../../src/exec-time/exec-time.types.ts"],"mappings":";;AA8BA;;;;;AAmBA;;;;;;;;;AAmBA;;;;;;;;;;;;;;AAAA,KAtCY,cAAA,IAAkB,IAAA,EAAM,mBAAA;;;;;;;;;;;;;;;;;;UAmBnB,mBAAA;;EAEf,IAAA;;EAEA,MAAA;;EAEA,QAAA;AAAA;;;;;;;;;;;KAaU,mBAAA,OACV,MAAA,EAAQ,CAAA,EACR,YAAA,QAAoB,CAAA,EACpB,UAAA,EAAY,uBAAA"}

package/lib/exec-time/index.d.ts

@@ -0,0 +1,4 @@
+import { ExactTimeReportData, ExactTimeReportable, ReportFunction } from "./exec-time.types.js";
+import { execTime } from "./exec-time.js";
+import { execTimeFn } from "./exec-time.fn.js";
+export { ExactTimeReportData, ExactTimeReportable, ReportFunction, execTime, execTimeFn };

package/lib/exec-time/index.js

@@ -0,0 +1,3 @@
+import { execTimeFn } from "./exec-time.fn.js";
+import { execTime } from "./exec-time.js";
+export { execTime, execTimeFn };

package/lib/execute/execute.d.ts

@@ -0,0 +1,78 @@
+//#region src/execute/execute.d.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.
+ */
+/**
+ * @fileoverview Execute decorator - automatically instantiates a class
+ * when it's decorated. Useful for singleton pattern implementation.
+ *
+ * @module @resq/typescript/decorators/execute
+ *
+ * @example
+ * ```typescript
+ * @selfExecute
+ * class SingletonService {
+ *   private static instance: SingletonService;
+ *
+ *   constructor() {
+ *     if (SingletonService.instance) {
+ *       return SingletonService.instance;
+ *     }
+ *     SingletonService.instance = this;
+ *   }
+ *
+ *   doSomething(): void {
+ *     console.log('Doing something');
+ *   }
+ * }
+ *
+ * // The class is automatically instantiated
+ * // SingletonService.doSomething(); // If methods were static
+ * ```
+ *
+ * @copyright Copyright (c) 2026 ResQ
+ * @license MIT
+ */
+/**
+ * Class decorator that automatically instantiates the class when decorated.
+ * Creates an instance immediately and returns the constructor.
+ *
+ * @template T - The type of the class constructor
+ * @param {T} constructor - The class constructor
+ * @returns {T} The constructor (with instance created as side effect)
+ *
+ * @example
+ * ```typescript
+ * @selfExecute
+ * class AutoStartService {
+ *   private timer: NodeJS.Timeout;
+ *
+ *   constructor() {
+ *     console.log('Service auto-started');
+ *     this.timer = setInterval(() => this.tick(), 1000);
+ *   }
+ *
+ *   tick(): void {
+ *     console.log('Tick');
+ *   }
+ * }
+ *
+ * // Service is already running when this module loads
+ * ```
+ */
+declare const selfExecute: <T extends new (...args: any[]) => object>(constructor: T) => T;
+//#endregion
+export { selfExecute };
+//# sourceMappingURL=execute.d.ts.map

package/lib/execute/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","names":[],"sources":["../../src/execute/execute.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,WAAA,qBAAiC,IAAA,oBAAwB,WAAA,EAAa,CAAA,KAAI,CAAA"}

package/lib/execute/execute.js

@@ -0,0 +1,82 @@
+//#region src/execute/execute.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.
+*/
+/**
+* @fileoverview Execute decorator - automatically instantiates a class
+* when it's decorated. Useful for singleton pattern implementation.
+*
+* @module @resq/typescript/decorators/execute
+*
+* @example
+* ```typescript
+* @selfExecute
+* class SingletonService {
+*   private static instance: SingletonService;
+*
+*   constructor() {
+*     if (SingletonService.instance) {
+*       return SingletonService.instance;
+*     }
+*     SingletonService.instance = this;
+*   }
+*
+*   doSomething(): void {
+*     console.log('Doing something');
+*   }
+* }
+*
+* // The class is automatically instantiated
+* // SingletonService.doSomething(); // If methods were static
+* ```
+*
+* @copyright Copyright (c) 2026 ResQ
+* @license MIT
+*/
+/**
+* Class decorator that automatically instantiates the class when decorated.
+* Creates an instance immediately and returns the constructor.
+*
+* @template T - The type of the class constructor
+* @param {T} constructor - The class constructor
+* @returns {T} The constructor (with instance created as side effect)
+*
+* @example
+* ```typescript
+* @selfExecute
+* class AutoStartService {
+*   private timer: NodeJS.Timeout;
+*
+*   constructor() {
+*     console.log('Service auto-started');
+*     this.timer = setInterval(() => this.tick(), 1000);
+*   }
+*
+*   tick(): void {
+*     console.log('Tick');
+*   }
+* }
+*
+* // Service is already running when this module loads
+* ```
+*/
+const selfExecute = (constructor) => {
+	new constructor();
+	return constructor;
+};
+//#endregion
+export { selfExecute };
+
+//# sourceMappingURL=execute.js.map

package/lib/execute/execute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.js","names":[],"sources":["../../src/execute/execute.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 Execute decorator - automatically instantiates a class\n * when it's decorated. Useful for singleton pattern implementation.\n *\n * @module @resq/typescript/decorators/execute\n *\n * @example\n * ```typescript\n * @selfExecute\n * class SingletonService {\n *   private static instance: SingletonService;\n *\n *   constructor() {\n *     if (SingletonService.instance) {\n *       return SingletonService.instance;\n *     }\n *     SingletonService.instance = this;\n *   }\n *\n *   doSomething(): void {\n *     console.log('Doing something');\n *   }\n * }\n *\n * // The class is automatically instantiated\n * // SingletonService.doSomething(); // If methods were static\n * ```\n *\n * @copyright Copyright (c) 2026 ResQ\n * @license MIT\n */\n\n/**\n * Class decorator that automatically instantiates the class when decorated.\n * Creates an instance immediately and returns the constructor.\n *\n * @template T - The type of the class constructor\n * @param {T} constructor - The class constructor\n * @returns {T} The constructor (with instance created as side effect)\n *\n * @example\n * ```typescript\n * @selfExecute\n * class AutoStartService {\n *   private timer: NodeJS.Timeout;\n *\n *   constructor() {\n *     console.log('Service auto-started');\n *     this.timer = setInterval(() => this.tick(), 1000);\n *   }\n *\n *   tick(): void {\n *     console.log('Tick');\n *   }\n * }\n *\n * // Service is already running when this module loads\n * ```\n */\nexport const selfExecute = <T extends new (...args: any[]) => object>(constructor: T): T => {\n  const _instance = new constructor();\n  return constructor;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,MAAa,eAAyD,gBAAsB;AACxE,KAAI,aAAa;AACnC,QAAO"}

package/lib/execute/index.d.ts

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

package/lib/execute/index.js

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

package/lib/index.d.ts

@@ -0,0 +1,30 @@
+import { AsyncDecorator, AsyncMethod, Decorator, Method } from "./types.js";
+import { AfterConfig, AfterFunc, AfterParams } from "./after/after.types.js";
+import { after } from "./after/after.js";
+import { BeforeConfig } from "./before/before.types.js";
+import { before } from "./before/before.js";
+import { bind } from "./bind/bind.js";
+import { BindConfig } from "./bind/bind.types.js";
+import { debounceFn } from "./debounce/debounce.fn.js";
+import { delay } from "./delay/delay.js";
+import { Delegatable } from "./delegate/delegate.types.js";
+import { delegate } from "./delegate/delegate.js";
+import { ExactTimeReportData, ExactTimeReportable, ReportFunction } from "./exec-time/exec-time.types.js";
+import { execTime } from "./exec-time/exec-time.js";
+import { execTimeFn } from "./exec-time/exec-time.fn.js";
+import { selfExecute } from "./execute/execute.js";
+import { Cache, KeyResolver, Memoizable, MemoizeConfig } from "./memoize/memoize.types.js";
+import { memoize } from "./memoize/memoize.js";
+import { AsyncCache, AsyncMemoizable, AsyncMemoizeConfig } from "./memoize-async/memoize-async.types.js";
+import { memoizeAsyncFn } from "./memoize-async/memoize-async.fn.js";
+import { memoizeAsync } from "./memoize-async/memoize-async.js";
+import { observe } from "./observer/observer.js";
+import { ObserverCallback } from "./observer/observer.types.js";
+import { RateLimitAsyncCounter, RateLimitConfigs, RateLimitCounter, RateLimitable } from "./rate-limit/rate-limit.types.js";
+import { rateLimit } from "./rate-limit/rate-limit.js";
+import { SimpleRateLimitCounter } from "./rate-limit/simple-rate-limit-counter.js";
+import { readonly } from "./readonly/readonly.js";
+import { Readonlyable } from "./readonly/readonly.types.js";
+import { throttle } from "./throttle/throttle.js";
+import { throttleAsync } from "./throttle-async/throttle-async.js";
+export { AfterConfig, AfterFunc, AfterParams, AsyncCache, AsyncDecorator, AsyncMemoizable, AsyncMemoizeConfig, AsyncMethod, BeforeConfig, BindConfig, Cache, Decorator, Delegatable, ExactTimeReportData, ExactTimeReportable, KeyResolver, Memoizable, MemoizeConfig, Method, ObserverCallback, RateLimitAsyncCounter, RateLimitConfigs, RateLimitCounter, RateLimitable, Readonlyable, ReportFunction, SimpleRateLimitCounter, after, before, bind, debounceFn, delay, delegate, execTime, execTimeFn, memoize, memoizeAsync, memoizeAsyncFn, observe, rateLimit, readonly, selfExecute, throttle, throttleAsync };

package/lib/index.js

@@ -0,0 +1,19 @@
+import { after } from "./after/after.js";
+import { before } from "./before/before.js";
+import { bind } from "./bind/bind.js";
+import { debounceFn } from "./debounce/debounce.fn.js";
+import { delay } from "./delay/delay.js";
+import { delegate } from "./delegate/delegate.js";
+import { execTimeFn } from "./exec-time/exec-time.fn.js";
+import { execTime } from "./exec-time/exec-time.js";
+import { selfExecute } from "./execute/execute.js";
+import { memoize } from "./memoize/memoize.js";
+import { memoizeAsyncFn } from "./memoize-async/memoize-async.fn.js";
+import { memoizeAsync } from "./memoize-async/memoize-async.js";
+import { observe } from "./observer/observer.js";
+import { SimpleRateLimitCounter } from "./rate-limit/simple-rate-limit-counter.js";
+import { rateLimit } from "./rate-limit/rate-limit.js";
+import { readonly } from "./readonly/readonly.js";
+import { throttle } from "./throttle/throttle.js";
+import { throttleAsync } from "./throttle-async/throttle-async.js";
+export { SimpleRateLimitCounter, after, before, bind, debounceFn, delay, delegate, execTime, execTimeFn, memoize, memoizeAsync, memoizeAsyncFn, observe, rateLimit, readonly, selfExecute, throttle, throttleAsync };

package/lib/memoize/index.d.ts

@@ -0,0 +1,3 @@
+import { Cache, KeyResolver, Memoizable, MemoizeConfig } from "./memoize.types.js";
+import { memoize } from "./memoize.js";
+export { Cache, KeyResolver, Memoizable, MemoizeConfig, memoize };

package/lib/memoize/index.js

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