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

package/src/index.ts

@@ -15,6 +15,7 @@ import {
 
 const defaultMetaExtractor = (value) => value;
 export const defaultBufferSize = 10;
+const thresholdNumber = Number.MAX_SAFE_INTEGER - 100000;
 
 // !!!!! should do meta validation...meta should has an index...
 // value: original data `index` value
@@ -34,10 +35,8 @@ export const defaultBufferSize = 10;
 // the set.
 // feature: add / delete / update item will also in consider..
 class IntegerBufferSet<Meta = any> {
-  private _size: number;
   private _name: string;
   private _bufferSize: number;
-  // private _positionToValueObject: ValueToPositionObject;
 
   private _indexToMetaMap: IndexToMetaMap<Meta>;
   private _metaToPositionMap: MetaToPositionMap<Meta>;
@@ -68,7 +67,6 @@ class IntegerBufferSet<Meta = any> {
     this._indexExtractor = indexExtractor;
 
     this._name = name;
-    // this._positionToValueObject = {};
 
     /**
      * this._indexToMetaMap is used to find the prev meta when finding a position for index.
@@ -79,7 +77,6 @@ class IntegerBufferSet<Meta = any> {
     this._metaToIndexMap = new Map();
     this._onTheFlyIndices = [];
 
-    this._size = 0;
     this._bufferSize = bufferSize;
 
     this._smallValues = new Heap([], this._smallerComparator);
@@ -87,9 +84,6 @@ class IntegerBufferSet<Meta = any> {
 
     this.getNewPositionForIndex = this.getNewPositionForIndex.bind(this);
     this.getIndexPosition = this.getIndexPosition.bind(this);
-    this.getSize = this.getSize.bind(this);
-    this.replacePositionInFliedIndices =
-      this.replacePositionInFliedIndices.bind(this);
     this.replaceFurthestIndexPosition =
       this.replaceFurthestIndexPosition.bind(this);
     this._isOnTheFlyFullReturnHook = returnHook(
@@ -100,21 +94,28 @@ class IntegerBufferSet<Meta = any> {
     this._lastUpdatedMS = this._loopMS;
   }
 
-  getSize() {
-    return this._size;
-  }
-
   get bufferSize() {
     return this._bufferSize;
   }
 
+  isThresholdMeta(meta) {
+    if (typeof meta === 'number' && meta > thresholdNumber) return true;
+    return false;
+  }
+
   setIsOnTheFlyFull(val: any) {
     if (val != null) {
-      const data = this._onTheFlyIndices.filter((v) => v);
+      const data = this._onTheFlyIndices.filter((v) => v != null);
       this._isOnTheFlyFull = data.length === this._bufferSize;
+      // console.log('fly ', this._isOnTheFlyFull, data.length, this._bufferSize);
     }
   }
 
+  resetOnTheFlies() {
+    this._isOnTheFlyFull = false;
+    this._onTheFlyIndices = [];
+  }
+
   get isBufferFull() {
     return this._positionToMetaList.length >= this._bufferSize;
   }
@@ -123,7 +124,7 @@ class IntegerBufferSet<Meta = any> {
     const { startIndex, endIndex } = safeRange;
     for (let idx = 0; idx < this._onTheFlyIndices.length; idx++) {
       const meta = this._onTheFlyIndices[idx];
-      const metaIndex = this._metaToIndexMap.get(meta);
+      const metaIndex = this.getMetaIndex(meta);
       if (!isClamped(startIndex, metaIndex, endIndex)) {
         return idx;
       }
@@ -135,15 +136,17 @@ class IntegerBufferSet<Meta = any> {
     return {
       smallValues: new Heap([], this._smallerComparator),
       largeValues: new Heap([], this._greaterComparator),
-      valueToPositionObject: {},
     };
   }
 
   getIndexMeta(index: number) {
+    if (index == null || index < 0) return null;
     return this._metaExtractor(index);
   }
 
   getMetaIndex(meta: Meta) {
+    if (meta == null) return -1;
+    if (this.isThresholdMeta(meta)) return -1;
     if (this._indexExtractor) return this._indexExtractor(meta);
     return this._metaToIndexMap.get(meta);
   }
@@ -193,140 +196,19 @@ class IntegerBufferSet<Meta = any> {
     return this._largeValues.peek()?.value;
   }
 
-  /**
-   * values actually is the position of original data.
-   */
-  setValuePosition(value: number, position: number) {}
-
-  findPositionMeta(position: number) {
-    for (const [meta, pos] of this._metaToPositionMap) {
-      if (pos === position) return meta;
-    }
-    return null;
-  }
-
-  rebuildHeapsWithMeta(metaToPositionMap: MetaToPositionMap<Meta>) {
-    const { smallValues, largeValues } = this.initialize();
-
-    for (const [meta, position] of metaToPositionMap) {
-      const index = this.getMetaIndex(meta);
-      const token = { index, position };
-      smallValues.push(token);
-      largeValues.push(token);
-    }
-
-    this._smallValues = smallValues;
-    this._largeValues = largeValues;
-  }
-
-  /**
-   *
-   * @param position
-   * @param value
-   *
-   *
-   */
-  setPositionIndex(position: number, index: number) {
-    const meta = this._metaExtractor(index);
-    const originalPosition = this._metaToPositionMap.get(meta);
-
-    // current index has a position
-    if (originalPosition !== undefined) {
-      if (originalPosition === position) return true;
-      this.deleteMetaIndex(meta);
-    }
-
-    const metaToReplace = this.findPositionMeta(position);
-    if (metaToReplace) this._metaToPositionMap.delete(metaToReplace);
-    this._metaToPositionMap.set(meta, position);
-
-    this.rebuildHeapsWithMeta(this._metaToPositionMap);
-    return true;
-  }
-
-  getMetaPosition(meta: Meta) {
-    return this._metaToPositionMap.get(meta);
-  }
-
-  // performRangeUpdate(
-  //   startIndex: number,
-  //   endIndex: number,
-  //   safeRange: {
-  //     startIndex: number;
-  //     endIndex: number;
-  //   }
-  // ) {
-  //   const _start = Math.max(startIndex, safeRange.startIndex);
-  //   const _end = Math.min(endIndex, safeRange.endIndex);
-  //   const primaryMetaList = [];
-  //   const secondaryMetaList = [];
-  //   const locationStartIndex = startIndex;
-  //   const targetIndices = new Array(this._bufferSize);
-
-  //   const _valueToPositionObject = {};
-  //   const _positionToValueObject = {};
-
-  //   const _valueToMetaObject = {};
-  //   const _metaToIndexMap = new Map();
-
-  //   for (let value = startIndex; value <= endIndex; value++) {
-  //     const meta = this._metaExtractor(value);
-  //     if (meta) {
-  //       const _i = value - locationStartIndex;
-  //       if (isClamped(value, safeRange.startIndex, safeRange.endIndex)) {
-  //         primaryMetaList[_i] = meta;
-  //         const targetIndex = this.getMetaPosition(meta);
-  //         if (isNumber(targetIndex)) {
-  //           targetIndices[targetIndex] = value;
-  //           _valueToPositionObject[value] = targetIndex;
-  //           _valueToMetaObject[value] = meta;
-  //           _metaToIndexMap.set(meta, value);
-  //           _positionToValueObject[targetIndex] = value;
-  //         }
-  //       } else {
-  //         secondaryMetaList[_i] = meta;
-  //       }
-  //     }
-  //   }
-
-  // for (let idx = _start; idx <= _end; idx++) {
-  //   const meta = this._metaExtractor(idx);
-  //   if (_metaToIndexMap.get(meta) !== undefined) continue;
-  //   let p;
-  //   while (
-  //     (p =
-  //       targetIndices[
-  //         this.resolvePosition(safeRange.startIndex, safeRange.endIndex, idx)
-  //       ]) === undefined
-  //   ) {
-  //     targetIndices[p] = idx;
-  //   }
-  // }
-  // }
-
-  replacePositionInFliedIndices(newIndex: number, safeRange: SafeRange) {
-    const { startIndex, endIndex } = safeRange;
-
+  getFliedPosition(newIndex: number, safeRange: SafeRange) {
     if (this._isOnTheFlyFull) {
       // newIndex is not critical index, do nothing
-      if (!isClamped(startIndex, newIndex, endIndex)) {
-        return null;
+      if (
+        safeRange &&
+        isClamped(safeRange.startIndex, newIndex, safeRange.endIndex)
+      ) {
+        return this.getOnTheFlyUncriticalPosition(safeRange);
       }
       // if `newIndex` is critical index, replace an un-committed
       // index value from _onTheFlyIndices.
-      const pos = this.getOnTheFlyUncriticalPosition(safeRange);
-      if (pos != null) return pos;
-    }
-    return null;
-  }
-
-  getFliedPosition(newIndex: number, safeRange: SafeRange) {
-    const pos = this.replacePositionInFliedIndices(newIndex, safeRange);
-    if (pos != null) {
-      const meta = this.getIndexMeta(newIndex);
-      this._onTheFlyIndices[pos] = meta;
-      this._setMetaIndex(meta, newIndex);
-      return this._isOnTheFlyFullReturnHook(pos);
+      // const pos = this.getOnTheFlyUncriticalPosition(safeRange);
+      // if (pos != null) return pos;
     }
     return null;
   }
@@ -343,74 +225,73 @@ class IntegerBufferSet<Meta = any> {
   getPosition(newIndex: number, safeRange?: SafeRange) {
     this.prepare();
     const meta = this.getIndexMeta(newIndex);
-    const prevMetaPosition = this._metaToPositionMap.get(meta);
-
-    if (prevMetaPosition !== undefined) {
-      const onTheFlyPositionMeta = this._onTheFlyIndices[prevMetaPosition];
-      // the occupied meta should change position
-      if (onTheFlyPositionMeta) {
-        // such as place item 11 twice...
-        if (onTheFlyPositionMeta === meta) {
-          return prevMetaPosition;
-        }
-        let positionToReplace = this._replaceFurthestIndexPosition(
-          newIndex,
-          safeRange
-        );
-        if (this._isOnTheFlyFull)
-          return this.getFliedPosition(newIndex, safeRange);
-
-        while (this._onTheFlyIndices[positionToReplace]) {
-          positionToReplace = this._replaceFurthestIndexPosition(
-            newIndex,
-            safeRange
-          );
-        }
-
-        if (positionToReplace != null) {
-          this._setMetaIndex(meta, newIndex);
-          this._onTheFlyIndices[positionToReplace] = onTheFlyPositionMeta;
-          return this._isOnTheFlyFullReturnHook(positionToReplace);
-        }
-      }
-      this._onTheFlyIndices[prevMetaPosition] = meta;
-      return this._isOnTheFlyFullReturnHook(prevMetaPosition);
+    const metaPosition = this._metaToPositionMap.get(meta);
+    let position, indexMeta;
+
+    // if (this._name === 'normal_goods')
+    //   console.log(
+    //     'getPosition ',
+    //     newIndex,
+    //     !this.isBufferFull,
+    //     this._isOnTheFlyFull,
+    //     this._onTheFlyIndices.slice(),
+    //     this._indexToMetaMap.get(newIndex),
+    //     this._metaToPositionMap.get(this._indexToMetaMap.get(newIndex))
+    //   );
+
+    if (metaPosition !== undefined) {
+      position = this.commitPosition({
+        newIndex,
+        meta,
+        safeRange,
+        position: metaPosition,
+      });
+    } else if (!this.isBufferFull) {
+      /** placed on new buffered position */
+      position = this.getNewPositionForIndex(newIndex);
+    } else if (this._isOnTheFlyFull) {
+      position = this.getFliedPosition(newIndex, safeRange);
+    } else if (
+      (indexMeta = this._indexToMetaMap.get(newIndex)) &&
+      this._metaToPositionMap.get(indexMeta)
+    ) {
+      /**
+      Index has already been stored, but we cant use its old position directly...
+        1：index -> meta, meta may be reused later
+        2: temp use index -> meta -> position, this issue should exist for follows...
+     */
+      position = this.commitPosition({
+        newIndex,
+        meta,
+        safeRange,
+        position: this._metaToPositionMap.get(indexMeta),
+      });
+    } else {
+      this._cleanHeaps();
+      // console.log('commeit ---')
+      position = this.commitPosition({
+        newIndex,
+        meta,
+        safeRange,
+        position: this._replaceFurthestIndexPosition(newIndex, safeRange),
+      });
     }
 
-    // placed on new buffered position
-    if (!this.isBufferFull)
-      return this._isOnTheFlyFullReturnHook(
-        this.getNewPositionForIndex(newIndex)
-      );
-
-    // console.log('this. fly ', this._isOnTheFlyFull)
-    if (this._isOnTheFlyFull) return this.getFliedPosition(newIndex, safeRange);
+    // console.log('position ', position)
 
-    let positionToReplace;
-    const prevIndexMeta = this._indexToMetaMap.get(newIndex);
-    // console.log('this. is ', this.isBufferFull, prevIndexMeta);
+    if (position != null) {
+      this._onTheFlyIndices[position] = meta;
+      this._setMetaIndex(meta, newIndex);
+      this._metaToPositionMap.set(meta, position);
 
-    // Index has already been stored, but we cant use its old position directly...
-    // 1：index -> meta, meta may be reused later
+      // this._setMetaPosition(meta, position);
+      // should not push to heap, pop only
+      // this._pushToHeaps(position, newIndex)
 
-    // 2: temp use index -> meta -> position, this issue should exist for follows...
-    if (!prevIndexMeta) {
-      this._cleanHeaps();
-      positionToReplace = this._replaceFurthestIndexPosition(
-        newIndex,
-        safeRange
-      );
-    } else {
-      positionToReplace = this._metaToPositionMap.get(prevIndexMeta);
+      return this._isOnTheFlyFullReturnHook(position);
     }
 
-    this._onTheFlyIndices[positionToReplace] = meta;
-    this._setMetaIndex(meta, newIndex);
-    this._setMetaPosition(meta, positionToReplace);
-    // should not push to heap, pop only
-    // this._pushToHeaps(positionToReplace, newIndex)
-
-    return this._isOnTheFlyFullReturnHook(positionToReplace);
+    return null;
   }
 
   replaceFurthestIndexPosition(
@@ -442,11 +323,19 @@ class IntegerBufferSet<Meta = any> {
       );
     }
 
+    let indexToReplace;
+
     const minValue = this._smallValues.peek()!.value;
     const maxValue = this._largeValues.peek()!.value;
 
-    // console.log('mxa ', maxValue, minValue);
-    let indexToReplace;
+    // console.log('mathc ', maxValue, maxValue > thresholdNumber)
+    if (maxValue > thresholdNumber) {
+      indexToReplace = maxValue;
+      this._largeValues.pop();
+      const replacedMeta = this._indexToMetaMap.get(indexToReplace);
+      const position = this._metaToPositionMap.get(replacedMeta);
+      return position;
+    }
 
     if (!safeRange) {
       // far from min
@@ -495,6 +384,8 @@ class IntegerBufferSet<Meta = any> {
     const replacedMeta = this._indexToMetaMap.get(indexToReplace);
     const position = this._metaToPositionMap.get(replacedMeta);
 
+    // console.log('index ', indexToReplace, replacedMeta, position)
+
     return position;
   }
 
@@ -502,29 +393,30 @@ class IntegerBufferSet<Meta = any> {
     const indices = new Array(this.bufferSize);
     for (let idx = 0; idx < indices.length; idx++) {
       const meta = this._onTheFlyIndices[idx] || this._positionToMetaList[idx];
+      // console.log('ix ', idx,this.getMetaIndex(meta) )
       const targetIndex = this.getMetaIndex(meta);
       indices[idx] = targetIndex;
     }
 
     // console.log(
-    //   'position xxx ',
+    //   'indices ',
     //   this._positionToMetaList,
-    //   this._onTheFlyIndices
+    //   this._onTheFlyIndices.slice(),
+    //   indices
     // );
 
     const _arr = new Array(indices.length);
     const _available = [];
     const indexToMetaMap = new Map();
     const metaToIndexMap = new Map();
-    const metaToPositionMap = new Map();
+
     for (let idx = 0; idx < indices.length; idx++) {
       const currentIndex = indices[idx];
       const currentMeta = this._metaExtractor(currentIndex);
+      // console.log("current ", currentIndex, currentMeta)
       if (currentMeta == null) continue;
-
       indexToMetaMap.set(currentIndex, currentMeta);
       metaToIndexMap.set(currentMeta, currentIndex);
-
       if (currentMeta === this._positionToMetaList[idx]) {
         _arr[idx] = currentMeta;
         continue;
@@ -538,74 +430,49 @@ class IntegerBufferSet<Meta = any> {
       _available.push(currentMeta);
     }
 
-    const { smallValues, largeValues } = this.initialize();
     const positionToMetaList = [];
+    this._indexToMetaMap = indexToMetaMap;
+    this.replaceMetaToIndexMap(metaToIndexMap);
 
     for (let position = 0; position < indices.length; position++) {
-      const value = indices[position];
       if (_arr[position] != null) {
         positionToMetaList[position] = _arr[position];
-        metaToPositionMap.set(_arr[position], position);
-        const element = { position, value };
-        smallValues.push(element);
-        largeValues.push(element);
         continue;
       }
       const meta = _available.shift();
       if (meta != null) {
         positionToMetaList[position] = meta;
-        metaToPositionMap.set(meta, position);
-
-        const element = { position, value };
-        smallValues.push(element);
-        largeValues.push(element);
       }
     }
 
-    // console.log('position ', positionToMetaList, largeValues.peek().value);
-
     this._positionToMetaList = positionToMetaList;
-    this._smallValues = smallValues;
-    this._largeValues = largeValues;
-    this._indexToMetaMap = indexToMetaMap;
-    this.replaceMetaToIndexMap(metaToIndexMap);
-    this._metaToPositionMap = metaToPositionMap;
-    this._onTheFlyIndices = [];
 
-    try {
-      const indices = new Array(this.bufferSize);
-      for (let idx = 0; idx < indices.length; idx++) {
-        const meta =
-          this._onTheFlyIndices[idx] || this._positionToMetaList[idx];
-        const targetIndex = this.getMetaIndex(meta);
-        if (meta != null) {
-          indices[idx] = {
-            meta,
-            targetIndex,
-            recyclerKey: `${this._name}_${idx}`,
-          };
-        }
-      }
-      return indices;
-    } catch (err) {
-      this.readyToStartNextLoop();
-      return this._positionToMetaList;
-    }
+    return this.getIndices();
   }
 
   // key point: `meta` should be preserved..
   getIndices() {
+    const { smallValues, largeValues } = this.initialize();
+
     try {
-      const indices = new Array(this.bufferSize);
+      const indices = new Array(this._positionToMetaList.length);
+      const metaToPositionMap = new Map();
       for (let idx = 0; idx < indices.length; idx++) {
         const meta =
           this._onTheFlyIndices[idx] || this._positionToMetaList[idx];
         const targetIndex = this.getMetaIndex(meta);
         // which means source data has changed. such as one element has been deleted
-        if (meta !== this.getIndexMeta(targetIndex)) {
+        if (
+          !this.isThresholdMeta(meta) &&
+          meta != this.getIndexMeta(targetIndex)
+        ) {
           return this.shuffle();
         }
-        if (meta != null) {
+        if (meta != null && !this.isThresholdMeta(meta)) {
+          const element = { position: idx, value: targetIndex };
+          smallValues.push(element);
+          largeValues.push(element);
+          metaToPositionMap.set(meta, idx);
           indices[idx] = {
             meta,
             targetIndex,
@@ -613,13 +480,19 @@ class IntegerBufferSet<Meta = any> {
           };
         }
       }
-      // clear on the fly indices after return indices.
-      this._onTheFlyIndices = [];
+      this._smallValues = smallValues;
+      this._largeValues = largeValues;
+      this._metaToPositionMap = metaToPositionMap;
+      this._positionToMetaList = indices.map((v) => v?.meta);
+      this.resetOnTheFlies();
 
       return indices;
     } catch (err) {
-      this.readyToStartNextLoop();
+      console.log('err ', err);
       return this._positionToMetaList;
+    } finally {
+      this.readyToStartNextLoop();
+      // clear on the fly indices after return indices.
     }
   }
 
@@ -631,12 +504,45 @@ class IntegerBufferSet<Meta = any> {
   }
 
   _setMetaPosition(meta: Meta, position: number) {
-    const prevMetaOnPosition = this._positionToMetaList[position];
-    if (prevMetaOnPosition) this._metaToPositionMap.delete(prevMetaOnPosition);
+    // do not delete meta2position; because getPosition will get by meta first...
+    // const prevMetaOnPosition = this._positionToMetaList[position];
+    // if (prevMetaOnPosition) this._metaToPositionMap.delete(prevMetaOnPosition);
     this._positionToMetaList[position] = meta;
     this._metaToPositionMap.set(meta, position);
   }
 
+  commitPosition(props: {
+    newIndex: number;
+    position: number;
+    meta: Meta;
+    safeRange: SafeRange;
+  }) {
+    const { newIndex, safeRange, position, meta } = props;
+    const onTheFlyPositionMeta = this._onTheFlyIndices[position];
+    let positionToReplace = position;
+
+    // console.log('position ', newIndex, position);
+
+    if (onTheFlyPositionMeta) {
+      // such as place item 11 twice...
+      if (onTheFlyPositionMeta === meta) return position;
+      if (this._isOnTheFlyFull)
+        return this.getFliedPosition(newIndex, safeRange);
+      positionToReplace = this._replaceFurthestIndexPosition(
+        newIndex,
+        safeRange
+      );
+
+      while (this._onTheFlyIndices[positionToReplace]) {
+        positionToReplace = this._replaceFurthestIndexPosition(
+          newIndex,
+          safeRange
+        );
+      }
+    }
+    return positionToReplace;
+  }
+
   /**
    *
    * @param meta
@@ -665,16 +571,21 @@ class IntegerBufferSet<Meta = any> {
 
     this._onTheFlyIndices = [];
     this._isOnTheFlyFull = false;
-    const len = this._positionToMetaList.length;
-
-    for (let index = 0; index < len; index++) {}
   }
 
   _cleanHeaps() {
     // We not usually only remove object from one heap while moving value.
     // Here we make sure that there is no stale data on top of heaps.
-    this._cleanHeap(this._smallValues);
-    this._cleanHeap(this._largeValues);
+    // this._cleanHeap(this._smallValues);
+    // this._cleanHeap(this._largeValues);
+
+    for (let idx = 0; idx < this._positionToMetaList.length; idx++) {
+      if (this._positionToMetaList[idx] == null) {
+        this._recreateHeaps();
+        return;
+      }
+    }
+
     const minHeapSize = Math.min(
       this._smallValues.size(),
       this._largeValues.size()
@@ -689,112 +600,49 @@ class IntegerBufferSet<Meta = any> {
       this._recreateHeaps();
     }
   }
+  _recreateHeaps() {
+    const { smallValues, largeValues } = this.initialize();
+    for (
+      let position = 0;
+      position < this._positionToMetaList.length;
+      position++
+    ) {
+      const meta = this._positionToMetaList[position];
+      let value = this.getMetaIndex(meta);
 
-  rebuildHeapsWithValues(
-    arr: Array<{
-      position: number;
-      value: number;
-    }>
-  ) {
-    const valueToPositionObject = {};
-    const newSmallValues = new Heap<HeapItem>([], this._smallerComparator);
-    const newLargeValues = new Heap<HeapItem>([], this._greaterComparator);
-
-    arr.forEach((element) => {
-      const { position, value } = element;
-      if (value !== undefined) {
-        const element = {
-          position,
-          value,
-        };
-        newSmallValues.push(element);
-        newLargeValues.push(element);
-        valueToPositionObject[value] = position;
-      }
-    });
-    const _arr = new Array(this._bufferSize).fill(2);
-    Object.keys(valueToPositionObject).map(
-      (key) => (_arr[valueToPositionObject[key]] = 1)
-    );
-    _arr.forEach((_i, position) => {
-      if (_i === 2) {
-        const value = Number.MAX_SAFE_INTEGER - position;
-        const element = {
-          position,
-          value,
-        };
-
-        newSmallValues.push(element);
-        newLargeValues.push(element);
-        valueToPositionObject[value] = position;
+      if (!meta || value === -1 || value == null) {
+        value = Number.MAX_SAFE_INTEGER - position;
       }
-    });
-    this._smallValues = newSmallValues;
-    this._largeValues = newLargeValues;
-  }
-
-  // rebuildHeaps() {
-  //   const valueToPositionObject = {};
-  //   const newSmallValues = new Heap<HeapItem>([], this._smallerComparator);
-  //   const newLargeValues = new Heap<HeapItem>([], this._greaterComparator);
-
-  //   const keys = Object.keys(this._positionToValueObject);
-  //   for (let position = 0; position < keys.length; position++) {
-  //     const value = this._positionToValueObject[position];
-  //     if (value !== undefined) {
-  //       const element = {
-  //         position,
-  //         value,
-  //       };
-  //       valueToPositionObject[value] = position;
-  //       newSmallValues.push(element);
-  //       newLargeValues.push(element);
-  //     }
-  //   }
-
-  //   this._smallValues = newSmallValues;
-  //   this._largeValues = newLargeValues;
-  // }
 
-  _recreateHeaps() {
-    const sourceHeap =
-      this._smallValues.size() < this._largeValues.size()
-        ? this._smallValues
-        : this._largeValues;
-    const newSmallValues = new Heap<HeapItem>(
-      [], // Initial data in the heap
-      this._smallerComparator
-    );
-    const newLargeValues = new Heap<HeapItem>(
-      [], // Initial datat in the heap
-      this._greaterComparator
-    );
-    while (!sourceHeap.empty()) {
-      const element = sourceHeap.pop()!;
-      // Push all still valid elements to new heaps
-      if (
-        this._metaToPositionMap.get(this._indexToMetaMap.get(element.value)) !=
-        null
-      ) {
-        newSmallValues.push(element);
-        newLargeValues.push(element);
+      const element = { position, value };
+      smallValues.push(element);
+      largeValues.push(element);
+      if (value > thresholdNumber) {
+        // @ts-ignore
+        this._setMetaPosition(value, position);
+        // @ts-ignore
+        this._setMetaIndex(value, value);
       }
     }
-    this._smallValues = newSmallValues;
-    this._largeValues = newLargeValues;
-  }
 
-  _cleanHeap(heap: Heap<HeapItem>) {
-    while (
-      !heap.empty() &&
-      this._metaToPositionMap.get(
-        this._indexToMetaMap.get(heap.peek()!.value)
-      ) == null
-    ) {
-      heap.pop();
-    }
+    this._largeValues.peek().value;
+
+    this._smallValues = smallValues;
+    this._largeValues = largeValues;
   }
 
+  // _cleanHeap(heap: Heap<HeapItem>) {
+  //   while (
+  //     !heap.empty() &&
+  //     this._metaToPositionMap.get(
+  //       this._indexToMetaMap.get(heap.peek()!.value)
+  //     ) == null
+  //   ) {
+  //     console.log('pop ---', heap.peek()!.value);
+  //     heap.pop();
+  //   }
+  // }
+
   _smallerComparator(lhs: HeapItem, rhs: HeapItem) {
     return lhs.value < rhs.value;
   }