@resq-sw/decorators 0.1.0

package/lib/after/after.types.d.ts

@@ -0,0 +1,86 @@
+//#region src/after/after.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 signature for after hooks.
+ *
+ * @template D - The return type of the decorated method
+ * @param {AfterParams<D>} [x] - Parameters containing args and response
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const afterHook: AfterFunc<string> = ({ args, response }) => {
+ *   console.log(`Method returned: ${response}`);
+ * };
+ * ```
+ */
+type AfterFunc<D> = (x?: AfterParams<D>) => void;
+/**
+ * Configuration options for the @after decorator.
+ *
+ * @interface AfterConfig
+ * @template T - The type of the class containing the decorated method
+ * @template D - The return type of the decorated method
+ * @property {AfterFunc<D> | keyof T} func - The after function to execute, or a method name on the class
+ * @property {boolean} [wait=false] - Whether to wait for the after function to complete before returning
+ *
+ * @example
+ * ```typescript
+ * // Using a function reference
+ * const config1: AfterConfig<MyClass, string> = {
+ *   func: ({ args, response }) => console.log(response),
+ *   wait: false
+ * };
+
+ * // Using a method name
+ * const config2: AfterConfig<MyClass, string> = {
+ *   func: 'logResult', // Calls this.logResult()
+ *   wait: true
+ * };
+ * ```
+ */
+interface AfterConfig<T = any, D = any> {
+  /** The after function to execute, or a method name on the class */
+  func: AfterFunc<D> | keyof T;
+  /** Whether to wait for the after function to complete before returning */
+  wait?: boolean;
+}
+/**
+ * Parameters passed to the after hook function.
+ *
+ * @interface AfterParams
+ * @template D - The return type of the decorated method
+ * @property {any[]} args - The arguments passed to the decorated method
+ * @property {D} response - The return value of the decorated method
+ *
+ * @example
+ * ```typescript
+ * const params: AfterParams<number> = {
+ *   args: ['input', 42],
+ *   response: 100
+ * };
+ * ```
+ */
+interface AfterParams<D = any> {
+  /** The arguments passed to the decorated method */
+  args: unknown[];
+  /** The return value of the decorated method */
+  response: D;
+}
+//#endregion
+export { AfterConfig, AfterFunc, AfterParams };
+//# sourceMappingURL=after.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"after.types.d.ts","names":[],"sources":["../../src/after/after.types.ts"],"mappings":";;AA8BA;;;;;;;;;;AA0BA;;;;;;;;;;;;;;;;;AAuBA;KAjDY,SAAA,OAAgB,CAAA,GAAI,WAAA,CAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;UA0B3B,WAAA;;EAEf,IAAA,EAAM,SAAA,CAAU,CAAA,UAAW,CAAA;;EAE3B,IAAA;AAAA;;;;;;;;;;;;;;;;;UAmBe,WAAA;;EAEf,IAAA;;EAEA,QAAA,EAAU,CAAA;AAAA"}

package/lib/after/index.d.ts

@@ -0,0 +1,3 @@
+import { AfterConfig, AfterFunc, AfterParams } from "./after.types.js";
+import { after } from "./after.js";
+export { AfterConfig, AfterFunc, AfterParams, after };

package/lib/after/index.js

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

package/lib/before/before.d.ts

@@ -0,0 +1,61 @@
+import { Decorator } from "../types.js";
+import { BeforeConfig } from "./before.types.js";
+
+//#region src/before/before.d.ts
+/**
+* @fileoverview Before decorator - executes a function before the decorated method.
+* Useful for validation, authentication, or preprocessing before method execution.
+*
+* @module @resq/typescript/decorators/before
+*
+* @example
+* ```typescript
+* class MyService {
+*   @before({
+*     func: 'validateInput',
+*     wait: true // Wait for before function to complete
+*   })
+*   saveData(data: any) {
+*     database.save(data);
+*   }
+*
+*   validateInput() {
+*     if (!this.isValid) {
+*       throw new Error('Invalid state');
+*     }
+*   }
+* }
+* ```
+*
+* @copyright Copyright (c) 2026 ResQ
+* @license MIT
+*/
+/**
+ * Decorator that executes a function before the decorated method.
+ * The before function is called before the method body executes.
+ *
+ * @template T - The type of the class containing the decorated method
+ * @param {BeforeConfig<T>} config - Configuration for the before hook
+ * @returns {Decorator<T>} The decorator function
+ *
+ * @throws {Error} When applied to a non-method property
+ *
+ * @example
+ * ```typescript
+ * class DataProcessor {
+ *   @before({
+ *     func: function() {
+ *       console.log('About to process...');
+ *     },
+ *     wait: false
+ *   })
+ *   processItems(items: string[]): number {
+ *     return items.length;
+ *   }
+ * }
+ * ```
+ */
+declare function before<T = any>(config: BeforeConfig<T>): Decorator<T>;
+//#endregion
+export { before };
+//# sourceMappingURL=before.d.ts.map

package/lib/before/before.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"before.d.ts","names":[],"sources":["../../src/before/before.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0EgB,MAAA,SAAA,CAAgB,MAAA,EAAQ,YAAA,CAAa,CAAA,IAAK,SAAA,CAAU,CAAA"}

package/lib/before/before.fn.d.ts

@@ -0,0 +1,39 @@
+import { Method } from "../types.js";
+import { BeforeConfig } from "./before.types.js";
+
+//#region src/before/before.fn.d.ts
+/**
+ * Wraps a method to execute a before hook function before the method runs.
+ *
+ * @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 wrap
+ * @param {BeforeConfig<any>} config - Configuration for the before hook
+ * @returns {Method<Promise<D>, A>} The wrapped method
+ *
+ * @example
+ * ```typescript
+ * class Service {
+ *   process(data: string): string {
+ *     return data.toUpperCase();
+ *   }
+ * }
+ *
+ * const service = new Service();
+ * const wrapped = beforeFn(
+ *   service.process.bind(service),
+ *   {
+ *     func: () => {
+ *       console.log('About to process...');
+ *     },
+ *     wait: false
+ *   }
+ * );
+ *
+ * await wrapped('hello'); // Logs "About to process..." then returns "HELLO"
+ * ```
+ */
+declare function beforeFn<D = any, A extends any[] = any[]>(originalMethod: Method<D, A>, config: BeforeConfig<any>): Method<Promise<D>, A>;
+//#endregion
+export { beforeFn };
+//# sourceMappingURL=before.fn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"before.fn.d.ts","names":[],"sources":["../../src/before/before.fn.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDgB,QAAA,kCAAA,CACd,cAAA,EAAgB,MAAA,CAAO,CAAA,EAAG,CAAA,GAC1B,MAAA,EAAQ,YAAA,QACP,MAAA,CAAO,OAAA,CAAQ,CAAA,GAAI,CAAA"}

package/lib/before/before.fn.js

@@ -0,0 +1,51 @@
+//#region src/before/before.fn.ts
+/**
+* Wraps a method to execute a before hook function before the method runs.
+*
+* @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 wrap
+* @param {BeforeConfig<any>} config - Configuration for the before hook
+* @returns {Method<Promise<D>, A>} The wrapped method
+*
+* @example
+* ```typescript
+* class Service {
+*   process(data: string): string {
+*     return data.toUpperCase();
+*   }
+* }
+*
+* const service = new Service();
+* const wrapped = beforeFn(
+*   service.process.bind(service),
+*   {
+*     func: () => {
+*       console.log('About to process...');
+*     },
+*     wait: false
+*   }
+* );
+*
+* await wrapped('hello'); // Logs "About to process..." then returns "HELLO"
+* ```
+*/
+function beforeFn(originalMethod, config) {
+	const resolvedConfig = {
+		wait: false,
+		...config
+	};
+	return async function(...args) {
+		const beforeFunc = typeof resolvedConfig.func === "string" ? this[resolvedConfig.func].bind(this) : resolvedConfig.func;
+		if (resolvedConfig.wait) {
+			await beforeFunc();
+			return originalMethod.apply(this, args);
+		}
+		beforeFunc();
+		return originalMethod.apply(this, args);
+	};
+}
+//#endregion
+export { beforeFn };
+
+//# sourceMappingURL=before.fn.js.map

package/lib/before/before.fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"before.fn.js","names":[],"sources":["../../src/before/before.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';\nimport type { BeforeConfig } from './before.types.js';\n\n/**\n * Wraps a method to execute a before hook function before the method runs.\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 wrap\n * @param {BeforeConfig<any>} config - Configuration for the before hook\n * @returns {Method<Promise<D>, A>} The wrapped method\n *\n * @example\n * ```typescript\n * class Service {\n *   process(data: string): string {\n *     return data.toUpperCase();\n *   }\n * }\n *\n * const service = new Service();\n * const wrapped = beforeFn(\n *   service.process.bind(service),\n *   {\n *     func: () => {\n *       console.log('About to process...');\n *     },\n *     wait: false\n *   }\n * );\n *\n * await wrapped('hello'); // Logs \"About to process...\" then returns \"HELLO\"\n * ```\n */\nexport function beforeFn<D = any, A extends any[] = any[]>(\n  originalMethod: Method<D, A>,\n  config: BeforeConfig<any>,\n): Method<Promise<D>, A> {\n  const resolvedConfig: BeforeConfig<any> = {\n    wait: false,\n    ...config,\n  };\n\n  return async function (this: any, ...args: A): Promise<D> {\n    const beforeFunc =\n      typeof resolvedConfig.func === 'string'\n        ? this[resolvedConfig.func].bind(this)\n        : resolvedConfig.func;\n\n    if (resolvedConfig.wait) {\n      await beforeFunc();\n      return originalMethod.apply(this, args);\n    }\n\n    beforeFunc();\n    return originalMethod.apply(this, args);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,SACd,gBACA,QACuB;CACvB,MAAM,iBAAoC;EACxC,MAAM;EACN,GAAG;EACJ;AAED,QAAO,eAA2B,GAAG,MAAqB;EACxD,MAAM,aACJ,OAAO,eAAe,SAAS,WAC3B,KAAK,eAAe,MAAM,KAAK,KAAK,GACpC,eAAe;AAErB,MAAI,eAAe,MAAM;AACvB,SAAM,YAAY;AAClB,UAAO,eAAe,MAAM,MAAM,KAAK;;AAGzC,cAAY;AACZ,SAAO,eAAe,MAAM,MAAM,KAAK"}

