@resq-sw/decorators 0.1.0

package/README.md

@@ -0,0 +1,277 @@
+# @resq-sw/decorators
+
+> TypeScript method and class decorators for caching, rate limiting, control flow, and observability.
+
+## Installation
+
+```bash
+bun add @resq-sw/decorators
+```
+
+Zero runtime dependencies.
+
+## Quick Start
+
+```ts
+import { memoize, throttle, bind, debounce } from "@resq-sw/decorators";
+
+class SearchService {
+  @memoize()
+  computeExpensive(n: number): number { return n * n; }
+
+  @throttle(200)
+  handleScroll(): void { /* at most once per 200ms */ }
+
+  @debounce(300)
+  onInput(query: string): void { /* fires after 300ms idle */ }
+
+  @bind
+  handleClick(): void { /* `this` always bound to instance */ }
+}
+```
+
+## API Reference
+
+### `@after(config)`
+
+Executes a function after the decorated method completes.
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `func` | `((data: { args, response }) => void) \| string` | required | Callback or method name on `this` |
+| `wait` | `boolean` | `false` | Whether to await the original method before calling `func` |
+
+```ts
+class Service {
+  @after({ func: ({ response }) => console.log(response), wait: true })
+  async save(data: string) { return db.save(data); }
+}
+```
+
+Also exported: `afterFn(method, config)` -- standalone wrapper function.
+
+### `@before(config)`
+
+Executes a function before the decorated method runs.
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `func` | `(() => void) \| string` | required | Callback or method name on `this` |
+| `wait` | `boolean` | `false` | Whether to await the before function |
+
+```ts
+class Service {
+  @before({ func: 'validateState', wait: true })
+  process() { /* runs after validateState */ }
+}
+```
+
+Also exported: `beforeFn(method, config)`.
+
+### `@bind`
+
+Automatically binds a method to its class instance using lazy binding on first access.
+
+```ts
+class Component {
+  @bind
+  handleClick(): void { /* `this` is always correct */ }
+}
+const fn = new Component().handleClick; // safely detached
+```
+
+Also exported: `bindFn(method, context)`.
+
+### `@debounce(delayMs)`
+
+Debounces method calls -- only executes after `delayMs` of inactivity.
+
+- **delayMs** (`number`) -- delay in milliseconds.
+
+```ts
+class Editor {
+  @debounce(500)
+  autoSave(content: string): void { localStorage.setItem("draft", content); }
+}
+```
+
+Also exported: `debounceFn(method, delayMs)`.
+
+### `@delay(delayMs)`
+
+Delays method execution by `delayMs` milliseconds.
+
+- **delayMs** (`number`) -- delay in milliseconds.
+
+```ts
+class Animator {
+  @delay(1000)
+  fadeOut(el: HTMLElement): void { el.style.opacity = "0"; }
+}
+```
+
+Also exported: `delayFn(method, delayMs)`.
+
+### `@delegate(keyResolver?)`
+
+Deduplicates concurrent async method calls. Calls with the same key share a single promise.
+
+- **keyResolver** (`(...args) => string`, optional) -- custom key function; defaults to `JSON.stringify(args)`.
+
+```ts
+class Api {
+  @delegate((id: string) => id)
+  async fetchUser(id: string): Promise<User> { return fetch(`/users/${id}`).then(r => r.json()); }
+}
+```
+
+Also exported: `delegateFn(method, keyResolver?)`.
+
+### `@execTime(arg?)`
+
+Measures and reports method execution time. Supports both legacy and Stage 3 decorators.
+
+- **arg** (`ReportFunction | string`, optional) -- custom reporter function, a label string, or a method name on `this`.
+
+```ts
+class Monitor {
+  @execTime()
+  processData(data: unknown[]): void { /* logs execution time */ }
+
+  @execTime("DB Query")
+  async query(): Promise<void> { /* logs "DB Query execution time: Xms" */ }
+
+  @execTime((data) => metrics.record(data.execTime))
+  compute(): void { /* custom reporter */ }
+}
+```
+
+Also exported: `execTimeFn(method, arg?)`.
+
+### `@selfExecute`
+
+Class decorator that auto-instantiates the class on load.
+
+```ts
+@selfExecute
+class Singleton {
+  constructor() { console.log("Created"); }
+}
+// Instance created immediately when module loads
+```
+
+### `@memoize(configOrTTL?)`
+
+Caches synchronous method results by arguments.
+
+| Overload | Parameter | Description |
+|----------|-----------|-------------|
+| `@memoize()` | none | Cache indefinitely |
+| `@memoize(60000)` | `number` | Cache with TTL in ms |
+| `@memoize({ cache, keyResolver, expirationTimeMs })` | `MemoizeConfig` | Full config |
+
+```ts
+class Calc {
+  @memoize(30000)
+  fibonacci(n: number): number { return n <= 1 ? n : this.fibonacci(n-1) + this.fibonacci(n-2); }
+}
+```
+
+Also exported: `memoizeFn(method, configOrTTL?)`.
+
+### `@memoizeAsync(configOrTTL?)`
+
+Caches async method results with promise deduplication. Same overloads as `@memoize`.
+
+```ts
+class Api {
+  @memoizeAsync({ expirationTimeMs: 60000 })
+  async getConfig(): Promise<Config> { return fetch("/config").then(r => r.json()); }
+}
+```
+
+Also exported: `memoizeAsyncFn(method, configOrTTL?)`.
+
+### `@observe` / `@observe(callback)`
+
+Property decorator that watches assignments.
+
+```ts
+class State {
+  @observe
+  count: number = 0; // logs "setting property State#count = <value>"
+
+  @observe((val: string) => analytics.track("name", val))
+  name: string = "";
+}
+```
+
+### `@rateLimit(config)`
+
+Limits method calls to a fixed number within a time window.
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `timeSpanMs` | `number` | Time window in ms |
+| `allowedCalls` | `number` | Max calls per window |
+| `exceedHandler` | `() => void` | Called when limit exceeded |
+| `keyResolver` | `(...args) => string` | Per-key limiting |
+| `rateLimitCounter` | `RateLimitCounter` | Custom counter implementation |
+
+```ts
+class Api {
+  @rateLimit({ timeSpanMs: 1000, allowedCalls: 5 })
+  call(): void { /* max 5 per second */ }
+}
+```
+
+Also exported: `rateLimitFn(method, config)`, `SimpleRateLimitCounter`.
+
+### `@readonly()`
+
+Makes a method non-writable (prevents reassignment).
+
+```ts
+class Secure {
+  @readonly()
+  getSecret(): string { return this.secret; }
+}
+```
+
+### `@throttle(delayMs)`
+
+Throttles method calls to at most once per `delayMs` milliseconds.
+
+- **delayMs** (`number`) -- throttle interval.
+
+```ts
+class Scroll {
+  @throttle(100)
+  onScroll(): void { /* max once per 100ms */ }
+}
+```
+
+Also exported: `throttleFn(method, delayMs)`.
+
+### `@throttleAsync(parallelCalls?)`
+
+Limits concurrent async method executions. Excess calls are queued.
+
+- **parallelCalls** (`number`, default `1`) -- max concurrent executions.
+
+```ts
+class Processor {
+  @throttleAsync(3)
+  async process(item: Item): Promise<Result> { /* max 3 concurrent */ }
+}
+```
+
+Also exported: `throttleAsyncFn(method, parallelCalls?)`, `ThrottleAsyncExecutor`.
+
+## Types
+
+All decorator types are exported: `Method`, `Decorator`, `AsyncMethod`, `AsyncDecorator`.
+
+## License
+
+Apache-2.0

