ChildrenCache | path-scurry (original) (raw)

• path-scurry
• ChildrenCache

Class ChildrenCacheInternal

Hierarchy

• LRUCache<PathBase, Children>
  • ChildrenCache

Index

Constructors

constructor

• new ChildrenCache(maxSize?: number): ChildrenCache

• Parameters

  • maxSize: number = ...

Returns ChildrenCache

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

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 | PathBase | Children | BackgroundFetch<Children>)[], void, unknown>

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

clear

• clear(): void

• Returns void

delete

• delete(k: PathBase): boolean

• Returns boolean

dump

• dump(): [PathBase, Entry<Children>][]

• Returns [PathBase, Entry<Children>][]

entries

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

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

fetch

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

• Returns Promise<void | Children>

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

• Returns Promise<void | Children>

find

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

• Parameters

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

    * * (v: [Children](../types/Children.html), k: [PathBase](PathBase.html), self: LRUCache<[PathBase](PathBase.html), [Children](../types/Children.html), unknown\>): boolean  
             * #### Returns boolean  

  • Optional getOptions: GetOptions<PathBase, Children, unknown>

Returns undefined | Children

forEach

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

• Parameters

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

    * * (v: [Children](../types/Children.html), k: [PathBase](PathBase.html), self: LRUCache<[PathBase](PathBase.html), [Children](../types/Children.html), unknown\>): any  
             * #### Returns any  

  • Optional thisp: any

Returns void

get

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

• Returns undefined | Children

getRemainingTTL

• getRemainingTTL(key: PathBase): number

• Returns number

has

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

• Returns boolean

keys

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

• Returns Generator<PathBase, void, unknown>

load

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

• Returns void

peek

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

• Returns undefined | Children

pop

• pop(): undefined | Children

• Returns undefined | Children

purgeStale

• purgeStale(): boolean

• Returns boolean

rentries

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

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

rforEach

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

• Parameters

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

    * * (v: [Children](../types/Children.html), k: [PathBase](PathBase.html), self: LRUCache<[PathBase](PathBase.html), [Children](../types/Children.html), unknown\>): any  
             * #### Returns any  

  • Optional thisp: any

Returns void

rkeys

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

• Returns Generator<PathBase, void, unknown>

rvalues

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

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

set

• set(k: PathBase, v: undefined | Children | BackgroundFetch<Children>, setOptions?: SetOptions<PathBase, Children, unknown>): ChildrenCache

• Parameters

  • k: PathBase

  • v: undefined | Children | BackgroundFetch<Children>

  • Optional setOptions: SetOptions<PathBase, Children, unknown>

Returns ChildrenCache

values

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

• Returns Generator<undefined | Children | BackgroundFetch<Children>, 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>)[]