package/lib/before/before.js

@@ -0,0 +1,40 @@
+import { beforeFn } from "./before.fn.js";
+//#region src/before/before.ts
+/**
+* Decorator that executes a function before the decorated method.
+* The before function is called before the method body executes.
+*
+* @template T - The type of the class containing the decorated method
+* @param {BeforeConfig<T>} config - Configuration for the before hook
+* @returns {Decorator<T>} The decorator function
+*
+* @throws {Error} When applied to a non-method property
+*
+* @example
+* ```typescript
+* class DataProcessor {
+*   @before({
+*     func: function() {
+*       console.log('About to process...');
+*     },
+*     wait: false
+*   })
+*   processItems(items: string[]): number {
+*     return items.length;
+*   }
+* }
+* ```
+*/
+function before(config) {
+	return (target, propertyName, descriptor) => {
+		if (descriptor.value) {
+			descriptor.value = beforeFn(descriptor.value, config);
+			return descriptor;
+		}
+		throw new Error("@before is applicable only on a methods.");
+	};
+}
+//#endregion
+export { before };
+
+//# sourceMappingURL=before.js.map

package/lib/before/before.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"before.js","names":[],"sources":["../../src/before/before.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 Before decorator - executes a function before the decorated method.\n * Useful for validation, authentication, or preprocessing before method execution.\n *\n * @module @resq/typescript/decorators/before\n *\n * @example\n * ```typescript\n * class MyService {\n *   @before({\n *     func: 'validateInput',\n *     wait: true // Wait for before function to complete\n *   })\n *   saveData(data: any) {\n *     database.save(data);\n *   }\n *\n *   validateInput() {\n *     if (!this.isValid) {\n *       throw new Error('Invalid state');\n *     }\n *   }\n * }\n * ```\n *\n * @copyright Copyright (c) 2026 ResQ\n * @license MIT\n */\n\nimport type { Decorator, Method } from '../types.js';\nimport { beforeFn } from './before.fn.js';\nimport type { BeforeConfig } from './before.types.js';\n\n/**\n * Decorator that executes a function before the decorated method.\n * The before function is called before the method body executes.\n *\n * @template T - The type of the class containing the decorated method\n * @param {BeforeConfig<T>} config - Configuration for the before hook\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 DataProcessor {\n *   @before({\n *     func: function() {\n *       console.log('About to process...');\n *     },\n *     wait: false\n *   })\n *   processItems(items: string[]): number {\n *     return items.length;\n *   }\n * }\n * ```\n */\nexport function before<T = any>(config: BeforeConfig<T>): Decorator<T> {\n  return (\n    target: T,\n    propertyName: keyof T,\n    descriptor: TypedPropertyDescriptor<Method<any>>,\n  ): TypedPropertyDescriptor<Method<any>> => {\n    if (descriptor.value) {\n      descriptor.value = beforeFn(descriptor.value, config);\n\n      return descriptor;\n    }\n    throw new Error('@before is applicable only on a methods.');\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,SAAgB,OAAgB,QAAuC;AACrE,SACE,QACA,cACA,eACyC;AACzC,MAAI,WAAW,OAAO;AACpB,cAAW,QAAQ,SAAS,WAAW,OAAO,OAAO;AAErD,UAAO;;AAET,QAAM,IAAI,MAAM,2CAA2C"}