package/lib/_utils.d.ts

@@ -0,0 +1,46 @@
+//#region src/_utils.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 Inlined utilities for the decorators package.
+ * These are minimal copies of utilities from the monorepo to keep this package zero-dependency.
+ */
+declare const isPromise: (value: unknown) => value is Promise<unknown>;
+declare const isFunction: (value: unknown) => value is Function;
+declare const isNumber: (value: unknown) => value is number;
+declare const isString: (value: unknown) => value is string;
+declare const logger: {
+  info(message: string, data?: Record<string, unknown>): void;
+};
+declare class Queue<T> {
+  private firstItem;
+  private lastItem;
+  private size;
+  getSize(): number;
+  isEmpty(): boolean;
+  enqueue(item: T): void;
+  dequeue(): T | null;
+}
+declare class TaskExec {
+  private readonly tasks;
+  private handler;
+  exec(func: (...args: unknown[]) => unknown, ttl: number): void;
+  private handleNext;
+  private execNext;
+}
+//#endregion
+export { Queue, TaskExec, isFunction, isNumber, isPromise, isString, logger };
+//# sourceMappingURL=_utils.d.ts.map

package/lib/_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_utils.d.ts","names":[],"sources":["../src/_utils.ts"],"mappings":";;AAuBA;;;;;;;;;AAIA;;;;;;;;;cAJa,SAAA,GAAa,KAAA,cAAiB,KAAA,IAAS,OAAA;AAAA,cAIvC,UAAA,GAAc,KAAA,cAAiB,KAAA,IAAS,QAAA;AAAA,cAGxC,QAAA,GAAY,KAAA,cAAiB,KAAA;AAAA,cAG7B,QAAA,GAAY,KAAA,cAAiB,KAAA;AAAA,cAK7B,MAAA;wBACS,IAAA,GAAS,MAAA;AAAA;AAAA,cAalB,KAAA;EAAA,QACH,SAAA;EAAA,QACA,QAAA;EAAA,QACA,IAAA;EAED,OAAA,CAAA;EAIA,OAAA,CAAA;EAIA,OAAA,CAAQ,IAAA,EAAM,CAAA;EAcd,OAAA,CAAA,GAAW,CAAA;AAAA;AAAA,cAkBP,QAAA;EAAA,iBACM,KAAA;EAAA,QACT,OAAA;EAER,IAAA,CAAK,IAAA,MAAU,IAAA,yBAA6B,GAAA;EAAA,QAMpC,UAAA;EAAA,QAMA,QAAA;AAAA"}

