💅 decorio — First-class ECMAScript decorators

A toolkit of decorators built on the Stage 3 ECMAScript Decorators proposal. These follow the TC39 spec (not the old typescript "legacy" decorators): https://github.com/tc39/proposal-decorators.

📦 Install

``bash
npm install decorio


or


yarn add decorio
`

🗄️ Caching decorators

$3

Run a method only once for each unique set of arguments. Any further calls with the same inputs just return the cached result: no extra executions.

`typescript
import { once } from 'decorio';

class Example {
@once compute(x: number): number {
console.log('Computing', x);

return x * 2;
}
}

const e = new Example();
e.compute(3); // logs 'Computing 3', returns 6
e.compute(3); // returns 6 from cache, no log
`

$3

Cache all (args ➡️ result) pairs per instance. Use cached.invalidate(fn) to clear the cache for a specific method.

`typescript
import { cached } from 'decorio';

class Example {
@cached sum(a: number, b: number): number {
return a + b;
}

// ⬇️ ttl
@cached(60 * 1000) async fetchData(id: string): Promise { ... }
}

const e = new Example();
e.sum(1, 2); // computes 3
e.sum(1, 2); // returns 3 from cache

// flush the cache for this method
cached.invalidate(e.sum);

const p1 = e.fetchData('foo');
await wait(30 * 1000); // wait 30 sec
const p2 = e.fetchData('foo'); // p2 === p1
await wait(30 * 1000); // wait 30 sec
const p3 = e.fetchData('foo'); // new promise returned
`

$3

Evaluates the original getter once per instance on the first access and then keeps returning the same value on subsequent reads, without re-running the getter.

`typescript
class User {
#seed = Math.random();

@lazy get checksum(): string {
// expensive work...
return hash(this.#seed);
}
}

const u = new User();
u.checksum; // computed once
u.checksum; // served from cache
`

⚙️ Concurrency decorators

$3

Prevent duplicate in-flight calls per argument list. If you call it again with the same args before it finishes, you get the same pending Promise.

`typescript
import { singleflight } from 'decorio';

class Example {
@singleflight async fetchData(id: string): Promise { ... }
}

const e = new Example();
const p1 = e.fetchData('foo');
const p2 = e.fetchData('foo'); // p2 === p1
`

$3

Debounce a method: wait for delayMs ms of "silence", then run only the last invocation. Every returned Promise resolves (or rejects) with that final run.

`typescript
import { debounced } from 'decorio';

class Searcher {
@debounced(300) async search(query: string): Promise> { ... }
}

const s = new Searcher();
s.search('a');
s.search('ab');
s.search('abc'); // only this one actually fires, after 300 ms
`

You can also cancel earlier runs by passing the built-in AbortSignal:

`typescript
import { debounced } from 'decorio';

class Fetcher {
@debounced(500) async fetchData(id: string): Promise