package/lib/before/before.types.d.ts

@@ -0,0 +1,48 @@
+//#region src/before/before.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.
+ */
+/**
+ * Configuration options for the @before decorator.
+ *
+ * @interface BeforeConfig
+ * @template T - The type of the class containing the decorated method
+ * @property {((...args: any[]) => any) | keyof T} func - The before function to execute, or a method name on the class
+ * @property {boolean} [wait=false] - Whether to wait for the before function to complete before executing the method
+ *
+ * @example
+ * ```typescript
+ * // Using a function reference
+ * const config1: BeforeConfig<MyClass> = {
+ *   func: () => console.log('Before method'),
+ *   wait: false
+ * };
+
+ * // Using a method name
+ * const config2: BeforeConfig<MyClass> = {
+ *   func: 'validate',
+ *   wait: true
+ * };
+ * ```
+ */
+interface BeforeConfig<T> {
+  /** The before function to execute, or a method name on the class */
+  func: ((...args: unknown[]) => unknown) | keyof T;
+  /** Whether to wait for the before function to complete before executing the method */
+  wait?: boolean;
+}
+//#endregion
+export { BeforeConfig };
+//# sourceMappingURL=before.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"before.types.d.ts","names":[],"sources":["../../src/before/before.types.ts"],"mappings":";;AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAiB,YAAA;;EAEf,IAAA,OAAW,IAAA,iCAAqC,CAAA;;EAEhD,IAAA;AAAA"}