package/lib/_utils.js

@@ -0,0 +1,91 @@
+//#region src/_utils.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 Inlined utilities for the decorators package.
+* These are minimal copies of utilities from the monorepo to keep this package zero-dependency.
+*/
+const isPromise = (value) => value instanceof Promise || typeof value === "object" && value !== null && typeof value.then === "function";
+const isFunction = (value) => typeof value === "function";
+const isNumber = (value) => typeof value === "number" && !Number.isNaN(value);
+const isString = (value) => typeof value === "string";
+const logger = { info(message, data) {
+	const suffix = data ? ` ${JSON.stringify(data)}` : "";
+	console.info(`INFO [decorators] ${message}${suffix}`);
+} };
+var Queue = class {
+	firstItem = null;
+	lastItem = null;
+	size = 0;
+	getSize() {
+		return this.size;
+	}
+	isEmpty() {
+		return this.size === 0;
+	}
+	enqueue(item) {
+		const newItem = {
+			next: null,
+			value: item
+		};
+		if (this.isEmpty()) {
+			this.firstItem = newItem;
+			this.lastItem = newItem;
+		} else {
+			if (this.lastItem) this.lastItem.next = newItem;
+			this.lastItem = newItem;
+		}
+		this.size += 1;
+	}
+	dequeue() {
+		let removedItem = null;
+		if (!this.isEmpty() && this.firstItem) {
+			removedItem = this.firstItem.value;
+			this.firstItem = this.firstItem.next;
+			this.size -= 1;
+		}
+		return removedItem;
+	}
+};
+var TaskExec = class {
+	tasks = [];
+	handler;
+	exec(func, ttl) {
+		this.tasks.push({
+			func,
+			execTime: Date.now() + ttl
+		});
+		this.tasks.sort((a, b) => a.execTime - b.execTime);
+		this.handleNext();
+	}
+	handleNext() {
+		if (!this.tasks.length) return;
+		const { execTime } = this.tasks[0];
+		this.execNext(Math.max(execTime - Date.now(), 0));
+	}
+	execNext(ttl) {
+		clearTimeout(this.handler);
+		this.handler = setTimeout(() => {
+			const task = this.tasks.shift();
+			if (task) task.func();
+			this.handleNext();
+		}, ttl);
+	}
+};
+//#endregion
+export { Queue, TaskExec, isFunction, isNumber, isPromise, isString, logger };
+
+//# sourceMappingURL=_utils.js.map

