@x-oasis/integer-buffer-set 0.1.18 → 0.1.20

package/README.md

@@ -16,4 +16,26 @@ import IntegerBufferSet from '@x-oasis/integer-buffer-set'
 
 ```bash
 $ pnpm test
-```
+```
+
+## Usage
+
+## Philosophy
+
+Basically, we only compare index value, such as 
+
+create a `onTheFlyIndices` as a slave buffer. theoretically, at most buffer size's new 
+item could occupy a position.
+
+`IndexExtractor` is the key point of design.
+if you do not delete/reorder an an array, `indexExtractor` is useless.
+
+## bad case 
+
+when getIndices.. 
+
+`positionToMetaIndices` may used as a supplement. but when has multiple buffer. index refer to meta may changed to other buffer..
+
+const data = [0, 1, 2, 3, 4, 5] only reuse `m % 3 === 0`, but when an item is deleted.. 
+all these index after delete index value will be invalid, because `m % 2 === 0` could not be reused.
+

package/dist/index.d.ts

@@ -1,33 +1,71 @@
 import Heap from '@x-oasis/heap';
-declare type HeapItem = {
-    position: number;
-    value: number;
-};
-declare class IntegerBufferSet {
+import { HeapItem, SafeRange, IntegerBufferSetProps, MetaToIndexMap, MetaToPositionMap } from './types';
+export declare const defaultBufferSize = 10;
+declare class IntegerBufferSet<Meta = any> {
     private _size;
-    private _valueToPositionMap;
+    private _name;
+    private _bufferSize;
+    private _indexToMetaMap;
+    private _metaToPositionMap;
+    private _positionToMetaList;
+    private _metaToIndexMap;
     private _smallValues;
     private _largeValues;
-    constructor();
+    private _metaExtractor;
+    private _indexExtractor;
+    private _onTheFlyIndices;
+    private _isOnTheFlyFull;
+    private _isOnTheFlyFullReturnHook;
+    private _loopMS;
+    private _lastUpdatedMS;
+    constructor(props?: IntegerBufferSetProps<Meta>);
     getSize(): number;
-    get indices(): any[];
-    getValuePosition(value: number): null | number;
-    getNewPositionForValue(value: number): number;
+    get bufferSize(): number;
+    setIsOnTheFlyFull(val: any): void;
+    get isBufferFull(): boolean;
+    getOnTheFlyUncriticalPosition(safeRange: SafeRange): number;
+    initialize(): {
+        smallValues: Heap<any>;
+        largeValues: Heap<any>;
+        valueToPositionObject: {};
+    };
+    getIndexMeta(index: number): Meta;
+    getMetaIndex(meta: Meta): number;
+    setMetaIndex(meta: Meta, index: number): false | MetaToIndexMap<Meta>;
+    deleteMetaIndex(meta: Meta): boolean;
+    replaceMetaToIndexMap(newMetaToIndexMap: MetaToIndexMap<Meta>): false | MetaToIndexMap<Meta>;
+    getIndexPosition(index: number): undefined | number;
+    getNewPositionForIndex(index: number): number;
     getMinValue(): number;
     getMaxValue(): number;
-    replaceFurthestValuePosition(lowValue: number, highValue: number, newValue: number, useMinValueFn?: (options: {
-        safeRange: {
-            lowValue: number;
-            highValue: number;
-        };
-        bufferSetRange: {
-            maxValue: number;
-            minValue: number;
-        };
-        currentIndex: number;
-    }) => boolean): null | number;
+    setValuePosition(value: number, position: number): void;
+    findPositionMeta(position: number): Meta;
+    rebuildHeapsWithMeta(metaToPositionMap: MetaToPositionMap<Meta>): void;
+    setPositionIndex(position: number, index: number): boolean;
+    getMetaPosition(meta: Meta): number;
+    replacePositionInFliedIndices(newIndex: number, safeRange: SafeRange): number;
+    getFliedPosition(newIndex: number, safeRange: SafeRange): any;
+    getPosition(newIndex: number, safeRange?: SafeRange): any;
+    replaceFurthestIndexPosition(newIndex: number, safeRange?: {
+        startIndex: number;
+        endIndex: number;
+    }): any;
+    _replaceFurthestIndexPosition(newIndex: number, safeRange?: {
+        startIndex: number;
+        endIndex: number;
+    }): any;
+    shuffle(): any[];
+    getIndices(): any[];
     _pushToHeaps(position: number, value: number): void;
+    _setMetaPosition(meta: Meta, position: number): void;
+    _setMetaIndex(meta: Meta, index: number): boolean;
+    readyToStartNextLoop(): void;
+    prepare(): void;
     _cleanHeaps(): void;
+    rebuildHeapsWithValues(arr: Array<{
+        position: number;
+        value: number;
+    }>): void;
     _recreateHeaps(): void;
     _cleanHeap(heap: Heap<HeapItem>): void;
     _smallerComparator(lhs: HeapItem, rhs: HeapItem): boolean;