package/lib/before/index.d.ts

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

package/lib/before/index.js

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

package/lib/bind/bind.d.ts

@@ -0,0 +1,75 @@
+import { Method } from "../types.js";
+
+//#region src/bind/bind.d.ts
+/**
+* @fileoverview Bind decorator - automatically binds class methods to their
+* instance context. Ensures `this` always refers to the class instance.
+*
+* @module @resq/typescript/decorators/bind
+*
+* @example
+* ```typescript
+* class EventHandler {
+*   private count = 0;
+*
+*   @bind
+*   handleClick(event: MouseEvent): void {
+*     this.count++; // `this` correctly refers to EventHandler instance
+*     console.log(`Clicked ${this.count} times`);
+*   }
+* }
+*
+* const handler = new EventHandler();
+* button.addEventListener('click', handler.handleClick);
+* // Works correctly even when passed as callback
+* ```
+*
+* @copyright Copyright (c) 2026 ResQ
+* @license MIT
+*/
+/**
+ * Decorator that automatically binds a method to its class instance.
+ * This ensures `this` always refers to the class instance, even when
+ * the method is passed as a callback or stored separately.
+ *
+ * Uses lazy binding on first access for better performance.
+ *
+ * @template T - The type of the class containing the decorated method
+ * @param {T} _target - The class prototype (unused)
+ * @param {string | symbol} propertyKey - The name of the method
+ * @param {TypedPropertyDescriptor<Method<unknown>>} descriptor - The property descriptor
+ * @returns {TypedPropertyDescriptor<Method<unknown>>} The modified descriptor
+ *
+ * @throws {Error} When applied to a non-method property
+ *
+ * @example
+ * ```typescript
+ * class MyClass {
+ *   private value = 42;
+ *
+ *   @bind
+ *   getValue(): number {
+ *     return this.value;
+ *   }
+ *
+ *   @bind
+ *   async fetchData(): Promise<Data> {
+ *     return await this.api.getData();
+ *   }
+ * }
+ *
+ * const instance = new MyClass();
+ *
+ * // Works correctly when passed as callback
+ * const getValue = instance.getValue;
+ * console.log(getValue()); // 42
+ *
+ * // Works with async methods too
+ * const fetchData = instance.fetchData;
+ * const data = await fetchData();
+ * ```
+ */
+declare function bind<T = unknown>(_target: T, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<Method<unknown>>): TypedPropertyDescriptor<Method<unknown>>;
+//#endregion
+export { bind };
+//# sourceMappingURL=bind.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bind.d.ts","names":[],"sources":["../../src/bind/bind.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,IAAA,aAAA,CACd,OAAA,EAAS,CAAA,EACT,WAAA,mBACA,UAAA,EAAY,uBAAA,CAAwB,MAAA,aACnC,uBAAA,CAAwB,MAAA"}