package/lib/_utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_utils.js","names":[],"sources":["../src/_utils.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 Inlined utilities for the decorators package.\n * These are minimal copies of utilities from the monorepo to keep this package zero-dependency.\n */\n\n// --- Type guards ---\n\nexport const isPromise = (value: unknown): value is Promise<unknown> =>\n  value instanceof Promise ||\n  (typeof value === 'object' && value !== null && typeof (value as any).then === 'function');\n\nexport const isFunction = (value: unknown): value is Function =>\n  typeof value === 'function';\n\nexport const isNumber = (value: unknown): value is number =>\n  typeof value === 'number' && !Number.isNaN(value);\n\nexport const isString = (value: unknown): value is string =>\n  typeof value === 'string';\n\n// --- Logger stub ---\n\nexport const logger = {\n  info(message: string, data?: Record<string, unknown>): void {\n    const suffix = data ? ` ${JSON.stringify(data)}` : '';\n    console.info(`INFO [decorators] ${message}${suffix}`);\n  },\n};\n\n// --- Queue (linked-list FIFO) ---\n\ninterface QueueNode<T> {\n  next: QueueNode<T> | null;\n  value: T;\n}\n\nexport class Queue<T> {\n  private firstItem: QueueNode<T> | null = null;\n  private lastItem: QueueNode<T> | null = null;\n  private size = 0;\n\n  public getSize(): number {\n    return this.size;\n  }\n\n  public isEmpty(): boolean {\n    return this.size === 0;\n  }\n\n  public enqueue(item: T): void {\n    const newItem: QueueNode<T> = { next: null, value: item };\n    if (this.isEmpty()) {\n      this.firstItem = newItem;\n      this.lastItem = newItem;\n    } else {\n      if (this.lastItem) {\n        this.lastItem.next = newItem;\n      }\n      this.lastItem = newItem;\n    }\n    this.size += 1;\n  }\n\n  public dequeue(): T | null {\n    let removedItem: T | null = null;\n    if (!this.isEmpty() && this.firstItem) {\n      removedItem = this.firstItem.value;\n      this.firstItem = this.firstItem.next;\n      this.size -= 1;\n    }\n    return removedItem;\n  }\n}\n\n// --- TaskExec (simple priority-based delayed execution) ---\n\ninterface TimedTask {\n  func: (...args: unknown[]) => unknown;\n  execTime: number;\n}\n\nexport class TaskExec {\n  private readonly tasks: TimedTask[] = [];\n  private handler: ReturnType<typeof setTimeout> | undefined;\n\n  exec(func: (...args: unknown[]) => unknown, ttl: number): void {\n    this.tasks.push({ func, execTime: Date.now() + ttl });\n    this.tasks.sort((a, b) => a.execTime - b.execTime);\n    this.handleNext();\n  }\n\n  private handleNext(): void {\n    if (!this.tasks.length) return;\n    const { execTime } = this.tasks[0]!;\n    this.execNext(Math.max(execTime - Date.now(), 0));\n  }\n\n  private execNext(ttl: number): void {\n    clearTimeout(this.handler);\n    this.handler = setTimeout(() => {\n      const task = this.tasks.shift();\n      if (task) task.func();\n      this.handleNext();\n    }, ttl);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,aAAa,UACxB,iBAAiB,WAChB,OAAO,UAAU,YAAY,UAAU,QAAQ,OAAQ,MAAc,SAAS;AAEjF,MAAa,cAAc,UACzB,OAAO,UAAU;AAEnB,MAAa,YAAY,UACvB,OAAO,UAAU,YAAY,CAAC,OAAO,MAAM,MAAM;AAEnD,MAAa,YAAY,UACvB,OAAO,UAAU;AAInB,MAAa,SAAS,EACpB,KAAK,SAAiB,MAAsC;CAC1D,MAAM,SAAS,OAAO,IAAI,KAAK,UAAU,KAAK,KAAK;AACnD,SAAQ,KAAK,qBAAqB,UAAU,SAAS;GAExD;AASD,IAAa,QAAb,MAAsB;CACpB,YAAyC;CACzC,WAAwC;CACxC,OAAe;CAEf,UAAyB;AACvB,SAAO,KAAK;;CAGd,UAA0B;AACxB,SAAO,KAAK,SAAS;;CAGvB,QAAe,MAAe;EAC5B,MAAM,UAAwB;GAAE,MAAM;GAAM,OAAO;GAAM;AACzD,MAAI,KAAK,SAAS,EAAE;AAClB,QAAK,YAAY;AACjB,QAAK,WAAW;SACX;AACL,OAAI,KAAK,SACP,MAAK,SAAS,OAAO;AAEvB,QAAK,WAAW;;AAElB,OAAK,QAAQ;;CAGf,UAA2B;EACzB,IAAI,cAAwB;AAC5B,MAAI,CAAC,KAAK,SAAS,IAAI,KAAK,WAAW;AACrC,iBAAc,KAAK,UAAU;AAC7B,QAAK,YAAY,KAAK,UAAU;AAChC,QAAK,QAAQ;;AAEf,SAAO;;;AAWX,IAAa,WAAb,MAAsB;CACpB,QAAsC,EAAE;CACxC;CAEA,KAAK,MAAuC,KAAmB;AAC7D,OAAK,MAAM,KAAK;GAAE;GAAM,UAAU,KAAK,KAAK,GAAG;GAAK,CAAC;AACrD,OAAK,MAAM,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,SAAS;AAClD,OAAK,YAAY;;CAGnB,aAA2B;AACzB,MAAI,CAAC,KAAK,MAAM,OAAQ;EACxB,MAAM,EAAE,aAAa,KAAK,MAAM;AAChC,OAAK,SAAS,KAAK,IAAI,WAAW,KAAK,KAAK,EAAE,EAAE,CAAC;;CAGnD,SAAiB,KAAmB;AAClC,eAAa,KAAK,QAAQ;AAC1B,OAAK,UAAU,iBAAiB;GAC9B,MAAM,OAAO,KAAK,MAAM,OAAO;AAC/B,OAAI,KAAM,MAAK,MAAM;AACrB,QAAK,YAAY;KAChB,IAAI"}

