ResolveCache | path-scurry (original) (raw)

• path-scurry
• ResolveCache

Class ResolveCacheInternal

Hierarchy

• LRUCache<string, string>
  • ResolveCache

Index

Constructors

constructor

• new ResolveCache(): ResolveCache

• Returns ResolveCache

Properties

Private #private

#private: any

allowStale

allowStale: boolean

allowStaleOnFetchAbort

allowStaleOnFetchAbort: boolean

allowStaleOnFetchRejection

allowStaleOnFetchRejection: boolean

ignoreFetchAbort

ignoreFetchAbort: boolean

maxEntrySize

maxEntrySize: number

noDeleteOnFetchRejection

noDeleteOnFetchRejection: boolean

noDeleteOnStaleGet

noDeleteOnStaleGet: boolean

noDisposeOnSet

noDisposeOnSet: boolean

noUpdateTTL

noUpdateTTL: boolean

Optional sizeCalculation

sizeCalculation?: SizeCalculator<string, string>

ttl

ttl: number

ttlAutopurge

ttlAutopurge: boolean

ttlResolution

ttlResolution: number

updateAgeOnGet

updateAgeOnGet: boolean

updateAgeOnHas

updateAgeOnHas: boolean

Accessors

calculatedSize

• get calculatedSize(): number

• Returns number

dispose

• get dispose(): undefined | Disposer<K, V>

• Returns undefined | Disposer<K, V>

disposeAfter

• get disposeAfter(): undefined | Disposer<K, V>

• Returns undefined | Disposer<K, V>

fetchMethod

• get fetchMethod(): undefined | Fetcher<K, V, FC>

• Returns undefined | Fetcher<K, V, FC>

max

• get max(): number

• Returns number

maxSize

• get maxSize(): number

• Returns number

size

• get size(): number

• Returns number

Methods

[iterator]

• [iterator](): Generator<(undefined | string | BackgroundFetch<string>)[], void, unknown>

• Returns Generator<(undefined | string | BackgroundFetch<string>)[], void, unknown>

clear

• clear(): void

• Returns void

delete

• delete(k: string): boolean

• Parameters

  • k: string

Returns boolean

dump

• dump(): [string, Entry<string>][]

• Returns [string, Entry<string>][]

entries

• entries(): Generator<(undefined | string | BackgroundFetch<string>)[], void, unknown>

• Returns Generator<(undefined | string | BackgroundFetch<string>)[], void, unknown>

fetch

• fetch(k: string, fetchOptions: FetchOptions<string, string, unknown>): Promise<string | void>

• Parameters

  • k: string

  • fetchOptions: FetchOptions<string, string, unknown>

Returns Promise<string | void>

• fetch(k: string, fetchOptions?: FetchOptions<string, string, unknown>): Promise<string | void>

• Parameters

  • k: string

  • Optional fetchOptions: FetchOptions<string, string, unknown>

Returns Promise<string | void>

find

• find(fn: ((v: string, k: string, self: LRUCache<string, string, unknown>) => boolean), getOptions?: GetOptions<string, string, unknown>): undefined | string

• Parameters

  • fn: ((v: string, k: string, self: LRUCache<string, string, unknown>) => boolean)

    * * (v: string, k: string, self: LRUCache<string, string, unknown\>): boolean  
             * #### Parameters  
                         * ##### v: string  
                         * ##### k: string  
                         * ##### self: LRUCache<string, string, unknown\>  
             #### Returns boolean  

  • Optional getOptions: GetOptions<string, string, unknown>

Returns undefined | string

forEach

• forEach(fn: ((v: string, k: string, self: LRUCache<string, string, unknown>) => any), thisp?: any): void

• Parameters

  • fn: ((v: string, k: string, self: LRUCache<string, string, unknown>) => any)

    * * (v: string, k: string, self: LRUCache<string, string, unknown\>): any  
             * #### Parameters  
                         * ##### v: string  
                         * ##### k: string  
                         * ##### self: LRUCache<string, string, unknown\>  
             #### Returns any  

  • Optional thisp: any

Returns void

get

• get(k: string, getOptions?: GetOptions<string, string, unknown>): undefined | string

• Parameters

  • k: string

  • Optional getOptions: GetOptions<string, string, unknown>

Returns undefined | string

getRemainingTTL

• getRemainingTTL(key: string): number

• Parameters

  • key: string

Returns number

has

• has(k: string, hasOptions?: HasOptions<string, string, unknown>): boolean

• Parameters

  • k: string

  • Optional hasOptions: HasOptions<string, string, unknown>

Returns boolean

keys

• keys(): Generator<string, void, unknown>

• Returns Generator<string, void, unknown>

load

• load(arr: [string, Entry<string>][]): void

• Parameters

  • arr: [string, Entry<string>][]

Returns void

peek

• peek(k: string, peekOptions?: PeekOptions<string, string, unknown>): undefined | string

• Parameters

  • k: string

  • Optional peekOptions: PeekOptions<string, string, unknown>

Returns undefined | string

pop

• pop(): undefined | string

• Returns undefined | string

purgeStale

• purgeStale(): boolean

• Returns boolean

rentries

• rentries(): Generator<(undefined | string | BackgroundFetch<string>)[], void, unknown>

• Returns Generator<(undefined | string | BackgroundFetch<string>)[], void, unknown>

rforEach

