Class Cache<Type, Ready>

constructor

• new Cache<Type, Ready>(args): Cache<Type, Ready>

• Type Parameters

  • Type

  • Ready extends boolean = false

  Parameters

  • args: NewCacheArgs<Type, Ready>

  Returns Cache<Type, Ready>

[toStringTag]

max_size

query

Readonly ready

Readonly size

Readonly storeQuery

[iterator]

• [iterator](): IterableIterator<[Key, Type]>

• Returns IterableIterator<[Key, Type]>

clear

• clear(): void

• Returns void

delete

• delete(key, include_store?): Promise<boolean>

• Parameters

  • key: Key

  • Optional include_store: boolean

    delete key in store

  Returns Promise<boolean>

  deleted_from_map || (include_store && deleted_from_store)

entries

• entries(): IterableIterator<[Key, Type]>

• Returns IterableIterator<[Key, Type]>

flushToStore

• flushToStore(): Promise<void>

• Insert all items into the store, then clear the cache.

  Returns Promise<void>

forEach

• forEach(callbackfn, thisArg?): void

• Parameters

  • callbackfn: ((value, key, map) => void)

    • • (value, key, map): void

      • Parameters

        • value: Type

        • key: Key

        • map: Map<Key, Type>

        Returns void

  • Optional thisArg: any

  Returns void

get

• get(key, include_store?): Promise<NullableCacheValue<Type>>

• Get value by key.

  Parameters

  • key: Key

  • Optional include_store: boolean

    if key is not found in the cache, then search the store. If found in the store, automatically load it into the cache.

  Returns Promise<NullableCacheValue<Type>>

getMeta

• getMeta(key): Promise<undefined | Metadata>

• Get key metadata. Only works if key has already been stored at some point.

  Parameters

  • key: Key

  Returns Promise<undefined | Metadata>

has

• has(key, include_store?): boolean

• Parameters

  • key: Key

  • Optional include_store: boolean

    if key is not found in the cache, then search the store.

  Returns boolean

keys

• keys(): IterableIterator<Key>

• Returns IterableIterator<Key>

loadFromStore

• loadFromStore(): Promise<void>

• Load items from the store, in reverse chronological order, limited by max_size.

  Returns Promise<void>

save

• save(keys): Promise<void>

• Insert items into the store.

  Parameters

  • keys: "all" | Key[]

  Returns Promise<void>

set

• set(key, value): Promise<Key>

• Adds a new element with a specified key and value to the Cache. If an element with the same key already exists, the element will be updated. If the insertion of the element makes the cache larger than max_size, the first pushed element is flushed to store. If a string key is passed, a new Key instance will be generated.

  Parameters

  • key: string | Key

  • value: Type

  Returns Promise<Key>

values

• values(): IterableIterator<Type>

• Returns IterableIterator<Type>

Static start

• start<Type>(args): Promise<Cache<Type, true>>

• Type Parameters

  • Type

  Parameters

  • args: {
        store: {
            clean?: boolean;
            dest: string;
        };
    } & Omit<NewCacheArgs<Type, boolean>, "store">

  Returns Promise<Cache<Type, true>>