@unshared/decorators 0.0.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Stanley Horwood <stanley@hsjm.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/Debounce.cjs

@@ -0,0 +1,10 @@
+"use strict";
+var debounce = require("@unshared/functions/debounce");
+function Debounce(delay) {
+  return (target, propertyName, descriptor) => {
+    const method = descriptor.value;
+    return descriptor.value = debounce.debounce(method, delay), descriptor;
+  };
+}
+exports.Debounce = Debounce;
+//# sourceMappingURL=Debounce.cjs.map

package/dist/Debounce.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Debounce.cjs","sources":["../Debounce.ts"],"sourcesContent":["import { Function, MethodDecorator } from '@unshared/types'\nimport { debounce } from '@unshared/functions/debounce'\n\n/**\n * Debounce a method so that it will only execute after the specified delay. If the method\n * is called multiple times before the delay has passed, the method will only execute once\n * after the delay has passed. The method will be called with the parameters of the last call.\n *\n * **Note:** This decorator will omit the return value of the method and return `undefined`.\n *\n * @param delay The delay in milliseconds to wait before executing the method.\n * @returns The method descriptor.\n * @example\n * // Declare a class with a debounced method.\n * class Greeter {\n * ->@Debounce(100)\n *  greet(name: string) { return `Hello, ${name}! - ${Date.now()}` }\n * }\n *\n * // The first call to the method will be executed.\n * const instance = new Greeter()\n * instance.greet('Alice')\n * instance.greet('Bob')\n * instance.greet('Charlie')\n *\n * // After 100ms the method will be called with the parameters of the last call.\n * // => Hello, Charlie!\n */\nexport function Debounce<T extends Function<void>>(delay: number): MethodDecorator<T> {\n  return (target, propertyName, descriptor) => {\n    const method = descriptor.value!\n    descriptor.value = debounce(method, delay) as unknown as T\n    return descriptor\n  }\n}\n\n/* v8 ignore start */\nif (import.meta.vitest) {\n  beforeAll(() => {\n    vi.useFakeTimers()\n  })\n\n  test('should not call the function if the delay has not passed', () => {\n    const fn = vi.fn()\n    class Greeter { @Debounce(100) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    instance.fn()\n    instance.fn()\n    vi.advanceTimersByTime(50)\n    expect(fn).not.toHaveBeenCalled()\n  })\n\n  test('should call the function once after the delay has passed', () => {\n    const fn = vi.fn()\n    class Greeter { @Debounce(10) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    instance.fn()\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledTimes(1)\n  })\n\n  test('should call the function once with the parameters of the last call', () => {\n    const fn = vi.fn()\n    class Greeter { @Debounce(10) fn(name: string) { fn(name) } }\n    const instance = new Greeter()\n    instance.fn('Alice')\n    instance.fn('Bob')\n    instance.fn('Charlie')\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledWith('Charlie')\n  })\n\n  test('should call the function multiple times if the delay has passed', () => {\n    const fn = vi.fn()\n    class Greeter { @Debounce(10) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledTimes(3)\n  })\n\n  test('should return undefined', () => {\n    const fn = vi.fn(() => 'foobar')\n    class Greeter { @Debounce(10) fn() { return fn() } }\n    const instance = new Greeter()\n    const result = instance.fn()\n    expect(result).toBeUndefined()\n  })\n}\n"],"names":["debounce"],"mappings":";;AA4BO,SAAS,SAAmC,OAAmC;AAC7E,SAAA,CAAC,QAAQ,cAAc,eAAe;AAC3C,UAAM,SAAS,WAAW;AAC1B,WAAA,WAAW,QAAQA,SAAAA,SAAS,QAAQ,KAAK,GAClC;AAAA,EAAA;AAEX;;"}

package/dist/Debounce.d.ts

@@ -0,0 +1,30 @@
+import { Function, MethodDecorator } from '@unshared/types';
+
+/**
+ * Debounce a method so that it will only execute after the specified delay. If the method
+ * is called multiple times before the delay has passed, the method will only execute once
+ * after the delay has passed. The method will be called with the parameters of the last call.
+ *
+ * **Note:** This decorator will omit the return value of the method and return `undefined`.
+ *
+ * @param delay The delay in milliseconds to wait before executing the method.
+ * @returns The method descriptor.
+ * @example
+ * // Declare a class with a debounced method.
+ * class Greeter {
+ * ->@Debounce(100)
+ *  greet(name: string) { return `Hello, ${name}! - ${Date.now()}` }
+ * }
+ *
+ * // The first call to the method will be executed.
+ * const instance = new Greeter()
+ * instance.greet('Alice')
+ * instance.greet('Bob')
+ * instance.greet('Charlie')
+ *
+ * // After 100ms the method will be called with the parameters of the last call.
+ * // => Hello, Charlie!
+ */
+declare function Debounce<T extends Function<void>>(delay: number): MethodDecorator<T>;
+
+export { Debounce };

package/dist/Debounce.js

@@ -0,0 +1,11 @@
+import { debounce } from "@unshared/functions/debounce";
+function Debounce(delay) {
+  return (target, propertyName, descriptor) => {
+    const method = descriptor.value;
+    return descriptor.value = debounce(method, delay), descriptor;
+  };
+}
+export {
+  Debounce
+};
+//# sourceMappingURL=Debounce.js.map

package/dist/Debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Debounce.js","sources":["../Debounce.ts"],"sourcesContent":["import { Function, MethodDecorator } from '@unshared/types'\nimport { debounce } from '@unshared/functions/debounce'\n\n/**\n * Debounce a method so that it will only execute after the specified delay. If the method\n * is called multiple times before the delay has passed, the method will only execute once\n * after the delay has passed. The method will be called with the parameters of the last call.\n *\n * **Note:** This decorator will omit the return value of the method and return `undefined`.\n *\n * @param delay The delay in milliseconds to wait before executing the method.\n * @returns The method descriptor.\n * @example\n * // Declare a class with a debounced method.\n * class Greeter {\n * ->@Debounce(100)\n *  greet(name: string) { return `Hello, ${name}! - ${Date.now()}` }\n * }\n *\n * // The first call to the method will be executed.\n * const instance = new Greeter()\n * instance.greet('Alice')\n * instance.greet('Bob')\n * instance.greet('Charlie')\n *\n * // After 100ms the method will be called with the parameters of the last call.\n * // => Hello, Charlie!\n */\nexport function Debounce<T extends Function<void>>(delay: number): MethodDecorator<T> {\n  return (target, propertyName, descriptor) => {\n    const method = descriptor.value!\n    descriptor.value = debounce(method, delay) as unknown as T\n    return descriptor\n  }\n}\n\n/* v8 ignore start */\nif (import.meta.vitest) {\n  beforeAll(() => {\n    vi.useFakeTimers()\n  })\n\n  test('should not call the function if the delay has not passed', () => {\n    const fn = vi.fn()\n    class Greeter { @Debounce(100) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    instance.fn()\n    instance.fn()\n    vi.advanceTimersByTime(50)\n    expect(fn).not.toHaveBeenCalled()\n  })\n\n  test('should call the function once after the delay has passed', () => {\n    const fn = vi.fn()\n    class Greeter { @Debounce(10) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    instance.fn()\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledTimes(1)\n  })\n\n  test('should call the function once with the parameters of the last call', () => {\n    const fn = vi.fn()\n    class Greeter { @Debounce(10) fn(name: string) { fn(name) } }\n    const instance = new Greeter()\n    instance.fn('Alice')\n    instance.fn('Bob')\n    instance.fn('Charlie')\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledWith('Charlie')\n  })\n\n  test('should call the function multiple times if the delay has passed', () => {\n    const fn = vi.fn()\n    class Greeter { @Debounce(10) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledTimes(3)\n  })\n\n  test('should return undefined', () => {\n    const fn = vi.fn(() => 'foobar')\n    class Greeter { @Debounce(10) fn() { return fn() } }\n    const instance = new Greeter()\n    const result = instance.fn()\n    expect(result).toBeUndefined()\n  })\n}\n"],"names":[],"mappings":";AA4BO,SAAS,SAAmC,OAAmC;AAC7E,SAAA,CAAC,QAAQ,cAAc,eAAe;AAC3C,UAAM,SAAS,WAAW;AAC1B,WAAA,WAAW,QAAQ,SAAS,QAAQ,KAAK,GAClC;AAAA,EAAA;AAEX;"}

package/dist/Memoize.cjs

@@ -0,0 +1,10 @@
+"use strict";
+var memoize = require("@unshared/functions/memoize");
+function Memoize(options) {
+  return function(_target, _propertyName, descriptor) {
+    const method = descriptor.value;
+    return descriptor.value = memoize.memoize(method, options), descriptor;
+  };
+}
+exports.Memoize = Memoize;
+//# sourceMappingURL=Memoize.cjs.map

package/dist/Memoize.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Memoize.cjs","sources":["../Memoize.ts"],"sourcesContent":["import { Function, MethodDecorator } from '@unshared/types'\nimport { MemoizeOptions, memoize } from '@unshared/functions/memoize'\n\n/**\n * Decorate a method to memoize it's result based on the arguments. Meaning\n * that it will return the same result without executing the method again,\n * **unless the arguments change**.\n *\n * @param options The memoization options.\n * @returns The method descriptor.\n * @example\n * // Declare a class with a memoized method.\n * class Greeter {\n * ->@Memoize()\n *   greet(name: string) { return `Hello, ${name}! - ${Math.random()}` }\n * }\n *\n * // The first call to the method will be executed.\n * const instance = new Greeter()\n * instance.greet('Alice') // 'Hello, Alice! - 0.123456789'\n * instance.greet('Alice') // 'Hello, Alice! - 0.123456789'\n * instance.greet('Bob')   // 'Hello, Bob!   - 0.987654321'\n */\nexport function Memoize<T extends Function>(options?: MemoizeOptions<T>): MethodDecorator<T> {\n  return function(_target, _propertyName, descriptor) {\n    const method = descriptor.value!\n    descriptor.value = memoize(method, options) as unknown as T\n    return descriptor\n  }\n}\n\n/* v8 ignore start */\nif (import.meta.vitest) {\n  test('should memoize the method', () => {\n    const fn = vi.fn(Math.random)\n    class MyClass { @Memoize() getId() { return fn() } }\n    const instance = new MyClass()\n    const id1 = instance.getId()\n    const id2 = instance.getId()\n    expect(id1).toStrictEqual(id2)\n    expect(fn).toHaveBeenCalledTimes(1)\n    expect(fn).toHaveBeenCalledWith()\n  })\n\n  test('should memoize the method by parameter', () => {\n    const fn = vi.fn((n = 0) => (n as number) + Math.random())\n    class MyClass { @Memoize() getId(n: number) { return fn(n) } }\n    const instance = new MyClass()\n    const id1 = instance.getId(1)\n    const id2 = instance.getId(1)\n    const id3 = instance.getId(2)\n    expect(id1).toStrictEqual(id2)\n    expect(id1).not.toStrictEqual(id3)\n    expect(fn).toHaveBeenCalledTimes(2)\n    expect(fn).toHaveBeenCalledWith(1)\n    expect(fn).toHaveBeenCalledWith(2)\n  })\n\n  test('should preserve the method context', () => {\n    class MyClass { value = { foo: 42 }; @Memoize() getValue() { return this?.value } }\n    const instance = new MyClass()\n    const result1 = instance.getValue()\n    const result2 = instance.value\n    expect(result1).toBe(result2)\n  })\n}\n"],"names":["memoize"],"mappings":";;AAuBO,SAAS,QAA4B,SAAiD;AACpF,SAAA,SAAS,SAAS,eAAe,YAAY;AAClD,UAAM,SAAS,WAAW;AAC1B,WAAA,WAAW,QAAQA,QAAAA,QAAQ,QAAQ,OAAO,GACnC;AAAA,EAAA;AAEX;;"}

package/dist/Memoize.d.ts

@@ -0,0 +1,26 @@
+import { Function, MethodDecorator } from '@unshared/types';
+import { MemoizeOptions } from '@unshared/functions/memoize';
+
+/**
+ * Decorate a method to memoize it's result based on the arguments. Meaning
+ * that it will return the same result without executing the method again,
+ * **unless the arguments change**.
+ *
+ * @param options The memoization options.
+ * @returns The method descriptor.
+ * @example
+ * // Declare a class with a memoized method.
+ * class Greeter {
+ * ->@Memoize()
+ *   greet(name: string) { return `Hello, ${name}! - ${Math.random()}` }
+ * }
+ *
+ * // The first call to the method will be executed.
+ * const instance = new Greeter()
+ * instance.greet('Alice') // 'Hello, Alice! - 0.123456789'
+ * instance.greet('Alice') // 'Hello, Alice! - 0.123456789'
+ * instance.greet('Bob')   // 'Hello, Bob!   - 0.987654321'
+ */
+declare function Memoize<T extends Function>(options?: MemoizeOptions<T>): MethodDecorator<T>;
+
+export { Memoize };

package/dist/Memoize.js

@@ -0,0 +1,11 @@
+import { memoize } from "@unshared/functions/memoize";
+function Memoize(options) {
+  return function(_target, _propertyName, descriptor) {
+    const method = descriptor.value;
+    return descriptor.value = memoize(method, options), descriptor;
+  };
+}
+export {
+  Memoize
+};
+//# sourceMappingURL=Memoize.js.map

package/dist/Memoize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Memoize.js","sources":["../Memoize.ts"],"sourcesContent":["import { Function, MethodDecorator } from '@unshared/types'\nimport { MemoizeOptions, memoize } from '@unshared/functions/memoize'\n\n/**\n * Decorate a method to memoize it's result based on the arguments. Meaning\n * that it will return the same result without executing the method again,\n * **unless the arguments change**.\n *\n * @param options The memoization options.\n * @returns The method descriptor.\n * @example\n * // Declare a class with a memoized method.\n * class Greeter {\n * ->@Memoize()\n *   greet(name: string) { return `Hello, ${name}! - ${Math.random()}` }\n * }\n *\n * // The first call to the method will be executed.\n * const instance = new Greeter()\n * instance.greet('Alice') // 'Hello, Alice! - 0.123456789'\n * instance.greet('Alice') // 'Hello, Alice! - 0.123456789'\n * instance.greet('Bob')   // 'Hello, Bob!   - 0.987654321'\n */\nexport function Memoize<T extends Function>(options?: MemoizeOptions<T>): MethodDecorator<T> {\n  return function(_target, _propertyName, descriptor) {\n    const method = descriptor.value!\n    descriptor.value = memoize(method, options) as unknown as T\n    return descriptor\n  }\n}\n\n/* v8 ignore start */\nif (import.meta.vitest) {\n  test('should memoize the method', () => {\n    const fn = vi.fn(Math.random)\n    class MyClass { @Memoize() getId() { return fn() } }\n    const instance = new MyClass()\n    const id1 = instance.getId()\n    const id2 = instance.getId()\n    expect(id1).toStrictEqual(id2)\n    expect(fn).toHaveBeenCalledTimes(1)\n    expect(fn).toHaveBeenCalledWith()\n  })\n\n  test('should memoize the method by parameter', () => {\n    const fn = vi.fn((n = 0) => (n as number) + Math.random())\n    class MyClass { @Memoize() getId(n: number) { return fn(n) } }\n    const instance = new MyClass()\n    const id1 = instance.getId(1)\n    const id2 = instance.getId(1)\n    const id3 = instance.getId(2)\n    expect(id1).toStrictEqual(id2)\n    expect(id1).not.toStrictEqual(id3)\n    expect(fn).toHaveBeenCalledTimes(2)\n    expect(fn).toHaveBeenCalledWith(1)\n    expect(fn).toHaveBeenCalledWith(2)\n  })\n\n  test('should preserve the method context', () => {\n    class MyClass { value = { foo: 42 }; @Memoize() getValue() { return this?.value } }\n    const instance = new MyClass()\n    const result1 = instance.getValue()\n    const result2 = instance.value\n    expect(result1).toBe(result2)\n  })\n}\n"],"names":[],"mappings":";AAuBO,SAAS,QAA4B,SAAiD;AACpF,SAAA,SAAS,SAAS,eAAe,YAAY;AAClD,UAAM,SAAS,WAAW;AAC1B,WAAA,WAAW,QAAQ,QAAQ,QAAQ,OAAO,GACnC;AAAA,EAAA;AAEX;"}

package/dist/Once.cjs

@@ -0,0 +1,10 @@
+"use strict";
+var once = require("@unshared/functions/once");
+function Once() {
+  return (target, propertyName, descriptor) => {
+    const method = descriptor.value;
+    return descriptor.value = once.once(method), descriptor;
+  };
+}
+exports.Once = Once;
+//# sourceMappingURL=Once.cjs.map

package/dist/Once.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Once.cjs","sources":["../Once.ts"],"sourcesContent":["import { Function, MethodDecorator } from '@unshared/types'\nimport { once } from '@unshared/functions/once'\n\n/**\n * Decorate a method to memoize it's result. Meaning that if the method is called,\n * it will return the same result without executing the method again, **even if the\n * method is called with different arguments**.\n *\n * @returns The method descriptor.\n * @example\n * // Declare a class with a onced method.\n * class Greeter {\n * ->@Once()\n *  greet(name: string) { return `Hello, ${name}! - ${Math.random()}` }\n * }\n *\n * // The first call to the method will be executed.\n * const instance = new Greeter()\n * instance.greet('Alice') // 'Hello, Alice! - 0.123456789'\n * instance.greet('Bob')   // 'Hello, Alice! - 0.123456789'\n */\nexport function Once<T extends Function>(): MethodDecorator<T> {\n  return (target, propertyName, descriptor) => {\n    const method = descriptor.value!\n    descriptor.value = once(method) as unknown as T\n    return descriptor\n  }\n}\n\n/* v8 ignore start */\nif (import.meta.vitest) {\n  test('should return the same value if no arguments are passed', () => {\n    const fn = vi.fn(Math.random)\n    class MyClass { @Once() getId() { return fn() } }\n    const instance = new MyClass()\n    const id1 = instance.getId()\n    const id2 = instance.getId()\n    expect(id1).toStrictEqual(id2)\n    expect(fn).toHaveBeenCalledTimes(1)\n    expect(fn).toHaveBeenCalledWith()\n  })\n\n  test('should return the same values if different arguments are passed', () => {\n    const fn = vi.fn((n = 0) => (n as number) + Math.random())\n    class MyClass { @Once() getId(n: number) { return fn(n) } }\n    const instance = new MyClass()\n    const id1 = instance.getId(1)\n    const id2 = instance.getId(1)\n    const id3 = instance.getId(2)\n    expect(id1).toStrictEqual(id2)\n    expect(id1).toStrictEqual(id3)\n    expect(fn).toHaveBeenCalledTimes(1)\n    expect(fn).toHaveBeenCalledWith(1)\n    expect(fn).not.toHaveBeenCalledWith(2)\n  })\n\n  test('should preserve the method context', () => {\n    class MyClass { value = { foo: 42 }; @Once() getValue() { return this?.value } }\n    const instance = new MyClass()\n    const result1 = instance.getValue()\n    const result2 = instance.value\n    expect(result1).toBe(result2)\n  })\n\n  test('should have different results for different instances', () => {\n    class MyClass { @Once() getValue() { return Math.random() } }\n    const instance1 = new MyClass()\n    const instance2 = new MyClass()\n    const result1 = instance1.getValue()\n    const result2 = instance2.getValue()\n    expect(result1).not.toStrictEqual(result2)\n  })\n}\n"],"names":["once"],"mappings":";;AAqBO,SAAS,OAA+C;AACtD,SAAA,CAAC,QAAQ,cAAc,eAAe;AAC3C,UAAM,SAAS,WAAW;AACf,WAAA,WAAA,QAAQA,KAAK,KAAA,MAAM,GACvB;AAAA,EAAA;AAEX;;"}

package/dist/Once.d.ts

@@ -0,0 +1,23 @@
+import { Function, MethodDecorator } from '@unshared/types';
+
+/**
+ * Decorate a method to memoize it's result. Meaning that if the method is called,
+ * it will return the same result without executing the method again, **even if the
+ * method is called with different arguments**.
+ *
+ * @returns The method descriptor.
+ * @example
+ * // Declare a class with a onced method.
+ * class Greeter {
+ * ->@Once()
+ *  greet(name: string) { return `Hello, ${name}! - ${Math.random()}` }
+ * }
+ *
+ * // The first call to the method will be executed.
+ * const instance = new Greeter()
+ * instance.greet('Alice') // 'Hello, Alice! - 0.123456789'
+ * instance.greet('Bob')   // 'Hello, Alice! - 0.123456789'
+ */
+declare function Once<T extends Function>(): MethodDecorator<T>;
+
+export { Once };

package/dist/Once.js

@@ -0,0 +1,11 @@
+import { once } from "@unshared/functions/once";
+function Once() {
+  return (target, propertyName, descriptor) => {
+    const method = descriptor.value;
+    return descriptor.value = once(method), descriptor;
+  };
+}
+export {
+  Once
+};
+//# sourceMappingURL=Once.js.map

package/dist/Once.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Once.js","sources":["../Once.ts"],"sourcesContent":["import { Function, MethodDecorator } from '@unshared/types'\nimport { once } from '@unshared/functions/once'\n\n/**\n * Decorate a method to memoize it's result. Meaning that if the method is called,\n * it will return the same result without executing the method again, **even if the\n * method is called with different arguments**.\n *\n * @returns The method descriptor.\n * @example\n * // Declare a class with a onced method.\n * class Greeter {\n * ->@Once()\n *  greet(name: string) { return `Hello, ${name}! - ${Math.random()}` }\n * }\n *\n * // The first call to the method will be executed.\n * const instance = new Greeter()\n * instance.greet('Alice') // 'Hello, Alice! - 0.123456789'\n * instance.greet('Bob')   // 'Hello, Alice! - 0.123456789'\n */\nexport function Once<T extends Function>(): MethodDecorator<T> {\n  return (target, propertyName, descriptor) => {\n    const method = descriptor.value!\n    descriptor.value = once(method) as unknown as T\n    return descriptor\n  }\n}\n\n/* v8 ignore start */\nif (import.meta.vitest) {\n  test('should return the same value if no arguments are passed', () => {\n    const fn = vi.fn(Math.random)\n    class MyClass { @Once() getId() { return fn() } }\n    const instance = new MyClass()\n    const id1 = instance.getId()\n    const id2 = instance.getId()\n    expect(id1).toStrictEqual(id2)\n    expect(fn).toHaveBeenCalledTimes(1)\n    expect(fn).toHaveBeenCalledWith()\n  })\n\n  test('should return the same values if different arguments are passed', () => {\n    const fn = vi.fn((n = 0) => (n as number) + Math.random())\n    class MyClass { @Once() getId(n: number) { return fn(n) } }\n    const instance = new MyClass()\n    const id1 = instance.getId(1)\n    const id2 = instance.getId(1)\n    const id3 = instance.getId(2)\n    expect(id1).toStrictEqual(id2)\n    expect(id1).toStrictEqual(id3)\n    expect(fn).toHaveBeenCalledTimes(1)\n    expect(fn).toHaveBeenCalledWith(1)\n    expect(fn).not.toHaveBeenCalledWith(2)\n  })\n\n  test('should preserve the method context', () => {\n    class MyClass { value = { foo: 42 }; @Once() getValue() { return this?.value } }\n    const instance = new MyClass()\n    const result1 = instance.getValue()\n    const result2 = instance.value\n    expect(result1).toBe(result2)\n  })\n\n  test('should have different results for different instances', () => {\n    class MyClass { @Once() getValue() { return Math.random() } }\n    const instance1 = new MyClass()\n    const instance2 = new MyClass()\n    const result1 = instance1.getValue()\n    const result2 = instance2.getValue()\n    expect(result1).not.toStrictEqual(result2)\n  })\n}\n"],"names":[],"mappings":";AAqBO,SAAS,OAA+C;AACtD,SAAA,CAAC,QAAQ,cAAc,eAAe;AAC3C,UAAM,SAAS,WAAW;AACf,WAAA,WAAA,QAAQ,KAAK,MAAM,GACvB;AAAA,EAAA;AAEX;"}

package/dist/Throttle.cjs

@@ -0,0 +1,10 @@
+"use strict";
+var throttle = require("@unshared/functions/throttle");
+function Throttle(delay) {
+  return (target, propertyName, descriptor) => {
+    const method = descriptor.value;
+    return descriptor.value = throttle.throttle(method, delay), descriptor;
+  };
+}
+exports.Throttle = Throttle;
+//# sourceMappingURL=Throttle.cjs.map

package/dist/Throttle.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Throttle.cjs","sources":["../Throttle.ts"],"sourcesContent":["import { Function, MethodDecorator } from '@unshared/types'\nimport { throttle } from '@unshared/functions/throttle'\n\n/**\n * Throttle a method so that it will only execute once every specified delay.\n * Useful for implementing spam protection. When the method is called, it will\n * execute immediately and then wait for the specified delay before it can be\n * called again.\n *\n * **Note:** This decorator will omit the return value of the method and return `undefined`.\n *\n * @param delay The delay in milliseconds to wait before executing the method.\n * @returns The method descriptor.\n * @example\n * // Declare a class with a debounced method.\n * class Greeter {\n * ->@Throttle(100)\n *  greet(name: string) { return `Hello, ${name}! - ${Date.now()}` }\n * }\n *\n * // The first call to the method will be executed.\n * const instance = new Greeter()\n * instance.greet('Alice')\n * instance.greet('Bob')\n * instance.greet('Charlie')\n *\n * // The method will be called immediately and can only be called again after 100ms.\n * // => Hello, Alice!\n */\nexport function Throttle<T extends Function<void>>(delay: number): MethodDecorator<T> {\n  return (target, propertyName, descriptor) => {\n    const method = descriptor.value!\n    descriptor.value = throttle(method, delay) as unknown as T\n    return descriptor\n  }\n}\n\n/* v8 ignore start */\nif (import.meta.vitest) {\n  beforeEach(() => vi.useFakeTimers)\n\n  test('should call the function immediately', () => {\n    const fn = vi.fn()\n    class Greeter { @Throttle(100) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    expect(fn).toHaveBeenCalledTimes(1)\n  })\n\n  test('should not call the function more than once within the delay', () => {\n    const fn = vi.fn()\n    class Greeter { @Throttle(100) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    instance.fn()\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledTimes(1)\n  })\n\n  test('should pass the parameters of the first call to the function', () => {\n    const fn = vi.fn()\n    class Greeter { @Throttle(10) fn(name: string) { fn(name) } }\n    const instance = new Greeter()\n    instance.fn('Alice')\n    instance.fn('Bob')\n    instance.fn('Charlie')\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledWith('Alice')\n  })\n\n  test('should call the function again after the delay has passed', () => {\n    const fn = vi.fn()\n    class Greeter { @Throttle(100) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledTimes(2)\n  })\n\n  test('should return undefined', () => {\n    const fn = vi.fn(() => 'foobar')\n    class Greeter { @Throttle(100) fn() { return fn() } }\n    const instance = new Greeter()\n    const result = instance.fn()\n    expect(result).toBeUndefined()\n  })\n}\n"],"names":["throttle"],"mappings":";;AA6BO,SAAS,SAAmC,OAAmC;AAC7E,SAAA,CAAC,QAAQ,cAAc,eAAe;AAC3C,UAAM,SAAS,WAAW;AAC1B,WAAA,WAAW,QAAQA,SAAAA,SAAS,QAAQ,KAAK,GAClC;AAAA,EAAA;AAEX;;"}

package/dist/Throttle.d.ts

@@ -0,0 +1,31 @@
+import { Function, MethodDecorator } from '@unshared/types';
+
+/**
+ * Throttle a method so that it will only execute once every specified delay.
+ * Useful for implementing spam protection. When the method is called, it will
+ * execute immediately and then wait for the specified delay before it can be
+ * called again.
+ *
+ * **Note:** This decorator will omit the return value of the method and return `undefined`.
+ *
+ * @param delay The delay in milliseconds to wait before executing the method.
+ * @returns The method descriptor.
+ * @example
+ * // Declare a class with a debounced method.
+ * class Greeter {
+ * ->@Throttle(100)
+ *  greet(name: string) { return `Hello, ${name}! - ${Date.now()}` }
+ * }
+ *
+ * // The first call to the method will be executed.
+ * const instance = new Greeter()
+ * instance.greet('Alice')
+ * instance.greet('Bob')
+ * instance.greet('Charlie')
+ *
+ * // The method will be called immediately and can only be called again after 100ms.
+ * // => Hello, Alice!
+ */
+declare function Throttle<T extends Function<void>>(delay: number): MethodDecorator<T>;
+
+export { Throttle };

package/dist/Throttle.js

@@ -0,0 +1,11 @@
+import { throttle } from "@unshared/functions/throttle";
+function Throttle(delay) {
+  return (target, propertyName, descriptor) => {
+    const method = descriptor.value;
+    return descriptor.value = throttle(method, delay), descriptor;
+  };
+}
+export {
+  Throttle
+};
+//# sourceMappingURL=Throttle.js.map

package/dist/Throttle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Throttle.js","sources":["../Throttle.ts"],"sourcesContent":["import { Function, MethodDecorator } from '@unshared/types'\nimport { throttle } from '@unshared/functions/throttle'\n\n/**\n * Throttle a method so that it will only execute once every specified delay.\n * Useful for implementing spam protection. When the method is called, it will\n * execute immediately and then wait for the specified delay before it can be\n * called again.\n *\n * **Note:** This decorator will omit the return value of the method and return `undefined`.\n *\n * @param delay The delay in milliseconds to wait before executing the method.\n * @returns The method descriptor.\n * @example\n * // Declare a class with a debounced method.\n * class Greeter {\n * ->@Throttle(100)\n *  greet(name: string) { return `Hello, ${name}! - ${Date.now()}` }\n * }\n *\n * // The first call to the method will be executed.\n * const instance = new Greeter()\n * instance.greet('Alice')\n * instance.greet('Bob')\n * instance.greet('Charlie')\n *\n * // The method will be called immediately and can only be called again after 100ms.\n * // => Hello, Alice!\n */\nexport function Throttle<T extends Function<void>>(delay: number): MethodDecorator<T> {\n  return (target, propertyName, descriptor) => {\n    const method = descriptor.value!\n    descriptor.value = throttle(method, delay) as unknown as T\n    return descriptor\n  }\n}\n\n/* v8 ignore start */\nif (import.meta.vitest) {\n  beforeEach(() => vi.useFakeTimers)\n\n  test('should call the function immediately', () => {\n    const fn = vi.fn()\n    class Greeter { @Throttle(100) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    expect(fn).toHaveBeenCalledTimes(1)\n  })\n\n  test('should not call the function more than once within the delay', () => {\n    const fn = vi.fn()\n    class Greeter { @Throttle(100) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    instance.fn()\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledTimes(1)\n  })\n\n  test('should pass the parameters of the first call to the function', () => {\n    const fn = vi.fn()\n    class Greeter { @Throttle(10) fn(name: string) { fn(name) } }\n    const instance = new Greeter()\n    instance.fn('Alice')\n    instance.fn('Bob')\n    instance.fn('Charlie')\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledWith('Alice')\n  })\n\n  test('should call the function again after the delay has passed', () => {\n    const fn = vi.fn()\n    class Greeter { @Throttle(100) fn() { fn() } }\n    const instance = new Greeter()\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    instance.fn()\n    vi.advanceTimersByTime(100)\n    expect(fn).toHaveBeenCalledTimes(2)\n  })\n\n  test('should return undefined', () => {\n    const fn = vi.fn(() => 'foobar')\n    class Greeter { @Throttle(100) fn() { return fn() } }\n    const instance = new Greeter()\n    const result = instance.fn()\n    expect(result).toBeUndefined()\n  })\n}\n"],"names":[],"mappings":";AA6BO,SAAS,SAAmC,OAAmC;AAC7E,SAAA,CAAC,QAAQ,cAAc,eAAe;AAC3C,UAAM,SAAS,WAAW;AAC1B,WAAA,WAAW,QAAQ,SAAS,QAAQ,KAAK,GAClC;AAAA,EAAA;AAEX;"}

package/dist/index.cjs

@@ -0,0 +1,11 @@
+"use strict";
+var Debounce = require("./Debounce.cjs"), Memoize = require("./Memoize.cjs"), Once = require("./Once.cjs"), Throttle = require("./Throttle.cjs");
+require("@unshared/functions/debounce");
+require("@unshared/functions/memoize");
+require("@unshared/functions/once");
+require("@unshared/functions/throttle");
+exports.Debounce = Debounce.Debounce;
+exports.Memoize = Memoize.Memoize;
+exports.Once = Once.Once;
+exports.Throttle = Throttle.Throttle;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { Debounce } from './Debounce.js';
+export { Memoize } from './Memoize.js';
+export { Once } from './Once.js';
+export { Throttle } from './Throttle.js';
+import '@unshared/types';
+import '@unshared/functions/memoize';

package/dist/index.js

@@ -0,0 +1,15 @@
+import { Debounce } from "./Debounce.js";
+import { Memoize } from "./Memoize.js";
+import { Once } from "./Once.js";
+import { Throttle } from "./Throttle.js";
+import "@unshared/functions/debounce";
+import "@unshared/functions/memoize";
+import "@unshared/functions/once";
+import "@unshared/functions/throttle";
+export {
+  Debounce,
+  Memoize,
+  Once,
+  Throttle
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@unshared/decorators",
+  "type": "module",
+  "version": "0.0.1",
+  "license": "MIT",
+  "sideEffects": false,
+  "author": "Stanley Horwood <stanley@hsjm.io>",
+  "bugs": "https://github.com/shorwood/unshared/issues",
+  "homepage": "https://github.com/shorwood/unshared#readme",
+  "repository": {
+    "directory": "packages/decorators",
+    "type": "git",
+    "url": "git+ssh://https://github.com/shorwood/unshared"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./Debounce": {
+      "require": "./dist/Debounce.cjs",
+      "types": "./dist/Debounce.d.ts",
+      "import": "./dist/Debounce.js"
+    },
+    "./Memoize": {
+      "require": "./dist/Memoize.cjs",
+      "types": "./dist/Memoize.d.ts",
+      "import": "./dist/Memoize.js"
+    },
+    "./Once": {
+      "require": "./dist/Once.cjs",
+      "types": "./dist/Once.d.ts",
+      "import": "./dist/Once.js"
+    },
+    "./Throttle": {
+      "require": "./dist/Throttle.cjs",
+      "types": "./dist/Throttle.d.ts",
+      "import": "./dist/Throttle.js"
+    },
+    ".": {
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "dependencies": {
+    "@unshared/functions": "0.0.1",
+    "@unshared/types": "0.0.1"
+  }
+}