package/lib/after/after.d.ts

@@ -0,0 +1,60 @@
+import { Decorator } from "../types.js";
+import { AfterConfig } from "./after.types.js";
+
+//#region src/after/after.d.ts
+/**
+* @fileoverview After decorator - executes a function after the decorated method completes.
+* Useful for logging, cleanup, or triggering side effects after method execution.
+*
+* @module @resq/typescript/decorators/after
+*
+* @example
+* ```typescript
+* class MyService {
+*   @after({
+*     func: 'logCompletion',
+*     wait: true // Wait for after function to complete
+*   })
+*   async saveData(data: any) {
+*     await database.save(data);
+*   }
+*
+*   logCompletion({ response, args }) {
+*     console.log('Save completed:', response);
+*   }
+* }
+* ```
+*
+* @copyright Copyright (c) 2026 ResQ
+* @license MIT
+*/
+/**
+ * Decorator that executes a function after the decorated method completes.
+ * The after function receives the method's arguments and return value.
+ *
+ * @template T - The type of the class containing the decorated method
+ * @template D - The return type of the decorated method
+ * @param {AfterConfig<T, D>} config - Configuration for the after hook
+ * @returns {Decorator<T>} The decorator function
+ *
+ * @throws {Error} When applied to a non-method property
+ *
+ * @example
+ * ```typescript
+ * class DataProcessor {
+ *   @after({
+ *     func: function({ args, response }) {
+ *       console.log(`Processed ${args[0]} items, result: ${response}`);
+ *     },
+ *     wait: false // Don't wait for after function
+ *   })
+ *   processItems(items: string[]): number {
+ *     return items.length;
+ *   }
+ * }
+ * ```
+ */
+declare function after<T = any, D = any>(config: AfterConfig<T, D>): Decorator<T>;
+//#endregion
+export { after };
+//# sourceMappingURL=after.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"after.d.ts","names":[],"sources":["../../src/after/after.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyEgB,KAAA,kBAAA,CAAwB,MAAA,EAAQ,WAAA,CAAY,CAAA,EAAG,CAAA,IAAK,SAAA,CAAU,CAAA"}

package/lib/after/after.fn.d.ts