package/lib/bind/bind.fn.d.ts

@@ -0,0 +1,46 @@
+import { Method } from "../types.js";
+
+//#region src/bind/bind.fn.d.ts
+/**
+* @fileoverview Bind function implementation - creates a bound version of a method.
+*
+* @module @resq/typescript/decorators/bind.fn
+*
+* @copyright Copyright (c) 2026 ResQ
+* @license MIT
+*/
+/**
+ * Creates a bound version of a method.
+ *
+ * @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 bind
+ * @param {unknown} context - The context (`this`) to bind to
+ * @returns {Method<D, A>} The bound method
+ *
+ * @example
+ * ```typescript
+ * class Calculator {
+ *   private multiplier = 10;
+ *
+ *   multiply(value: number): number {
+ *     return value * this.multiplier;
+ *   }
+ * }
+ *
+ * const calc = new Calculator();
+ *
+ * // Create bound version
+ * const boundMultiply = bindFn(calc.multiply.bind(calc), calc);
+ * const result = boundMultiply(5); // 50
+ *
+ * // Can also be used with different context
+ * const calc2 = new Calculator();
+ * // calc2.multiplier = 20;
+ * const boundToCalc2 = bindFn(calc.multiply, calc2);
+ * ```
+ */
+declare function bindFn<D = unknown, A extends unknown[] = unknown[]>(originalMethod: Method<D, A>, context: unknown): Method<D, A>;
+//#endregion
+export { bindFn };
+//# sourceMappingURL=bind.fn.d.ts.map

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

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

package/lib/bind/bind.fn.js

@@ -0,0 +1,39 @@
+//#region src/bind/bind.fn.ts
+/**
+* Creates a bound version of a method.
+*
+* @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 bind
+* @param {unknown} context - The context (`this`) to bind to
+* @returns {Method<D, A>} The bound method
+*
+* @example
+* ```typescript
+* class Calculator {
+*   private multiplier = 10;
+*
+*   multiply(value: number): number {
+*     return value * this.multiplier;
+*   }
+* }
+*
+* const calc = new Calculator();
+*
+* // Create bound version
+* const boundMultiply = bindFn(calc.multiply.bind(calc), calc);
+* const result = boundMultiply(5); // 50
+*
+* // Can also be used with different context
+* const calc2 = new Calculator();
+* // calc2.multiplier = 20;
+* const boundToCalc2 = bindFn(calc.multiply, calc2);
+* ```
+*/
+function bindFn(originalMethod, context) {
+	return originalMethod.bind(context);
+}
+//#endregion
+export { bindFn };
+
+//# sourceMappingURL=bind.fn.js.map

