Class KeyedResolvSeq<VALUEType, KEYType, CTX>

Readonly Internalopts

onSet

• onSet(
      fn: (
          value: KeyedNgItem<
              KEYType,
              ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
              CTX,
          >,
      ) => void,
  ): UnregFn

  Registers a callback that fires when a new item is added to the collection.

  The callback is invoked after the item is created and stored. Multiple callbacks can be registered.

  Parameters

  • fn: (
        value: KeyedNgItem<
            KEYType,
            ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
            CTX,
        >,
    ) => void

    Callback function receiving the new item

  Returns UnregFn

  Unregister function to remove the callback

  Example

  const unregister = keyed.onSet((item) => {
    console.log('Added:', item.givenKey, item.value);
  });
  
  // Later: remove the callback
  unregister();
  Copy

onDelete

• onDelete(
      fn: (
          value: KeyedNgItem<
              KEYType,
              ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
              CTX,
          >,
      ) => void,
  ): UnregFn

  Registers a callback that fires when an item is deleted from the collection.

  The callback is invoked before the item is removed. This includes both explicit deletions and LRU evictions.

  Parameters

  • fn: (
        value: KeyedNgItem<
            KEYType,
            ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
            CTX,
        >,
    ) => void

    Callback function receiving the deleted item

  Returns UnregFn

  Unregister function to remove the callback

  Example

  const unregister = keyed.onDelete((item) => {
    console.log('Removed:', item.givenKey);
    item.value.cleanup?.(); // Perform cleanup if needed
  });
  Copy

setParam

• setParam(params: Partial<KeyedNgOptions<K, KeyedNgItem<K, V, CTX>, CTX>>): void

  Updates the LRU parameters of the underlying collection.

  Allows dynamic adjustment of caching behavior without recreating the entire collection.

  Parameters

  • params: Partial<KeyedNgOptions<K, KeyedNgItem<K, V, CTX>, CTX>>

    New parameters to apply (partial update)

  Returns void

  Example

  keyed.setParam({ lru: { max: 200 } });
  Copy

asyncGet

• asyncGet(
      key: () => Promise<KEYType>,
  ): Promise<ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>>

  Asynchronously gets or creates a value for a key resolved from a promise.

  Useful when the key itself needs to be computed asynchronously, such as from a database lookup or API call.

  Parameters

  • key: () => Promise<KEYType>

    Function returning a promise that resolves to the key

  Returns Promise<ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>>

  Promise resolving to the value

  Example

  const value = await keyed.asyncGet(async () => {
    const id = await fetchUserId();
    return id;
  });
  Copy

has

• has(keyOfFnKey: KEYType | (() => KEYType)): boolean

  Checks if a key exists in the collection.

  Does not create a new value if the key doesn't exist.

  Parameters

  • keyOfFnKey: KEYType | (() => KEYType)

    The key or function returning the key

  Returns boolean

  True if the key exists in the collection

  Example

  if (keyed.has('myKey')) {
    console.log('Key exists');
  }
  
  // With function
  if (keyed.has(() => computeKey())) {
    console.log('Computed key exists');
  }
  Copy

delete

• delete(key: KEYType): void

  Deletes an item from the collection.

  Triggers onDelete callbacks before removal. The item will need to be recreated if accessed again.

  Parameters

  • key: KEYType

    The key to delete

  Returns void

  Example

  keyed.delete('myKey');
  Copy

keys

• keys(): KEYType[]

  Returns all keys currently in the collection.

  Returns the original keys (givenKey), not the normalized string versions.

  Returns KEYType[]

  Array of all keys

  Example

  const keys = keyed.keys();
  console.log(keys); // ['key1', 'key2', 'key3']
  Copy

forEach

• forEach(
      fn: (
          v: KeyedNgItem<
              KEYType,
              ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
              CTX,
          >,
          idx: number,
      ) => void,
  ): void

  Iterates over all items in the collection.

  The callback receives each item and its index.

  Parameters

  • fn: (
        v: KeyedNgItem<
            KEYType,
            ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
            CTX,
        >,
        idx: number,
    ) => void

    Callback function receiving item and index

  Returns void

  Example

  keyed.forEach((item, idx) => {
    console.log(idx, item.givenKey, item.value);
  });
  Copy

entries

• entries(): Iterable<
      [
          KeyedNgItem<
              KEYType,
              ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
              CTX,
          >,
          number,
      ],
  >

  Returns an iterable of all items with their indices.

  Returns Iterable<
      [
          KeyedNgItem<
              KEYType,
              ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
              CTX,
          >,
          number,
      ],
  >

  Iterable of [item, index] pairs

  Example

  for (const [item, idx] of keyed.entries()) {
    console.log(idx, item.givenKey, item.value);
  }
  Copy

getItem

• getItem(
      key: KEYType,
      ctx?: CTX,
  ): KeyedNgItem<
      KEYType,
      ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
      CTX,
  >

  Gets or creates the full KeyedNgItem for a given key.

  Returns the complete item structure including key, value, and context. If the key doesn't exist, creates it using the factory function.

  Parameters

  • key: KEYType

    The key to get

  • Optionalctx: CTX

    Optional context override for this get operation

  Returns KeyedNgItem<
      KEYType,
      ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
      CTX,
  >

  The complete KeyedNgItem

  Example

  const item = keyed.getItem('myKey', { custom: 'context' });
  console.log(item.refKey, item.givenKey, item.value, item.ctx);
  Copy

get

• get(key: KEYType | (() => KEYType), ctx?: CTX): ResolveSeq

  Gets or creates a value for the given key.

  This is the primary method for accessing values. If the key doesn't exist, the factory function is called to create the value. Subsequent calls with the same key return the cached value.

  Parameters

  • key: KEYType | (() => KEYType)

    The key or function returning the key

  • Optionalctx: CTX

    Optional context override for this get operation

  Returns ResolveSeq

  The value associated with the key

  Example

  // Simple key
  const value1 = keyed.get('myKey');
  
  // With function
  const value2 = keyed.get(() => computeKey());
  
  // With custom context
  const value3 = keyed.get('myKey', { custom: 'context' });
  Copy

values

• values(): KeyedNgItem<
      KEYType,
      ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
      CTX,
  >[]

  Returns all items currently in the collection.

  Returns complete KeyedNgItem objects, not just the values.

  Returns KeyedNgItem<
      KEYType,
      ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>,
      CTX,
  >[]

  Array of all items

  Example

  const items = keyed.values();
  items.forEach(item => {
    console.log(item.givenKey, item.value);
  });
  Copy