Class KeyedResolvOnce<T, K, CTX, PT>

Keyed collection of ResolveOnce instances.

Manages a map of ResolveOnce instances indexed by keys, with optional LRU caching. Each key gets its own ResolveOnce instance that can be accessed and manipulated independently. Values can optionally have a reset() method for cleanup on deletion.

Example

const cache = new KeyedResolvOnce<number, string>();

// Each key gets its own ResolveOnce
const result1 = cache.get('key1').once(() => expensiveCalc1());
const result2 = cache.get('key2').once(() => expensiveCalc2());

// Delete specific key
cache.delete('key1');

// Iterate over all resolved entries
cache.forEach((item) => {
  console.log(item.key, item.value.Ok);
});

Example

// With custom key type and context
interface UserKey { org: string; id: string; }
interface UserContext { apiKey: string; }

const users = new KeyedResolvOnce<User, UserKey, UserContext>({
  key2string: (key) => `${key.org}:${key.id}`,
  ctx: { apiKey: 'default' },
  lru: { max: 100 }
});

const user = users.get({ org: 'acme', id: '123' })
  .once(({ givenKey, ctx }) => fetchUser(givenKey, ctx));

Type Parameters

T extends WithOptionalReset<PT>
The return type of the ResolveOnce instances (must include optional reset)
K = string
The key type (defaults to string)
CTX extends NonNullable<object> = object
Optional context type (defaults to empty object)
PT = T
Plain type of T without reset (for internal use)

Implements

Omit<
    KeyedIf<
        KeyedNgItem<K, ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>, CTX>,
        ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>,
        K,
        CTX,
    >,
    "entries" | "forEach" | "onSet" | "onDelete" | "values" | "setParam",
>

Index

Constructors

constructor

new KeyedResolvOnce<
    T extends { reset?: () => void },
    K = string,
    CTX extends object = object,
    PT = T,
>(
    kp?: Partial<AddKeyedParam<K, T, CTX>>,
): KeyedResolvOnce<T, K, CTX, PT>
Creates a new KeyedResolvOnce instance.
Type Parameters
- T extends { reset?: () => void }
- K = string
- CTX extends object = object
- PT = T
Parameters
- kp: Partial<AddKeyedParam<K, T, CTX>> = {}
  Configuration options (key2string, ctx, lru)
Returns KeyedResolvOnce<T, K, CTX, PT>
- Defined in resolve-once.ts:822

Properties

`Readonly` `Internal`_keyed

_keyed: KeyedNg<
    K,
    ResolveOnce<WithOptionalReset<T>, KeyedNgItemWithoutValue<K, CTX>>,
    CTX,
>

Methods

keys

keys(): K[]
Returns all keys currently in the collection.

Returns K[]
Array of all keys
Implementation of Omit.keys
- Defined in resolve-once.ts:848

values

values(): KeyedResolveOnceItem<K, T, CTX>[]
Returns all resolved items with their values wrapped in Result.

Only includes items that have been resolved (ready state). Each item contains the key, Result-wrapped value, and full item metadata.

Returns KeyedResolveOnceItem<K, T, CTX>[]
Array of all resolved items
Example
```
const items = cache.values();
items.forEach(({ key, value }) => {
  if (value.Ok) {
    console.log(key, value.unwrap());
  } else {
    console.error(key, value.unwrapErr());
  }
});
```
- Defined in resolve-once.ts:872

onSet

onSet(
    fn: (
        key: K,
        value: ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>,
    ) => void,
): UnregFn
Registers a callback that fires when a new ResolveOnce instance is created.
Parameters
- fn: (key: K, value: ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>) => void
  Callback receiving the key and ResolveOnce instance
Returns UnregFn
Unregister function
- Defined in resolve-once.ts:889

onDelete

onDelete(
    fn: (
        key: K,
        value: ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>,
    ) => void,
): UnregFn
Registers a callback that fires when a ResolveOnce instance is deleted.
Parameters
- fn: (key: K, value: ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>) => void
  Callback receiving the key and ResolveOnce instance
Returns UnregFn
Unregister function
- Defined in resolve-once.ts:901

setParam

setParam(params: Partial<AddKeyedParam<K, ResolveOnce<T, CTX>, CTX>>): void
Updates the LRU parameters dynamically.
Parameters
- params: Partial<AddKeyedParam<K, ResolveOnce<T, CTX>, CTX>>
  New LRU parameters
Returns void
- Defined in resolve-once.ts:912