@@ -0,0 +1,39 @@
+import { Method } from "../types.js";
+import { AfterConfig } from "./after.types.js";
+
+//#region src/after/after.fn.d.ts
+/**
+ * Wraps a method to execute an after hook function after the method completes.
+ *
+ * @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 {AfterConfig<any, ReturnType<typeof originalMethod>>} config - Configuration for the after hook
+ * @returns {(...args: any[]) => Promise<D>} The wrapped method
+ *
+ * @example
+ * ```typescript
+ * class Service {
+ *   process(data: string): string {
+ *     return data.toUpperCase();
+ *   }
+ * }
+ *
+ * const service = new Service();
+ * const wrapped = afterFn(
+ *   service.process.bind(service),
+ *   {
+ *     func: ({ args, response }) => {
+ *       console.log(`Called with ${args[0]}, returned ${response}`);
+ *     },
+ *     wait: false
+ *   }
+ * );
+ *
+ * await wrapped('hello'); // Logs: Called with hello, returned HELLO
+ * ```
+ */
+declare function afterFn<D = any, A extends any[] = any[]>(originalMethod: Method<D, A>, config: AfterConfig<any, ReturnType<typeof originalMethod>>): (...args: unknown[]) => Promise<D>;
+//#endregion
+export { afterFn };
+//# sourceMappingURL=after.fn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"after.fn.d.ts","names":[],"sources":["../../src/after/after.fn.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDgB,OAAA,kCAAA,CACd,cAAA,EAAgB,MAAA,CAAO,CAAA,EAAG,CAAA,GAC1B,MAAA,EAAQ,WAAA,MAAiB,UAAA,QAAkB,cAAA,SACtC,IAAA,gBAAoB,OAAA,CAAQ,CAAA"}

package/lib/after/after.fn.js

@@ -0,0 +1,59 @@
+//#region src/after/after.fn.ts
+/**
+* Wraps a method to execute an after hook function after the method completes.
+*
+* @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 {AfterConfig<any, ReturnType<typeof originalMethod>>} config - Configuration for the after hook
+* @returns {(...args: any[]) => Promise<D>} The wrapped method
+*
+* @example
+* ```typescript
+* class Service {
+*   process(data: string): string {
+*     return data.toUpperCase();
+*   }
+* }
+*
+* const service = new Service();
+* const wrapped = afterFn(
+*   service.process.bind(service),
+*   {
+*     func: ({ args, response }) => {
+*       console.log(`Called with ${args[0]}, returned ${response}`);
+*     },
+*     wait: false
+*   }
+* );
+*
+* await wrapped('hello'); // Logs: Called with hello, returned HELLO
+* ```
+*/
+function afterFn(originalMethod, config) {
+	const resolvedConfig = {
+		wait: false,
+		...config
+	};
+	return async function(...args) {
+		const afterFunc = typeof resolvedConfig.func === "string" ? this[resolvedConfig.func].bind(this) : resolvedConfig.func;
+		if (resolvedConfig.wait) {
+			const response = await originalMethod.apply(this, args);
+			afterFunc({
+				args,
+				response
+			});
+			return response;
+		}
+		const response = originalMethod.apply(this, args);
+		afterFunc({
+			args,
+			response
+		});
+		return response;
+	};
+}
+//#endregion
+export { afterFn };
+
+//# sourceMappingURL=after.fn.js.map

package/lib/after/after.fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"after.fn.js","names":[],"sources":["../../src/after/after.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 { AfterConfig, AfterFunc } from './after.types.js';\n\n/**\n * Wraps a method to execute an after hook function after the method completes.\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 {AfterConfig<any, ReturnType<typeof originalMethod>>} config - Configuration for the after hook\n * @returns {(...args: any[]) => Promise<D>} 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 = afterFn(\n *   service.process.bind(service),\n *   {\n *     func: ({ args, response }) => {\n *       console.log(`Called with ${args[0]}, returned ${response}`);\n *     },\n *     wait: false\n *   }\n * );\n *\n * await wrapped('hello'); // Logs: Called with hello, returned HELLO\n * ```\n */\nexport function afterFn<D = any, A extends any[] = any[]>(\n  originalMethod: Method<D, A>,\n  config: AfterConfig<any, ReturnType<typeof originalMethod>>,\n): (...args: unknown[]) => Promise<D> {\n  const resolvedConfig: AfterConfig<any, ReturnType<typeof originalMethod>> = {\n    wait: false,\n    ...config,\n  };\n\n  return async function (this: any, ...args: A): Promise<D> {\n    const afterFunc: AfterFunc<ReturnType<typeof originalMethod>> =\n      typeof resolvedConfig.func === 'string'\n        ? this[resolvedConfig.func].bind(this)\n        : resolvedConfig.func;\n\n    if (resolvedConfig.wait) {\n      const response = await originalMethod.apply(this, args);\n      afterFunc({\n        args,\n        response,\n      });\n      return response;\n    }\n\n    const response = originalMethod.apply(this, args);\n    afterFunc({\n      args,\n      response,\n    });\n    return response;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,QACd,gBACA,QACoC;CACpC,MAAM,iBAAsE;EAC1E,MAAM;EACN,GAAG;EACJ;AAED,QAAO,eAA2B,GAAG,MAAqB;EACxD,MAAM,YACJ,OAAO,eAAe,SAAS,WAC3B,KAAK,eAAe,MAAM,KAAK,KAAK,GACpC,eAAe;AAErB,MAAI,eAAe,MAAM;GACvB,MAAM,WAAW,MAAM,eAAe,MAAM,MAAM,KAAK;AACvD,aAAU;IACR;IACA;IACD,CAAC;AACF,UAAO;;EAGT,MAAM,WAAW,eAAe,MAAM,MAAM,KAAK;AACjD,YAAU;GACR;GACA;GACD,CAAC;AACF,SAAO"}