• rforEach(fn: ((v: string, k: string, self: LRUCache<string, string, unknown>) => any), thisp?: any): void

• Parameters

  • fn: ((v: string, k: string, self: LRUCache<string, string, unknown>) => any)

    * * (v: string, k: string, self: LRUCache<string, string, unknown\>): any  
             * #### Parameters  
                         * ##### v: string  
                         * ##### k: string  
                         * ##### self: LRUCache<string, string, unknown\>  
             #### Returns any  

  • Optional thisp: any

Returns void

rkeys

• rkeys(): Generator<string, void, unknown>

• Returns Generator<string, void, unknown>

rvalues

• rvalues(): Generator<undefined | string | BackgroundFetch<string>, void, unknown>

• Returns Generator<undefined | string | BackgroundFetch<string>, void, unknown>

set

• set(k: string, v: undefined | string | BackgroundFetch<string>, setOptions?: SetOptions<string, string, unknown>): ResolveCache

• Parameters

  • k: string

  • v: undefined | string | BackgroundFetch<string>

  • Optional setOptions: SetOptions<string, string, unknown>

Returns ResolveCache

values

• values(): Generator<undefined | string | BackgroundFetch<string>, void, unknown>

• Returns Generator<undefined | string | BackgroundFetch<string>, void, unknown>

Static unsafeExposeInternals

• unsafeExposeInternals<K, V, FC>(c: LRUCache<K, V, FC>): {
  backgroundFetch: ((k: K, index: undefined | number, options: FetchOptions<K, V, FC>, context: any) => BackgroundFetch<V>);
  free: StackLike;
  head: Index;
  indexes: ((options?: {
  allowStale: boolean;
  }) => Generator<Index, void, unknown>);
  isBackgroundFetch: ((p: any) => boolean);
  isStale: ((index: undefined | number) => boolean);
  keyList: (undefined | K)[];
  keyMap: Map<K, number>;
  moveToTail: ((index: number) => void);
  next: NumberArray;
  prev: NumberArray;
  rindexes: ((options?: {
  allowStale: boolean;
  }) => Generator<Index, void, unknown>);
  sizes: undefined | ZeroArray;
  starts: undefined | ZeroArray;
  tail: Index;
  ttls: undefined | ZeroArray;
  valList: (undefined | V | BackgroundFetch<V>)[];
  }
• Internal

Type Parameters

• K extends {}

• V extends {}

• FC extends unknown = unknown

Parameters

• c: LRUCache<K, V, FC>

Returns {

backgroundFetch: ((k: K, index: undefined | number, options: FetchOptions<K, V, FC>, context: any) => BackgroundFetch<V>);
free: StackLike;
head: Index;
indexes: ((options?: {
allowStale: boolean;
}) => Generator<Index, void, unknown>);
isBackgroundFetch: ((p: any) => boolean);
isStale: ((index: undefined | number) => boolean);
keyList: (undefined | K)[];
keyMap: Map<K, number>;
moveToTail: ((index: number) => void);
next: NumberArray;
prev: NumberArray;
rindexes: ((options?: {
allowStale: boolean;
}) => Generator<Index, void, unknown>);
sizes: undefined | ZeroArray;
starts: undefined | ZeroArray;
tail: Index;
ttls: undefined | ZeroArray;
valList: (undefined | V | BackgroundFetch<V>)[];
}

• backgroundFetch: ((k: K, index: undefined | number, options: FetchOptions<K, V, FC>, context: any) => BackgroundFetch<V>)

  * * (k: K, index: undefined | number, options: FetchOptions<K, V, FC\>, context: any): BackgroundFetch<V\>  
           * #### Parameters  
                       * ##### k: K  
                       * ##### index: undefined | number  
                       * ##### options: FetchOptions<K, V, FC\>  
                       * ##### context: any  
           #### Returns BackgroundFetch<V\>  

• free: StackLike

• Readonly head: Index

• indexes: ((options?: {

allowStale: boolean;
}) => Generator<Index, void, unknown>)
* * (options?: {
allowStale: boolean;
}): Generator<Index, void, unknown>
* #### Parameters
* ##### Optional options: {
allowStale: boolean;
}
* ##### allowStale: boolean
#### Returns Generator<Index, void, unknown>

• isBackgroundFetch: ((p: any) => boolean)

  * * (p: any): boolean  
           * #### Parameters  
                       * ##### p: any  
           #### Returns boolean  

• isStale: ((index: undefined | number) => boolean)

  * * (index: undefined | number): boolean  
           * #### Parameters  
                       * ##### index: undefined | number  
           #### Returns boolean  

• keyList: (undefined | K)[]

• keyMap: Map<K, number>

• moveToTail: ((index: number) => void)

  * * (index: number): void  
           * #### Parameters  
                       * ##### index: number  
           #### Returns void  

• next: NumberArray

• prev: NumberArray

• rindexes: ((options?: {

allowStale: boolean;
}) => Generator<Index, void, unknown>)
* * (options?: {
allowStale: boolean;
}): Generator<Index, void, unknown>
* #### Parameters
* ##### Optional options: {
allowStale: boolean;
}
* ##### allowStale: boolean
#### Returns Generator<Index, void, unknown>

• sizes: undefined | ZeroArray

• starts: undefined | ZeroArray

• Readonly tail: Index

• ttls: undefined | ZeroArray

• valList: (undefined | V | BackgroundFetch<V>)[]