asyncGet

asyncGet(
key: () => Promise<K>,
): Promise<ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>>
Asynchronously gets or creates a ResolveOnce for a key resolved from a promise.
Parameters
- key: () => Promise<K>
  Function returning a promise that resolves to the key
Returns Promise<ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>>
Promise resolving to the ResolveOnce instance
Implementation of Omit.asyncGet
- Defined in resolve-once.ts:922

get

get(
key: K | (() => K),
ctx?: CTX,
): ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>
Gets or creates a ResolveOnce instance for the given key.

This is the primary method for accessing ResolveOnce instances. Each unique key gets its own instance that persists across calls.
Parameters
- key: K | (() => K)
  The key or function returning the key
- Optionalctx: CTX
  Optional context override for this operation
Returns ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>
The ResolveOnce instance for this key
Example
```
const result = cache.get('myKey').once(({ refKey, givenKey, ctx }) => {
  return computeValue(givenKey, ctx);
});
```
Implementation of Omit.get
- Defined in resolve-once.ts:943

getItem

getItem(
key: K,
ctx?: CTX,
): KeyedNgItem<K, ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>, CTX>
Gets or creates the complete KeyedNgItem for a key.

Useful when you need access to the full item structure including metadata.
Parameters
- key: K
  The key to get
- Optionalctx: CTX
  Optional context override
Returns KeyedNgItem<K, ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>, CTX>
The complete KeyedNgItem
Implementation of Omit.getItem
- Defined in resolve-once.ts:959

has

has(key: K | (() => K)): boolean
Checks if a key exists in the collection.
Parameters
- key: K | (() => K)
  The key or function returning the key
Returns boolean
True if the key exists
Implementation of Omit.has
- Defined in resolve-once.ts:969

delete

delete(key: K): void
Deletes an entry from the collection.

Triggers onDelete callbacks before removal.
Parameters
- key: K
  The key to delete
Returns void
Implementation of Omit.delete
- Defined in resolve-once.ts:980

unget

unget(key: K): void
Resets and removes an entry from the collection.

Calls the optional reset() method on the value before deletion, allowing for cleanup operations.
Parameters
- key: K
  The key to reset and delete
Returns void
- Defined in resolve-once.ts:992

reset

reset(): void
Resets all entries by calling their optional reset() methods.

Does not remove entries from the collection, only resets their state. Useful for cleanup without losing the collection structure.

Returns void
- Defined in resolve-once.ts:1004

forEach

forEach(fn: (ki: KeyItem<K, T>, idx: number) => void): void
Iterates over all completed entries, yielding key-result pairs.

Only yields entries that have been resolved (ready state). Values are wrapped in Result to distinguish success from error.
Parameters
- fn: (ki: KeyItem<K, T>, idx: number) => void
  Callback receiving KeyItem and index
Returns void
Example
```
cache.forEach((item, idx) => {
  console.log(idx, item.key);
  if (item.value.Ok) {
    console.log('Success:', item.value.unwrap());
  } else {
    console.error('Error:', item.value.unwrapErr());
  }
});
```
- Defined in resolve-once.ts:1030

entries

entries(): Iterable<KeyItem<K, T>>
Returns an iterable of all completed entries.

Only yields entries that have been resolved. Values are wrapped in Result.

Returns Iterable<KeyItem<K, T>>
Iterable of KeyItem entries
Example
```
for (const item of cache.entries()) {
  console.log(item.key, item.value.Ok);
}
```
- Defined in resolve-once.ts:1059

Class KeyedResolvOnce<T, K, CTX, PT>

Example

Example

Type Parameters

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Type Parameters

Parameters

Returns KeyedResolvOnce<T, K, CTX, PT>

Properties

Readonly Internal_keyed

Methods

keys

Returns K[]

values

Returns KeyedResolveOnceItem<K, T, CTX>[]

Example

onSet

Parameters

Returns UnregFn

onDelete

Parameters

Returns UnregFn

setParam

Parameters

Returns void

asyncGet

Parameters

Returns Promise<ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>>

get

Parameters

Returns ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>

Example

getItem

Parameters

Returns KeyedNgItem<K, ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>, CTX>

has

Parameters

Returns boolean

delete

Parameters

Returns void

unget

Parameters

Returns void

reset

Returns void

forEach

Parameters

Returns void

Example

entries

Returns Iterable<KeyItem<K, T>>

Example

Settings

On This Page

`Readonly` `Internal`_keyed