package/lib/bind/bind.fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.fn.js","names":[],"sources":["../../src/bind/bind.fn.ts"],"sourcesContent":["/**\n * @fileoverview Bind function implementation - creates a bound version of a method.\n *\n * @module @resq/typescript/decorators/bind.fn\n *\n * @copyright Copyright (c) 2026 ResQ\n * @license MIT\n */\n\nimport type { Method } from '../types.js';\n\n/**\n * Creates a bound version of a method.\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 bind\n * @param {unknown} context - The context (`this`) to bind to\n * @returns {Method<D, A>} The bound method\n *\n * @example\n * ```typescript\n * class Calculator {\n *   private multiplier = 10;\n *\n *   multiply(value: number): number {\n *     return value * this.multiplier;\n *   }\n * }\n *\n * const calc = new Calculator();\n *\n * // Create bound version\n * const boundMultiply = bindFn(calc.multiply.bind(calc), calc);\n * const result = boundMultiply(5); // 50\n *\n * // Can also be used with different context\n * const calc2 = new Calculator();\n * // calc2.multiplier = 20;\n * const boundToCalc2 = bindFn(calc.multiply, calc2);\n * ```\n */\nexport function bindFn<D = unknown, A extends unknown[] = unknown[]>(\n  originalMethod: Method<D, A>,\n  context: unknown,\n): Method<D, A> {\n  return originalMethod.bind(context);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,OACd,gBACA,SACc;AACd,QAAO,eAAe,KAAK,QAAQ"}

package/lib/bind/bind.js

@@ -0,0 +1,64 @@
+//#region src/bind/bind.ts
+/**
+* Decorator that automatically binds a method to its class instance.
+* This ensures `this` always refers to the class instance, even when
+* the method is passed as a callback or stored separately.
+*
+* Uses lazy binding on first access for better performance.
+*
+* @template T - The type of the class containing the decorated method
+* @param {T} _target - The class prototype (unused)
+* @param {string | symbol} propertyKey - The name of the method
+* @param {TypedPropertyDescriptor<Method<unknown>>} descriptor - The property descriptor
+* @returns {TypedPropertyDescriptor<Method<unknown>>} The modified descriptor
+*
+* @throws {Error} When applied to a non-method property
+*
+* @example
+* ```typescript
+* class MyClass {
+*   private value = 42;
+*
+*   @bind
+*   getValue(): number {
+*     return this.value;
+*   }
+*
+*   @bind
+*   async fetchData(): Promise<Data> {
+*     return await this.api.getData();
+*   }
+* }
+*
+* const instance = new MyClass();
+*
+* // Works correctly when passed as callback
+* const getValue = instance.getValue;
+* console.log(getValue()); // 42
+*
+* // Works with async methods too
+* const fetchData = instance.fetchData;
+* const data = await fetchData();
+* ```
+*/
+function bind(_target, propertyKey, descriptor) {
+	const originalMethod = descriptor.value;
+	if (!originalMethod) throw new Error("@bind is applicable only on methods.");
+	return {
+		configurable: true,
+		enumerable: false,
+		get() {
+			const boundMethod = originalMethod.bind(this);
+			Object.defineProperty(this, propertyKey, {
+				value: boundMethod,
+				configurable: true,
+				writable: true
+			});
+			return boundMethod;
+		}
+	};
+}
+//#endregion
+export { bind };
+
+//# sourceMappingURL=bind.js.map

package/lib/bind/bind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.js","names":[],"sources":["../../src/bind/bind.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 Bind decorator - automatically binds class methods to their\n * instance context. Ensures `this` always refers to the class instance.\n *\n * @module @resq/typescript/decorators/bind\n *\n * @example\n * ```typescript\n * class EventHandler {\n *   private count = 0;\n *\n *   @bind\n *   handleClick(event: MouseEvent): void {\n *     this.count++; // `this` correctly refers to EventHandler instance\n *     console.log(`Clicked ${this.count} times`);\n *   }\n * }\n *\n * const handler = new EventHandler();\n * button.addEventListener('click', handler.handleClick);\n * // Works correctly even when passed as callback\n * ```\n *\n * @copyright Copyright (c) 2026 ResQ\n * @license MIT\n */\n\nimport type { Method } from '../types.js';\n\n/**\n * Decorator that automatically binds a method to its class instance.\n * This ensures `this` always refers to the class instance, even when\n * the method is passed as a callback or stored separately.\n *\n * Uses lazy binding on first access for better performance.\n *\n * @template T - The type of the class containing the decorated method\n * @param {T} _target - The class prototype (unused)\n * @param {string | symbol} propertyKey - The name of the method\n * @param {TypedPropertyDescriptor<Method<unknown>>} descriptor - The property descriptor\n * @returns {TypedPropertyDescriptor<Method<unknown>>} The modified descriptor\n *\n * @throws {Error} When applied to a non-method property\n *\n * @example\n * ```typescript\n * class MyClass {\n *   private value = 42;\n *\n *   @bind\n *   getValue(): number {\n *     return this.value;\n *   }\n *\n *   @bind\n *   async fetchData(): Promise<Data> {\n *     return await this.api.getData();\n *   }\n * }\n *\n * const instance = new MyClass();\n *\n * // Works correctly when passed as callback\n * const getValue = instance.getValue;\n * console.log(getValue()); // 42\n *\n * // Works with async methods too\n * const fetchData = instance.fetchData;\n * const data = await fetchData();\n * ```\n */\nexport function bind<T = unknown>(\n  _target: T,\n  propertyKey: string | symbol,\n  descriptor: TypedPropertyDescriptor<Method<unknown>>,\n): TypedPropertyDescriptor<Method<unknown>> {\n  const originalMethod = descriptor.value;\n\n  if (!originalMethod) {\n    throw new Error('@bind is applicable only on methods.');\n  }\n\n  // Use a getter to lazily bind the method on first access\n  return {\n    configurable: true,\n    enumerable: false,\n    get(this: object): Method<unknown> {\n      const boundMethod = originalMethod.bind(this);\n\n      // Define the bound method directly on the instance for subsequent accesses\n      Object.defineProperty(this, propertyKey, {\n        value: boundMethod,\n        configurable: true,\n        writable: true,\n      });\n\n      return boundMethod;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuFA,SAAgB,KACd,SACA,aACA,YAC0C;CAC1C,MAAM,iBAAiB,WAAW;AAElC,KAAI,CAAC,eACH,OAAM,IAAI,MAAM,uCAAuC;AAIzD,QAAO;EACL,cAAc;EACd,YAAY;EACZ,MAAmC;GACjC,MAAM,cAAc,eAAe,KAAK,KAAK;AAG7C,UAAO,eAAe,MAAM,aAAa;IACvC,OAAO;IACP,cAAc;IACd,UAAU;IACX,CAAC;AAEF,UAAO;;EAEV"}

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

@@ -0,0 +1,36 @@
+//#region src/bind/bind.types.d.ts
+/**
+ * @fileoverview Type definitions for the Bind decorator.
+ * Provides configuration types for the bind decorator.
+ *
+ * @module @resq/typescript/decorators/bind/types
+ *
+ * @copyright Copyright (c) 2026 ResQ
+ * @license MIT
+ */
+/**
+ * Configuration options for the bind decorator.
+ *
+ * @interface BindConfig
+ * @property {boolean} [lazy=true] - If true, the method is bound lazily on first access.
+ *                                   If false, the method is bound at decoration time.
+ *
+ * @example
+ * ```typescript
+ * // Lazy binding (default) - binds on first access
+ * const lazyConfig: BindConfig = { lazy: true };
+ *
+ * // Eager binding - binds immediately
+ * const eagerConfig: BindConfig = { lazy: false };
+ * ```
+ */
+interface BindConfig {
+  /**
+   * If true, the method is bound lazily on first access.
+   * If false (default), the method is bound at decoration time.
+   */
+  lazy?: boolean;
+}
+//#endregion
+export { BindConfig };
+//# sourceMappingURL=bind.types.d.ts.map