package/lib/after/after.js

@@ -0,0 +1,41 @@
+import { afterFn } from "./after.fn.js";
+//#region src/after/after.ts
+/**
+* Decorator that executes a function after the decorated method completes.
+* The after function receives the method's arguments and return value.
+*
+* @template T - The type of the class containing the decorated method
+* @template D - The return type of the decorated method
+* @param {AfterConfig<T, D>} config - Configuration for the after hook
+* @returns {Decorator<T>} The decorator function
+*
+* @throws {Error} When applied to a non-method property
+*
+* @example
+* ```typescript
+* class DataProcessor {
+*   @after({
+*     func: function({ args, response }) {
+*       console.log(`Processed ${args[0]} items, result: ${response}`);
+*     },
+*     wait: false // Don't wait for after function
+*   })
+*   processItems(items: string[]): number {
+*     return items.length;
+*   }
+* }
+* ```
+*/
+function after(config) {
+	return (target, propertyName, descriptor) => {
+		if (descriptor.value) {
+			descriptor.value = afterFn(descriptor.value, config);
+			return descriptor;
+		}
+		throw new Error("@after is applicable only on a methods.");
+	};
+}
+//#endregion
+export { after };
+
+//# sourceMappingURL=after.js.map

package/lib/after/after.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"after.js","names":[],"sources":["../../src/after/after.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 After decorator - executes a function after the decorated method completes.\n * Useful for logging, cleanup, or triggering side effects after method execution.\n *\n * @module @resq/typescript/decorators/after\n *\n * @example\n * ```typescript\n * class MyService {\n *   @after({\n *     func: 'logCompletion',\n *     wait: true // Wait for after function to complete\n *   })\n *   async saveData(data: any) {\n *     await database.save(data);\n *   }\n *\n *   logCompletion({ response, args }) {\n *     console.log('Save completed:', response);\n *   }\n * }\n * ```\n *\n * @copyright Copyright (c) 2026 ResQ\n * @license MIT\n */\n\nimport type { Decorator, Method } from '../types.js';\nimport { afterFn } from './after.fn.js';\nimport type { AfterConfig } from './after.types.js';\n\n/**\n * Decorator that executes a function after the decorated method completes.\n * The after function receives the method's arguments and return value.\n *\n * @template T - The type of the class containing the decorated method\n * @template D - The return type of the decorated method\n * @param {AfterConfig<T, D>} config - Configuration for the after 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 *   @after({\n *     func: function({ args, response }) {\n *       console.log(`Processed ${args[0]} items, result: ${response}`);\n *     },\n *     wait: false // Don't wait for after function\n *   })\n *   processItems(items: string[]): number {\n *     return items.length;\n *   }\n * }\n * ```\n */\nexport function after<T = any, D = any>(config: AfterConfig<T, D>): Decorator<T> {\n  return (\n    target: T,\n    propertyName: keyof T,\n    descriptor: TypedPropertyDescriptor<Method<any>>,\n  ): TypedPropertyDescriptor<Method<D>> => {\n    if (descriptor.value) {\n      descriptor.value = afterFn(descriptor.value, config);\n\n      return descriptor;\n    }\n    throw new Error('@after is applicable only on a methods.');\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyEA,SAAgB,MAAwB,QAAyC;AAC/E,SACE,QACA,cACA,eACuC;AACvC,MAAI,WAAW,OAAO;AACpB,cAAW,QAAQ,QAAQ,WAAW,OAAO,OAAO;AAEpD,UAAO;;AAET,QAAM,IAAI,MAAM,0CAA0C"}