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

package/dist/integer-buffer-set.esm.js

@@ -1,4 +1,7 @@
 import Heap from '@x-oasis/heap';
+import isClamped from '@x-oasis/is-clamped';
+import invariant from '@x-oasis/invariant';
+import returnHook from '@x-oasis/return-hook';
 
 function _defineProperties(target, props) {
   for (var i = 0; i < props.length; i++) {
@@ -17,6 +20,37 @@ function _createClass(Constructor, protoProps, staticProps) {
   });
   return Constructor;
 }
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _toPrimitive(input, hint) {
   if (typeof input !== "object" || input === null) return input;
   var prim = input[Symbol.toPrimitive];
@@ -32,44 +66,107 @@ 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 = {};
+  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._size = 0;
+    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.getNewPositionForIndex = this.getNewPositionForIndex.bind(this);
+    this.getIndexPosition = this.getIndexPosition.bind(this);
     this.getSize = this.getSize.bind(this);
-    this.replaceFurthestValuePosition = this.replaceFurthestValuePosition.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.getValuePosition = function getValuePosition(value) {
-    if (this._valueToPositionMap[value] === undefined) {
-      return null;
+  _proto.setIsOnTheFlyFull = function setIsOnTheFlyFull(val) {
+    if (val != null) {
+      var data = this._onTheFlyIndices.filter(function (v) {
+        return v;
+      });
+      this._isOnTheFlyFull = data.length === this._bufferSize;
     }
-    return this._valueToPositionMap[value];
   };
-  _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.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;
+      }
     }
-    var newPosition = this._size;
-    this._size++;
-    this._pushToHeaps(newPosition, value);
-    this._valueToPositionMap[value] = newPosition;
+    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 false;
+  };
+  _proto.deleteMetaIndex = function deleteMetaIndex(meta) {
+    return this._metaToIndexMap["delete"](meta);
+  };
+  _proto.replaceMetaToIndexMap = function replaceMetaToIndexMap(newMetaToIndexMap) {
+    if (!this._indexExtractor) {
+      return this._metaToIndexMap = newMetaToIndexMap;
+    }
+    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) ? process.env.NODE_ENV !== "production" ? invariant(false, "Shouldn't try to find new position for value already stored in BufferSet") : invariant(false) : 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() {
@@ -80,46 +177,273 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     var _this$_largeValues$pe;
     return (_this$_largeValues$pe = this._largeValues.peek()) == null ? void 0 : _this$_largeValues$pe.value;
   };
-  _proto.replaceFurthestValuePosition = function replaceFurthestValuePosition(lowValue, highValue, newValue, useMinValueFn) {
-    if (useMinValueFn === void 0) {
-      useMinValueFn = defaultUseMinValueFn;
+  _proto.setValuePosition = function setValuePosition(value, position) {};
+  _proto.findPositionMeta = function findPositionMeta(position) {
+    for (var _iterator = _createForOfIteratorHelperLoose(this._metaToPositionMap), _step; !(_step = _iterator()).done;) {
+      var _step$value = _step.value,
+        meta = _step$value[0],
+        pos = _step$value[1];
+      if (pos === position) return meta;
     }
-    if (this._valueToPositionMap[newValue] !== undefined) {
-      console.warn("Shouldn't try to replace values with value already stored value in " + 'BufferSet');
+    return null;
+  };
+  _proto.rebuildHeapsWithMeta = function rebuildHeapsWithMeta(metaToPositionMap) {
+    var _this$initialize = this.initialize(),
+      smallValues = _this$initialize.smallValues,
+      largeValues = _this$initialize.largeValues;
+    for (var _iterator2 = _createForOfIteratorHelperLoose(metaToPositionMap), _step2; !(_step2 = _iterator2()).done;) {
+      var _step2$value = _step2.value,
+        meta = _step2$value[0],
+        position = _step2$value[1];
+      var index = this.getMetaIndex(meta);
+      var token = {
+        index: index,
+        position: position
+      };
+      smallValues.push(token);
+      largeValues.push(token);
     }
-    this._cleanHeaps();
-    if (this._smallValues.empty() || this._largeValues.empty()) {
-      return null;
+    this._smallValues = smallValues;
+    this._largeValues = largeValues;
+  };
+  _proto.setPositionIndex = function setPositionIndex(position, index) {
+    var meta = this._metaExtractor(index);
+    var originalPosition = this._metaToPositionMap.get(meta);
+    if (originalPosition !== undefined) {
+      if (originalPosition === position) return true;
+      this.deleteMetaIndex(meta);
+    }
+    var metaToReplace = this.findPositionMeta(position);
+    if (metaToReplace) this._metaToPositionMap["delete"](metaToReplace);
+    this._metaToPositionMap.set(meta, position);
+    this.rebuildHeapsWithMeta(this._metaToPositionMap);
+    return true;
+  };
+  _proto.getMetaPosition = function getMetaPosition(meta) {
+    return this._metaToPositionMap.get(meta);
+  };
+  _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.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);
+    }
+    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);
+    }
+    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);
+    }
+    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 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$initialize2 = this.initialize(),
+      smallValues = _this$initialize2.smallValues,
+      largeValues = _this$initialize2.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,
@@ -128,6 +452,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);
@@ -137,13 +485,49 @@ var IntegerBufferSet = /*#__PURE__*/function () {
       this._recreateHeaps();
     }
   };
+  _proto.rebuildHeapsWithValues = function rebuildHeapsWithValues(arr) {
+    var valueToPositionObject = {};
+    var newSmallValues = new Heap([], this._smallerComparator);
+    var newLargeValues = new Heap([], this._greaterComparator);
+    arr.forEach(function (element) {
+      var position = element.position,
+        value = element.value;
+      if (value !== undefined) {
+        var _element2 = {
+          position: position,
+          value: value
+        };
+        newSmallValues.push(_element2);
+        newLargeValues.push(_element2);
+        valueToPositionObject[value] = position;
+      }
+    });
+    var _arr = new Array(this._bufferSize).fill(2);
+    Object.keys(valueToPositionObject).map(function (key) {
+      return _arr[valueToPositionObject[key]] = 1;
+    });
+    _arr.forEach(function (_i, position) {
+      if (_i === 2) {
+        var value = Number.MAX_SAFE_INTEGER - position;
+        var element = {
+          position: position,
+          value: value
+        };
+        newSmallValues.push(element);
+        newLargeValues.push(element);
+        valueToPositionObject[value] = position;
+      }
+    });
+    this._smallValues = newSmallValues;
+    this._largeValues = newLargeValues;
+  };
   _proto._recreateHeaps = function _recreateHeaps() {
     var sourceHeap = this._smallValues.size() < this._largeValues.size() ? this._smallValues : this._largeValues;
     var newSmallValues = new Heap([], this._smallerComparator);
     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);
       }
@@ -152,7 +536,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();
     }
   };
@@ -163,18 +547,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;
 }();
 
 export default IntegerBufferSet;
+export { defaultBufferSize };
 //# sourceMappingURL=integer-buffer-set.esm.js.map