@x-oasis/integer-buffer-set 0.1.19 → 0.1.23

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,34 +1,59 @@
 import Heap from '@x-oasis/heap';
-declare type HeapItem = {
-    position: number;
-    value: number;
-};
-declare class IntegerBufferSet {
-    private _size;
-    private _valueToPositionMap;
+import { HeapItem, SafeRange, IntegerBufferSetProps, MetaToIndexMap } from './types';
+export declare const defaultBufferSize = 10;
+declare class IntegerBufferSet<Meta = any> {
+    private _name;
+    private _bufferSize;
+    private _indexToMetaMap;
+    private _metaToPositionMap;
+    private _positionToMetaList;
+    private _metaToIndexMap;
     private _smallValues;
     private _largeValues;
-    private _vacantPositions;
-    constructor();
-    getSize(): number;
-    get indices(): any[];
-    getValuePosition(value: number): null | number;
-    getNewPositionForValue(value: number): number;
+    private _metaExtractor;
+    private _indexExtractor;
+    private _onTheFlyIndices;
+    private _isOnTheFlyFull;
+    private _isOnTheFlyFullReturnHook;
+    private _loopMS;
+    private _lastUpdatedMS;
+    constructor(props?: IntegerBufferSetProps<Meta>);
+    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;
-    setPositionValue(position: number, value: number): void;
-    replaceFurthestValuePosition(lowValue: number, highValue: number, newValue: number, useMinValueFn?: (options: {
-        safeRange: {
-            lowValue: number;
-            highValue: number;
-        };
-        bufferSetRange: {
-            maxValue: number;
-            minValue: number;
-        };
-        currentIndex: number;
-    }) => boolean): null | 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;
     _recreateHeaps(): void;
     _cleanHeap(heap: Heap<HeapItem>): void;

package/dist/integer-buffer-set.cjs.development.js

@@ -5,6 +5,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
 var Heap = _interopDefault(require('@x-oasis/heap'));
+var isClamped = _interopDefault(require('@x-oasis/is-clamped'));
+var invariant = _interopDefault(require('@x-oasis/invariant'));
+var returnHook = _interopDefault(require('@x-oasis/return-hook'));
 
 function _defineProperties(target, props) {
   for (var i = 0; i < props.length; i++) {
@@ -38,45 +41,102 @@ function _toPropertyKey(arg) {
   return typeof key === "symbol" ? key : String(key);
 }
 
-var defaultUseMinValueFn = function defaultUseMinValueFn(options) {
-  var safeRange = options.safeRange,
-    bufferSetRange = options.bufferSetRange;
-  var lowValue = safeRange.lowValue,
-    highValue = safeRange.highValue;
-  var maxValue = bufferSetRange.maxValue,
-    minValue = bufferSetRange.minValue;
-  return lowValue - minValue > maxValue - highValue;
+var defaultMetaExtractor = function defaultMetaExtractor(value) {
+  return value;
 };
+var defaultBufferSize = 10;
 var IntegerBufferSet = /*#__PURE__*/function () {
-  function IntegerBufferSet() {
-    this._valueToPositionMap = {};
-    this._size = 0;
+  function IntegerBufferSet(props) {
+    if (props === void 0) {
+      props = {};
+    }
+    var _props = props,
+      _props$name = _props.name,
+      name = _props$name === void 0 ? 'default_buffer' : _props$name,
+      indexExtractor = _props.indexExtractor,
+      _props$bufferSize = _props.bufferSize,
+      bufferSize = _props$bufferSize === void 0 ? defaultBufferSize : _props$bufferSize,
+      _props$metaExtractor = _props.metaExtractor,
+      metaExtractor = _props$metaExtractor === void 0 ? defaultMetaExtractor : _props$metaExtractor;
+    this._metaExtractor = metaExtractor;
+    this._indexExtractor = indexExtractor;
+    this._name = name;
+    this._indexToMetaMap = new Map();
+    this._metaToPositionMap = new Map();
+    this._positionToMetaList = [];
+    this._metaToIndexMap = new Map();
+    this._onTheFlyIndices = [];
+    this._bufferSize = bufferSize;
     this._smallValues = new Heap([], this._smallerComparator);
     this._largeValues = new Heap([], this._greaterComparator);
-    this.getNewPositionForValue = this.getNewPositionForValue.bind(this);
-    this.getValuePosition = this.getValuePosition.bind(this);
-    this.getSize = this.getSize.bind(this);
-    this.replaceFurthestValuePosition = this.replaceFurthestValuePosition.bind(this);
-    this._vacantPositions = [];
+    this.getNewPositionForIndex = this.getNewPositionForIndex.bind(this);
+    this.getIndexPosition = this.getIndexPosition.bind(this);
+    this.replacePositionInFliedIndices = this.replacePositionInFliedIndices.bind(this);
+    this.replaceFurthestIndexPosition = this.replaceFurthestIndexPosition.bind(this);
+    this._isOnTheFlyFullReturnHook = returnHook(this.setIsOnTheFlyFull.bind(this));
+    this._loopMS = Date.now();
+    this._lastUpdatedMS = this._loopMS;
   }
   var _proto = IntegerBufferSet.prototype;
-  _proto.getSize = function getSize() {
-    return this._size;
+  _proto.setIsOnTheFlyFull = function setIsOnTheFlyFull(val) {
+    if (val != null) {
+      var data = this._onTheFlyIndices.filter(function (v) {
+        return v;
+      });
+      this._isOnTheFlyFull = data.length === this._bufferSize;
+    }
   };
-  _proto.getValuePosition = function getValuePosition(value) {
-    if (this._valueToPositionMap[value] === undefined) {
-      return null;
+  _proto.getOnTheFlyUncriticalPosition = function getOnTheFlyUncriticalPosition(safeRange) {
+    var startIndex = safeRange.startIndex,
+      endIndex = safeRange.endIndex;
+    for (var idx = 0; idx < this._onTheFlyIndices.length; idx++) {
+      var meta = this._onTheFlyIndices[idx];
+      var metaIndex = this._metaToIndexMap.get(meta);
+      if (!isClamped(startIndex, metaIndex, endIndex)) {
+        return idx;
+      }
+    }
+    return null;
+  };
+  _proto.initialize = function initialize() {
+    return {
+      smallValues: new Heap([], this._smallerComparator),
+      largeValues: new Heap([], this._greaterComparator),
+      valueToPositionObject: {}
+    };
+  };
+  _proto.getIndexMeta = function getIndexMeta(index) {
+    return this._metaExtractor(index);
+  };
+  _proto.getMetaIndex = function getMetaIndex(meta) {
+    if (this._indexExtractor) return this._indexExtractor(meta);
+    return this._metaToIndexMap.get(meta);
+  };
+  _proto.setMetaIndex = function setMetaIndex(meta, index) {
+    if (!this._indexExtractor) {
+      return this._metaToIndexMap.set(meta, index);
     }
-    return this._valueToPositionMap[value];
+    return false;
   };
-  _proto.getNewPositionForValue = function getNewPositionForValue(value) {
-    if (this._valueToPositionMap[value] !== undefined) {
-      console.warn("Shouldn't try to find new position for value already stored in BufferSet");
+  _proto.deleteMetaIndex = function deleteMetaIndex(meta) {
+    return this._metaToIndexMap["delete"](meta);
+  };
+  _proto.replaceMetaToIndexMap = function replaceMetaToIndexMap(newMetaToIndexMap) {
+    if (!this._indexExtractor) {
+      return this._metaToIndexMap = newMetaToIndexMap;
     }
-    var newPosition = this._size;
-    this._size++;
-    this._pushToHeaps(newPosition, value);
-    this._valueToPositionMap[value] = newPosition;
+    return false;
+  };
+  _proto.getIndexPosition = function getIndexPosition(index) {
+    return this.getMetaIndex(this.getIndexMeta(index));
+  };
+  _proto.getNewPositionForIndex = function getNewPositionForIndex(index) {
+    var meta = this.getIndexMeta(index);
+    !(this._metaToPositionMap.get(meta) === undefined) ?  invariant(false, "Shouldn't try to find new position for value already stored in BufferSet")  : void 0;
+    var newPosition = this._positionToMetaList.length;
+    this._pushToHeaps(newPosition, index);
+    this._setMetaIndex(meta, index);
+    this._setMetaPosition(meta, newPosition);
     return newPosition;
   };
   _proto.getMinValue = function getMinValue() {
@@ -87,67 +147,228 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     var _this$_largeValues$pe;
     return (_this$_largeValues$pe = this._largeValues.peek()) == null ? void 0 : _this$_largeValues$pe.value;
   };
-  _proto.setPositionValue = function setPositionValue(position, value) {
-    var originalPosition = this._valueToPositionMap[value];
-    if (originalPosition !== undefined) {
-      var index = this._vacantPositions.findIndex(function (v) {
-        return v === originalPosition;
-      });
-      if (index === -1) this._vacantPositions.push(originalPosition);
-      delete this._valueToPositionMap[value];
-      this._valueToPositionMap[value] = position;
+  _proto.replacePositionInFliedIndices = function replacePositionInFliedIndices(newIndex, safeRange) {
+    var startIndex = safeRange.startIndex,
+      endIndex = safeRange.endIndex;
+    if (this._isOnTheFlyFull) {
+      if (!isClamped(startIndex, newIndex, endIndex)) {
+        return null;
+      }
+      var pos = this.getOnTheFlyUncriticalPosition(safeRange);
+      if (pos != null) return pos;
     }
+    return null;
   };
-  _proto.replaceFurthestValuePosition = function replaceFurthestValuePosition(lowValue, highValue, newValue, useMinValueFn) {
-    if (useMinValueFn === void 0) {
-      useMinValueFn = defaultUseMinValueFn;
+  _proto.getFliedPosition = function getFliedPosition(newIndex, safeRange) {
+    var pos = this.replacePositionInFliedIndices(newIndex, safeRange);
+    if (pos != null) {
+      var meta = this.getIndexMeta(newIndex);
+      this._onTheFlyIndices[pos] = meta;
+      this._setMetaIndex(meta, newIndex);
+      return this._isOnTheFlyFullReturnHook(pos);
     }
-    if (this._valueToPositionMap[newValue] !== undefined) {
-      console.warn("Shouldn't try to replace values with value already stored value in " + 'BufferSet');
+    return null;
+  };
+  _proto.getPosition = function getPosition(newIndex, safeRange) {
+    this.prepare();
+    var meta = this.getIndexMeta(newIndex);
+    var prevMetaPosition = this._metaToPositionMap.get(meta);
+    if (prevMetaPosition !== undefined) {
+      var onTheFlyPositionMeta = this._onTheFlyIndices[prevMetaPosition];
+      if (onTheFlyPositionMeta) {
+        if (onTheFlyPositionMeta === meta) {
+          return prevMetaPosition;
+        }
+        var _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);
     }
-    this._cleanHeaps();
-    if (this._smallValues.empty() || this._largeValues.empty()) {
-      return null;
+    if (!this.isBufferFull) return this._isOnTheFlyFullReturnHook(this.getNewPositionForIndex(newIndex));
+    if (this._isOnTheFlyFull) return this.getFliedPosition(newIndex, safeRange);
+    var positionToReplace;
+    var prevIndexMeta = this._indexToMetaMap.get(newIndex);
+    if (!prevIndexMeta) {
+      this._cleanHeaps();
+      positionToReplace = this._replaceFurthestIndexPosition(newIndex, safeRange);
+    } else {
+      positionToReplace = this._metaToPositionMap.get(prevIndexMeta);
     }
-    if (this._vacantPositions.length) {
-      var _position = this._vacantPositions.pop();
-      this._valueToPositionMap[newValue] = _position;
-      this._pushToHeaps(_position, newValue);
-      return _position;
+    this._onTheFlyIndices[positionToReplace] = meta;
+    this._setMetaIndex(meta, newIndex);
+    this._setMetaPosition(meta, positionToReplace);
+    return this._isOnTheFlyFullReturnHook(positionToReplace);
+  };
+  _proto.replaceFurthestIndexPosition = function replaceFurthestIndexPosition(newIndex, safeRange) {
+    if (!this.isBufferFull) {
+      return this._isOnTheFlyFullReturnHook(this.getNewPositionForIndex(newIndex));
+    }
+    return this._replaceFurthestIndexPosition(newIndex, safeRange);
+  };
+  _proto._replaceFurthestIndexPosition = function _replaceFurthestIndexPosition(newIndex, safeRange) {
+    if (this._largeValues.empty() || this._smallValues.empty()) {
+      return this._isOnTheFlyFullReturnHook(this.getNewPositionForIndex(newIndex));
     }
     var minValue = this._smallValues.peek().value;
     var maxValue = this._largeValues.peek().value;
-    if (minValue >= lowValue && maxValue <= highValue) {
-      return null;
+    var indexToReplace;
+    if (!safeRange) {
+      if (Math.abs(newIndex - minValue) > Math.abs(newIndex - maxValue)) {
+        indexToReplace = minValue;
+        this._smallValues.pop();
+      } else {
+        indexToReplace = maxValue;
+        this._largeValues.pop();
+      }
+      var _replacedMeta = this._indexToMetaMap.get(indexToReplace);
+      var _position = this._metaToPositionMap.get(_replacedMeta);
+      return _position;
     }
-    var valueToReplace;
-    if (useMinValueFn({
-      safeRange: {
-        lowValue: lowValue,
-        highValue: highValue
-      },
-      bufferSetRange: {
-        minValue: minValue,
-        maxValue: maxValue
-      },
-      currentIndex: newValue
-    })) {
-      valueToReplace = minValue;
+    var lowValue = safeRange.startIndex,
+      highValue = safeRange.endIndex;
+    if (isClamped(lowValue, minValue, highValue) && isClamped(lowValue, maxValue, highValue)) {
+      return null;
+    } else if (isClamped(lowValue, minValue, highValue) && !isClamped(lowValue, maxValue, highValue)) {
+      indexToReplace = maxValue;
+      this._largeValues.pop();
+    } else if (!isClamped(lowValue, minValue, highValue) && isClamped(lowValue, maxValue, highValue)) {
+      indexToReplace = minValue;
+      this._smallValues.pop();
+    } else if (lowValue - minValue > maxValue - highValue) {
+      indexToReplace = minValue;
       this._smallValues.pop();
     } else {
-      valueToReplace = maxValue;
+      indexToReplace = maxValue;
       this._largeValues.pop();
     }
-    var position = this._valueToPositionMap[valueToReplace];
-    delete this._valueToPositionMap[valueToReplace];
-    this._valueToPositionMap[newValue] = position;
-    this._pushToHeaps(position, newValue);
-    var _i = this._vacantPositions.findIndex(function (v) {
-      return v === position;
-    });
-    if (_i !== -1) this._vacantPositions.splice(_i, 1);
+    var replacedMeta = this._indexToMetaMap.get(indexToReplace);
+    var position = this._metaToPositionMap.get(replacedMeta);
     return position;
   };
+  _proto.shuffle = function shuffle() {
+    var _this = this;
+    var indices = new Array(this.bufferSize);
+    for (var idx = 0; idx < indices.length; idx++) {
+      var meta = this._onTheFlyIndices[idx] || this._positionToMetaList[idx];
+      var targetIndex = this.getMetaIndex(meta);
+      indices[idx] = targetIndex;
+    }
+    var _arr = new Array(indices.length);
+    var _available = [];
+    var indexToMetaMap = new Map();
+    var metaToIndexMap = new Map();
+    var metaToPositionMap = new Map();
+    var _loop = function _loop() {
+      var currentIndex = indices[_idx];
+      var currentMeta = _this._metaExtractor(currentIndex);
+      if (currentMeta == null) return "continue";
+      indexToMetaMap.set(currentIndex, currentMeta);
+      metaToIndexMap.set(currentMeta, currentIndex);
+      if (currentMeta === _this._positionToMetaList[_idx]) {
+        _arr[_idx] = currentMeta;
+        return "continue";
+      }
+      var _i = _this._positionToMetaList.findIndex(function (v) {
+        return v === currentMeta;
+      });
+      if (_i !== -1) {
+        _arr[_i] = currentMeta;
+        return "continue";
+      }
+      _available.push(currentMeta);
+    };
+    for (var _idx = 0; _idx < indices.length; _idx++) {
+      var _ret = _loop();
+      if (_ret === "continue") continue;
+    }
+    var _this$initialize = this.initialize(),
+      smallValues = _this$initialize.smallValues,
+      largeValues = _this$initialize.largeValues;
+    var positionToMetaList = [];
+    for (var position = 0; position < indices.length; position++) {
+      var value = indices[position];
+      if (_arr[position] != null) {
+        positionToMetaList[position] = _arr[position];
+        metaToPositionMap.set(_arr[position], position);
+        var element = {
+          position: position,
+          value: value
+        };
+        smallValues.push(element);
+        largeValues.push(element);
+        continue;
+      }
+      var _meta = _available.shift();
+      if (_meta != null) {
+        positionToMetaList[position] = _meta;
+        metaToPositionMap.set(_meta, position);
+        var _element = {
+          position: position,
+          value: value
+        };
+        smallValues.push(_element);
+        largeValues.push(_element);
+      }
+    }
+    this._positionToMetaList = positionToMetaList;
+    this._smallValues = smallValues;
+    this._largeValues = largeValues;
+    this._indexToMetaMap = indexToMetaMap;
+    this.replaceMetaToIndexMap(metaToIndexMap);
+    this._metaToPositionMap = metaToPositionMap;
+    this._onTheFlyIndices = [];
+    try {
+      var _indices = new Array(this.bufferSize);
+      for (var _idx2 = 0; _idx2 < _indices.length; _idx2++) {
+        var _meta2 = this._onTheFlyIndices[_idx2] || this._positionToMetaList[_idx2];
+        var _targetIndex = this.getMetaIndex(_meta2);
+        if (_meta2 != null) {
+          _indices[_idx2] = {
+            meta: _meta2,
+            targetIndex: _targetIndex,
+            recyclerKey: this._name + "_" + _idx2
+          };
+        }
+      }
+      return _indices;
+    } catch (err) {
+      this.readyToStartNextLoop();
+      return this._positionToMetaList;
+    }
+  };
+  _proto.getIndices = function getIndices() {
+    try {
+      var indices = new Array(this.bufferSize);
+      for (var idx = 0; idx < indices.length; idx++) {
+        var meta = this._onTheFlyIndices[idx] || this._positionToMetaList[idx];
+        var targetIndex = this.getMetaIndex(meta);
+        if (meta !== this.getIndexMeta(targetIndex)) {
+          return this.shuffle();
+        }
+        if (meta != null) {
+          indices[idx] = {
+            meta: meta,
+            targetIndex: targetIndex,
+            recyclerKey: this._name + "_" + idx
+          };
+        }
+      }
+      this._onTheFlyIndices = [];
+      return indices;
+    } catch (err) {
+      this.readyToStartNextLoop();
+      return this._positionToMetaList;
+    }
+  };
   _proto._pushToHeaps = function _pushToHeaps(position, value) {
     var element = {
       position: position,
@@ -156,6 +377,30 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     this._smallValues.push(element);
     this._largeValues.push(element);
   };
+  _proto._setMetaPosition = function _setMetaPosition(meta, position) {
+    var prevMetaOnPosition = this._positionToMetaList[position];
+    if (prevMetaOnPosition) this._metaToPositionMap["delete"](prevMetaOnPosition);
+    this._positionToMetaList[position] = meta;
+    this._metaToPositionMap.set(meta, position);
+  };
+  _proto._setMetaIndex = function _setMetaIndex(meta, index) {
+    var prevMetaIndex = this.getMetaIndex(meta);
+    if (prevMetaIndex !== undefined) {
+      this._indexToMetaMap["delete"](prevMetaIndex);
+    }
+    this.setMetaIndex(meta, index);
+    this._indexToMetaMap.set(index, meta);
+    return false;
+  };
+  _proto.readyToStartNextLoop = function readyToStartNextLoop() {
+    this._lastUpdatedMS = Date.now();
+  };
+  _proto.prepare = function prepare() {
+    if (this._loopMS === this._lastUpdatedMS) return;
+    this._loopMS = this._lastUpdatedMS;
+    this._onTheFlyIndices = [];
+    this._isOnTheFlyFull = false;
+  };
   _proto._cleanHeaps = function _cleanHeaps() {
     this._cleanHeap(this._smallValues);
     this._cleanHeap(this._largeValues);
@@ -171,7 +416,7 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     var newLargeValues = new Heap([], this._greaterComparator);
     while (!sourceHeap.empty()) {
       var element = sourceHeap.pop();
-      if (this._valueToPositionMap[element.value] !== undefined) {
+      if (this._metaToPositionMap.get(this._indexToMetaMap.get(element.value)) != null) {
         newSmallValues.push(element);
         newLargeValues.push(element);
       }
@@ -180,7 +425,7 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     this._largeValues = newLargeValues;
   };
   _proto._cleanHeap = function _cleanHeap(heap) {
-    while (!heap.empty() && this._valueToPositionMap[heap.peek().value] === undefined) {
+    while (!heap.empty() && this._metaToPositionMap.get(this._indexToMetaMap.get(heap.peek().value)) == null) {
       heap.pop();
     }
   };
@@ -191,18 +436,19 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     return lhs.value > rhs.value;
   };
   _createClass(IntegerBufferSet, [{
-    key: "indices",
+    key: "bufferSize",
     get: function get() {
-      var indices = [];
-      for (var key in this._valueToPositionMap) {
-        var value = this._valueToPositionMap[key];
-        indices[value] = key;
-      }
-      return indices;
+      return this._bufferSize;
+    }
+  }, {
+    key: "isBufferFull",
+    get: function get() {
+      return this._positionToMetaList.length >= this._bufferSize;
     }
   }]);
   return IntegerBufferSet;
 }();
 
 exports.default = IntegerBufferSet;
+exports.defaultBufferSize = defaultBufferSize;
 //# sourceMappingURL=integer-buffer-set.cjs.development.js.map