@x-oasis/integer-buffer-set 0.0.18

package/README.md

@@ -0,0 +1,19 @@
+# @x-oasis/integer-buffer-set
+
+## Installation
+
+```bash
+$ npm i @x-oasis/integer-buffer-set
+```
+
+## How to use
+
+```typescript
+import IntegerBufferSet from '@x-oasis/integer-buffer-set'
+```
+
+## How to run test
+
+```bash
+$ pnpm test
+```

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import Heap from '@x-oasis/heap';
+declare type HeapItem = {
+    position: number;
+    value: number;
+};
+declare class IntegerBufferSet {
+    private _size;
+    private _valueToPositionMap;
+    private _smallValues;
+    private _largeValues;
+    constructor();
+    getSize(): number;
+    get indices(): any[];
+    getValuePosition(value: number): null | number;
+    getNewPositionForValue(value: number): number;
+    getMinValue(): number;
+    getMaxValue(): number;
+    replaceFurthestValuePosition(lowValue: number, highValue: number, newValue: number): null | number;
+    _pushToHeaps(position: number, value: number): void;
+    _cleanHeaps(): void;
+    _recreateHeaps(): void;
+    _cleanHeap(heap: Heap<HeapItem>): void;
+    _smallerComparator(lhs: HeapItem, rhs: HeapItem): boolean;
+    _greaterComparator(lhs: HeapItem, rhs: HeapItem): boolean;
+}
+export default IntegerBufferSet;

package/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./integer-buffer-set.cjs.production.min.js')
+} else {
+  module.exports = require('./integer-buffer-set.cjs.development.js')
+}

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

@@ -0,0 +1,164 @@
+'use strict';
+
+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'));
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+var IntegerBufferSet = /*#__PURE__*/function () {
+  function IntegerBufferSet() {
+    this._valueToPositionMap = {};
+    this._size = 0;
+    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);
+  }
+  var _proto = IntegerBufferSet.prototype;
+  _proto.getSize = function getSize() {
+    return this._size;
+  };
+  _proto.getValuePosition = function getValuePosition(value) {
+    if (this._valueToPositionMap[value] === undefined) {
+      return null;
+    }
+    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");
+    }
+    var newPosition = this._size;
+    this._size++;
+    this._pushToHeaps(newPosition, value);
+    this._valueToPositionMap[value] = newPosition;
+    return newPosition;
+  };
+  _proto.getMinValue = function getMinValue() {
+    var _this$_smallValues$pe;
+    return (_this$_smallValues$pe = this._smallValues.peek()) == null ? void 0 : _this$_smallValues$pe.value;
+  };
+  _proto.getMaxValue = function getMaxValue() {
+    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) {
+    if (this._valueToPositionMap[newValue] !== undefined) {
+      console.warn("Shouldn't try to replace values with value already stored value in " + 'BufferSet');
+    }
+    this._cleanHeaps();
+    if (this._smallValues.empty() || this._largeValues.empty()) {
+      return null;
+    }
+    var minValue = this._smallValues.peek().value;
+    var maxValue = this._largeValues.peek().value;
+    if (minValue >= lowValue && maxValue <= highValue) {
+      return null;
+    }
+    var valueToReplace;
+    if (lowValue - minValue > maxValue - highValue) {
+      valueToReplace = minValue;
+      this._smallValues.pop();
+    } else {
+      valueToReplace = maxValue;
+      this._largeValues.pop();
+    }
+    var position = this._valueToPositionMap[valueToReplace];
+    delete this._valueToPositionMap[valueToReplace];
+    this._valueToPositionMap[newValue] = position;
+    this._pushToHeaps(position, newValue);
+    return position;
+  };
+  _proto._pushToHeaps = function _pushToHeaps(position, value) {
+    var element = {
+      position: position,
+      value: value
+    };
+    this._smallValues.push(element);
+    this._largeValues.push(element);
+  };
+  _proto._cleanHeaps = function _cleanHeaps() {
+    this._cleanHeap(this._smallValues);
+    this._cleanHeap(this._largeValues);
+    var minHeapSize = Math.min(this._smallValues.size(), this._largeValues.size());
+    var maxHeapSize = Math.max(this._smallValues.size(), this._largeValues.size());
+    if (maxHeapSize > 10 * minHeapSize) {
+      this._recreateHeaps();
+    }
+  };
+  _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) {
+        newSmallValues.push(element);
+        newLargeValues.push(element);
+      }
+    }
+    this._smallValues = newSmallValues;
+    this._largeValues = newLargeValues;
+  };
+  _proto._cleanHeap = function _cleanHeap(heap) {
+    while (!heap.empty() && this._valueToPositionMap[heap.peek().value] === undefined) {
+      heap.pop();
+    }
+  };
+  _proto._smallerComparator = function _smallerComparator(lhs, rhs) {
+    return lhs.value < rhs.value;
+  };
+  _proto._greaterComparator = function _greaterComparator(lhs, rhs) {
+    return lhs.value > rhs.value;
+  };
+  _createClass(IntegerBufferSet, [{
+    key: "indices",
+    get: function get() {
+      var indices = [];
+      for (var key in this._valueToPositionMap) {
+        var value = this._valueToPositionMap[key];
+        indices[value] = key;
+      }
+      return indices;
+    }
+  }]);
+  return IntegerBufferSet;
+}();
+
+exports.default = IntegerBufferSet;
+//# sourceMappingURL=integer-buffer-set.cjs.development.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integer-buffer-set.cjs.development.js","sources":["../src/index.ts"],"sourcesContent":["// import invariant from 'invariant';\nimport Heap from '@x-oasis/heap';\n\ntype HeapItem = {\n  position: number;\n  value: number;\n};\n\n// Data structure that allows to store values and assign positions to them\n// in a way to minimize changing positions of stored values when new ones are\n// added or when some values are replaced. Stored elements are alwasy assigned\n// a consecutive set of positoins startin from 0 up to count of elements less 1\n// Following actions can be executed\n// * get position assigned to given value (null if value is not stored)\n// * create new entry for new value and get assigned position back\n// * replace value that is furthest from specified value range with new value\n//   and get it's position back\n// All operations take amortized log(n) time where n is number of elements in\n// the set.\nclass IntegerBufferSet {\n  private _size: number;\n  private _valueToPositionMap: {\n    [key: string]: number;\n  };\n  private _smallValues: Heap<HeapItem>;\n  private _largeValues: Heap<HeapItem>;\n\n  constructor() {\n    this._valueToPositionMap = {};\n    this._size = 0;\n    this._smallValues = new Heap([], this._smallerComparator);\n    this._largeValues = new Heap([], this._greaterComparator);\n\n    this.getNewPositionForValue = this.getNewPositionForValue.bind(this);\n    this.getValuePosition = this.getValuePosition.bind(this);\n    this.getSize = this.getSize.bind(this);\n    this.replaceFurthestValuePosition =\n      this.replaceFurthestValuePosition.bind(this);\n  }\n\n  getSize() {\n    return this._size;\n  }\n\n  get indices() {\n    const indices = [];\n    for (const key in this._valueToPositionMap) {\n      const value = this._valueToPositionMap[key];\n      indices[value] = key;\n    }\n    return indices;\n  }\n\n  getValuePosition(value: number): null | number {\n    if (this._valueToPositionMap[value] === undefined) {\n      return null;\n    }\n    return this._valueToPositionMap[value];\n  }\n\n  getNewPositionForValue(value: number) {\n    if (this._valueToPositionMap[value] !== undefined) {\n      console.warn(\n        \"Shouldn't try to find new position for value already stored in BufferSet\"\n      );\n    }\n    // invariant(\n    //   this._valueToPositionMap[value] === undefined,\n    //   \"Shouldn't try to find new position for value already stored in BufferSet\"\n    // );\n    const newPosition = this._size;\n    this._size++;\n    this._pushToHeaps(newPosition, value);\n    this._valueToPositionMap[value] = newPosition;\n    return newPosition;\n  }\n\n  getMinValue() {\n    return this._smallValues.peek()?.value;\n  }\n\n  getMaxValue() {\n    return this._largeValues.peek()?.value;\n  }\n\n  replaceFurthestValuePosition(\n    lowValue: number,\n    highValue: number,\n    newValue: number\n  ): null | number {\n    if (this._valueToPositionMap[newValue] !== undefined) {\n      console.warn(\n        \"Shouldn't try to replace values with value already stored value in \" +\n          'BufferSet'\n      );\n    }\n    // invariant(\n    //   this._valueToPositionMap[newValue] === undefined,\n    //   \"Shouldn't try to replace values with value already stored value in \" +\n    //     'BufferSet'\n    // );\n\n    this._cleanHeaps();\n    if (this._smallValues.empty() || this._largeValues.empty()) {\n      // Threre are currently no values stored. We will have to create new\n      // position for this value.\n      return null;\n    }\n\n    const minValue = this._smallValues.peek()!.value;\n    const maxValue = this._largeValues.peek()!.value;\n    if (minValue >= lowValue && maxValue <= highValue) {\n      // All values currently stored are necessary, we can't reuse any of them.\n      return null;\n    }\n\n    let valueToReplace;\n    if (lowValue - minValue > maxValue - highValue) {\n      // minValue is further from provided range. We will reuse it's position.\n      valueToReplace = minValue;\n      this._smallValues.pop();\n    } else {\n      valueToReplace = maxValue;\n      this._largeValues.pop();\n    }\n    const position = this._valueToPositionMap[valueToReplace];\n    delete this._valueToPositionMap[valueToReplace];\n    this._valueToPositionMap[newValue] = position;\n    this._pushToHeaps(position, newValue);\n\n    return position;\n  }\n\n  _pushToHeaps(position: number, value: number) {\n    const element = {\n      position,\n      value,\n    };\n    // We can reuse the same object in both heaps, because we don't mutate them\n    this._smallValues.push(element);\n    this._largeValues.push(element);\n  }\n\n  _cleanHeaps() {\n    // We not usually only remove object from one heap while moving value.\n    // Here we make sure that there is no stale data on top of heaps.\n    this._cleanHeap(this._smallValues);\n    this._cleanHeap(this._largeValues);\n    const minHeapSize = Math.min(\n      this._smallValues.size(),\n      this._largeValues.size()\n    );\n    const maxHeapSize = Math.max(\n      this._smallValues.size(),\n      this._largeValues.size()\n    );\n    if (maxHeapSize > 10 * minHeapSize) {\n      // There are many old values in one of heaps. We need to get rid of them\n      // to not use too avoid memory leaks\n      this._recreateHeaps();\n    }\n  }\n\n  _recreateHeaps() {\n    const sourceHeap =\n      this._smallValues.size() < this._largeValues.size()\n        ? this._smallValues\n        : this._largeValues;\n    const newSmallValues = new Heap<HeapItem>(\n      [], // Initial data in the heap\n      this._smallerComparator\n    );\n    const newLargeValues = new Heap<HeapItem>(\n      [], // Initial datat in the heap\n      this._greaterComparator\n    );\n    while (!sourceHeap.empty()) {\n      const element = sourceHeap.pop()!;\n      // Push all stil valid elements to new heaps\n      if (this._valueToPositionMap[element.value] !== undefined) {\n        newSmallValues.push(element);\n        newLargeValues.push(element);\n      }\n    }\n    this._smallValues = newSmallValues;\n    this._largeValues = newLargeValues;\n  }\n\n  _cleanHeap(heap: Heap<HeapItem>) {\n    while (\n      !heap.empty() &&\n      this._valueToPositionMap[heap.peek()!.value] === undefined\n    ) {\n      heap.pop();\n    }\n  }\n\n  _smallerComparator(lhs: HeapItem, rhs: HeapItem) {\n    return lhs.value < rhs.value;\n  }\n\n  _greaterComparator(lhs: HeapItem, rhs: HeapItem) {\n    return lhs.value > rhs.value;\n  }\n}\n\nexport default IntegerBufferSet;\n"],"names":["IntegerBufferSet","_valueToPositionMap","_size","_smallValues","Heap","_smallerComparator","_largeValues","_greaterComparator","getNewPositionForValue","bind","getValuePosition","getSize","replaceFurthestValuePosition","_proto","prototype","value","undefined","console","warn","newPosition","_pushToHeaps","getMinValue","_this$_smallValues$pe","peek","getMaxValue","_this$_largeValues$pe","lowValue","highValue","newValue","_cleanHeaps","empty","minValue","maxValue","valueToReplace","pop","position","element","push","_cleanHeap","minHeapSize","Math","min","size","maxHeapSize","max","_recreateHeaps","sourceHeap","newSmallValues","newLargeValues","heap","lhs","rhs","_createClass","key","get","indices"],"mappings":"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"}

package/dist/integer-buffer-set.cjs.production.min.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,t=(e=require("@x-oasis/heap"))&&"object"==typeof e&&"default"in e?e.default:e;exports.default=function(){function e(){this._valueToPositionMap={},this._size=0,this._smallValues=new t([],this._smallerComparator),this._largeValues=new t([],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)}var i,a,s=e.prototype;return s.getSize=function(){return this._size},s.getValuePosition=function(e){return void 0===this._valueToPositionMap[e]?null:this._valueToPositionMap[e]},s.getNewPositionForValue=function(e){void 0!==this._valueToPositionMap[e]&&console.warn("Shouldn't try to find new position for value already stored in BufferSet");var t=this._size;return this._size++,this._pushToHeaps(t,e),this._valueToPositionMap[e]=t,t},s.getMinValue=function(){var e;return null==(e=this._smallValues.peek())?void 0:e.value},s.getMaxValue=function(){var e;return null==(e=this._largeValues.peek())?void 0:e.value},s.replaceFurthestValuePosition=function(e,t,i){if(void 0!==this._valueToPositionMap[i]&&console.warn("Shouldn't try to replace values with value already stored value in BufferSet"),this._cleanHeaps(),this._smallValues.empty()||this._largeValues.empty())return null;var a,s=this._smallValues.peek().value,l=this._largeValues.peek().value;if(s>=e&&l<=t)return null;e-s>l-t?(a=s,this._smallValues.pop()):(a=l,this._largeValues.pop());var o=this._valueToPositionMap[a];return delete this._valueToPositionMap[a],this._valueToPositionMap[i]=o,this._pushToHeaps(o,i),o},s._pushToHeaps=function(e,t){var i={position:e,value:t};this._smallValues.push(i),this._largeValues.push(i)},s._cleanHeaps=function(){this._cleanHeap(this._smallValues),this._cleanHeap(this._largeValues);var e=Math.min(this._smallValues.size(),this._largeValues.size());Math.max(this._smallValues.size(),this._largeValues.size())>10*e&&this._recreateHeaps()},s._recreateHeaps=function(){for(var e=this._smallValues.size()<this._largeValues.size()?this._smallValues:this._largeValues,i=new t([],this._smallerComparator),a=new t([],this._greaterComparator);!e.empty();){var s=e.pop();void 0!==this._valueToPositionMap[s.value]&&(i.push(s),a.push(s))}this._smallValues=i,this._largeValues=a},s._cleanHeap=function(e){for(;!e.empty()&&void 0===this._valueToPositionMap[e.peek().value];)e.pop()},s._smallerComparator=function(e,t){return e.value<t.value},s._greaterComparator=function(e,t){return e.value>t.value},i=e,(a=[{key:"indices",get:function(){var e=[];for(var t in this._valueToPositionMap)e[this._valueToPositionMap[t]]=t;return e}}])&&function(e,t){for(var i=0;i<t.length;i++){var a=t[i];a.enumerable=a.enumerable||!1,a.configurable=!0,"value"in a&&(a.writable=!0),Object.defineProperty(e,"symbol"==typeof(s=function(e,t){if("object"!=typeof e||null===e)return e;var i=e[Symbol.toPrimitive];if(void 0!==i){var a=i.call(e,"string");if("object"!=typeof a)return a;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(e)}(a.key))?s:String(s),a)}var s}(i.prototype,a),Object.defineProperty(i,"prototype",{writable:!1}),e}();
+//# sourceMappingURL=integer-buffer-set.cjs.production.min.js.map

package/dist/integer-buffer-set.cjs.production.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer-buffer-set.cjs.production.min.js","sources":["../src/index.ts"],"sourcesContent":["// import invariant from 'invariant';\nimport Heap from '@x-oasis/heap';\n\ntype HeapItem = {\n  position: number;\n  value: number;\n};\n\n// Data structure that allows to store values and assign positions to them\n// in a way to minimize changing positions of stored values when new ones are\n// added or when some values are replaced. Stored elements are alwasy assigned\n// a consecutive set of positoins startin from 0 up to count of elements less 1\n// Following actions can be executed\n// * get position assigned to given value (null if value is not stored)\n// * create new entry for new value and get assigned position back\n// * replace value that is furthest from specified value range with new value\n//   and get it's position back\n// All operations take amortized log(n) time where n is number of elements in\n// the set.\nclass IntegerBufferSet {\n  private _size: number;\n  private _valueToPositionMap: {\n    [key: string]: number;\n  };\n  private _smallValues: Heap<HeapItem>;\n  private _largeValues: Heap<HeapItem>;\n\n  constructor() {\n    this._valueToPositionMap = {};\n    this._size = 0;\n    this._smallValues = new Heap([], this._smallerComparator);\n    this._largeValues = new Heap([], this._greaterComparator);\n\n    this.getNewPositionForValue = this.getNewPositionForValue.bind(this);\n    this.getValuePosition = this.getValuePosition.bind(this);\n    this.getSize = this.getSize.bind(this);\n    this.replaceFurthestValuePosition =\n      this.replaceFurthestValuePosition.bind(this);\n  }\n\n  getSize() {\n    return this._size;\n  }\n\n  get indices() {\n    const indices = [];\n    for (const key in this._valueToPositionMap) {\n      const value = this._valueToPositionMap[key];\n      indices[value] = key;\n    }\n    return indices;\n  }\n\n  getValuePosition(value: number): null | number {\n    if (this._valueToPositionMap[value] === undefined) {\n      return null;\n    }\n    return this._valueToPositionMap[value];\n  }\n\n  getNewPositionForValue(value: number) {\n    if (this._valueToPositionMap[value] !== undefined) {\n      console.warn(\n        \"Shouldn't try to find new position for value already stored in BufferSet\"\n      );\n    }\n    // invariant(\n    //   this._valueToPositionMap[value] === undefined,\n    //   \"Shouldn't try to find new position for value already stored in BufferSet\"\n    // );\n    const newPosition = this._size;\n    this._size++;\n    this._pushToHeaps(newPosition, value);\n    this._valueToPositionMap[value] = newPosition;\n    return newPosition;\n  }\n\n  getMinValue() {\n    return this._smallValues.peek()?.value;\n  }\n\n  getMaxValue() {\n    return this._largeValues.peek()?.value;\n  }\n\n  replaceFurthestValuePosition(\n    lowValue: number,\n    highValue: number,\n    newValue: number\n  ): null | number {\n    if (this._valueToPositionMap[newValue] !== undefined) {\n      console.warn(\n        \"Shouldn't try to replace values with value already stored value in \" +\n          'BufferSet'\n      );\n    }\n    // invariant(\n    //   this._valueToPositionMap[newValue] === undefined,\n    //   \"Shouldn't try to replace values with value already stored value in \" +\n    //     'BufferSet'\n    // );\n\n    this._cleanHeaps();\n    if (this._smallValues.empty() || this._largeValues.empty()) {\n      // Threre are currently no values stored. We will have to create new\n      // position for this value.\n      return null;\n    }\n\n    const minValue = this._smallValues.peek()!.value;\n    const maxValue = this._largeValues.peek()!.value;\n    if (minValue >= lowValue && maxValue <= highValue) {\n      // All values currently stored are necessary, we can't reuse any of them.\n      return null;\n    }\n\n    let valueToReplace;\n    if (lowValue - minValue > maxValue - highValue) {\n      // minValue is further from provided range. We will reuse it's position.\n      valueToReplace = minValue;\n      this._smallValues.pop();\n    } else {\n      valueToReplace = maxValue;\n      this._largeValues.pop();\n    }\n    const position = this._valueToPositionMap[valueToReplace];\n    delete this._valueToPositionMap[valueToReplace];\n    this._valueToPositionMap[newValue] = position;\n    this._pushToHeaps(position, newValue);\n\n    return position;\n  }\n\n  _pushToHeaps(position: number, value: number) {\n    const element = {\n      position,\n      value,\n    };\n    // We can reuse the same object in both heaps, because we don't mutate them\n    this._smallValues.push(element);\n    this._largeValues.push(element);\n  }\n\n  _cleanHeaps() {\n    // We not usually only remove object from one heap while moving value.\n    // Here we make sure that there is no stale data on top of heaps.\n    this._cleanHeap(this._smallValues);\n    this._cleanHeap(this._largeValues);\n    const minHeapSize = Math.min(\n      this._smallValues.size(),\n      this._largeValues.size()\n    );\n    const maxHeapSize = Math.max(\n      this._smallValues.size(),\n      this._largeValues.size()\n    );\n    if (maxHeapSize > 10 * minHeapSize) {\n      // There are many old values in one of heaps. We need to get rid of them\n      // to not use too avoid memory leaks\n      this._recreateHeaps();\n    }\n  }\n\n  _recreateHeaps() {\n    const sourceHeap =\n      this._smallValues.size() < this._largeValues.size()\n        ? this._smallValues\n        : this._largeValues;\n    const newSmallValues = new Heap<HeapItem>(\n      [], // Initial data in the heap\n      this._smallerComparator\n    );\n    const newLargeValues = new Heap<HeapItem>(\n      [], // Initial datat in the heap\n      this._greaterComparator\n    );\n    while (!sourceHeap.empty()) {\n      const element = sourceHeap.pop()!;\n      // Push all stil valid elements to new heaps\n      if (this._valueToPositionMap[element.value] !== undefined) {\n        newSmallValues.push(element);\n        newLargeValues.push(element);\n      }\n    }\n    this._smallValues = newSmallValues;\n    this._largeValues = newLargeValues;\n  }\n\n  _cleanHeap(heap: Heap<HeapItem>) {\n    while (\n      !heap.empty() &&\n      this._valueToPositionMap[heap.peek()!.value] === undefined\n    ) {\n      heap.pop();\n    }\n  }\n\n  _smallerComparator(lhs: HeapItem, rhs: HeapItem) {\n    return lhs.value < rhs.value;\n  }\n\n  _greaterComparator(lhs: HeapItem, rhs: HeapItem) {\n    return lhs.value > rhs.value;\n  }\n}\n\nexport default IntegerBufferSet;\n"],"names":["IntegerBufferSet","this","_valueToPositionMap","_size","_smallValues","Heap","_smallerComparator","_largeValues","_greaterComparator","getNewPositionForValue","bind","getValuePosition","getSize","replaceFurthestValuePosition","_proto","prototype","value","undefined","console","warn","newPosition","_pushToHeaps","getMinValue","_this$_smallValues$pe","peek","getMaxValue","_this$_largeValues$pe","lowValue","highValue","newValue","_cleanHeaps","empty","valueToReplace","minValue","maxValue","pop","position","element","push","_cleanHeap","minHeapSize","Math","min","size","max","_recreateHeaps","sourceHeap","newSmallValues","newLargeValues","heap","lhs","rhs","key","get","indices"],"mappings":"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"}

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

@@ -0,0 +1,158 @@
+import Heap from '@x-oasis/heap';
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+var IntegerBufferSet = /*#__PURE__*/function () {
+  function IntegerBufferSet() {
+    this._valueToPositionMap = {};
+    this._size = 0;
+    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);
+  }
+  var _proto = IntegerBufferSet.prototype;
+  _proto.getSize = function getSize() {
+    return this._size;
+  };
+  _proto.getValuePosition = function getValuePosition(value) {
+    if (this._valueToPositionMap[value] === undefined) {
+      return null;
+    }
+    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");
+    }
+    var newPosition = this._size;
+    this._size++;
+    this._pushToHeaps(newPosition, value);
+    this._valueToPositionMap[value] = newPosition;
+    return newPosition;
+  };
+  _proto.getMinValue = function getMinValue() {
+    var _this$_smallValues$pe;
+    return (_this$_smallValues$pe = this._smallValues.peek()) == null ? void 0 : _this$_smallValues$pe.value;
+  };
+  _proto.getMaxValue = function getMaxValue() {
+    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) {
+    if (this._valueToPositionMap[newValue] !== undefined) {
+      console.warn("Shouldn't try to replace values with value already stored value in " + 'BufferSet');
+    }
+    this._cleanHeaps();
+    if (this._smallValues.empty() || this._largeValues.empty()) {
+      return null;
+    }
+    var minValue = this._smallValues.peek().value;
+    var maxValue = this._largeValues.peek().value;
+    if (minValue >= lowValue && maxValue <= highValue) {
+      return null;
+    }
+    var valueToReplace;
+    if (lowValue - minValue > maxValue - highValue) {
+      valueToReplace = minValue;
+      this._smallValues.pop();
+    } else {
+      valueToReplace = maxValue;
+      this._largeValues.pop();
+    }
+    var position = this._valueToPositionMap[valueToReplace];
+    delete this._valueToPositionMap[valueToReplace];
+    this._valueToPositionMap[newValue] = position;
+    this._pushToHeaps(position, newValue);
+    return position;
+  };
+  _proto._pushToHeaps = function _pushToHeaps(position, value) {
+    var element = {
+      position: position,
+      value: value
+    };
+    this._smallValues.push(element);
+    this._largeValues.push(element);
+  };
+  _proto._cleanHeaps = function _cleanHeaps() {
+    this._cleanHeap(this._smallValues);
+    this._cleanHeap(this._largeValues);
+    var minHeapSize = Math.min(this._smallValues.size(), this._largeValues.size());
+    var maxHeapSize = Math.max(this._smallValues.size(), this._largeValues.size());
+    if (maxHeapSize > 10 * minHeapSize) {
+      this._recreateHeaps();
+    }
+  };
+  _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) {
+        newSmallValues.push(element);
+        newLargeValues.push(element);
+      }
+    }
+    this._smallValues = newSmallValues;
+    this._largeValues = newLargeValues;
+  };
+  _proto._cleanHeap = function _cleanHeap(heap) {
+    while (!heap.empty() && this._valueToPositionMap[heap.peek().value] === undefined) {
+      heap.pop();
+    }
+  };
+  _proto._smallerComparator = function _smallerComparator(lhs, rhs) {
+    return lhs.value < rhs.value;
+  };
+  _proto._greaterComparator = function _greaterComparator(lhs, rhs) {
+    return lhs.value > rhs.value;
+  };
+  _createClass(IntegerBufferSet, [{
+    key: "indices",
+    get: function get() {
+      var indices = [];
+      for (var key in this._valueToPositionMap) {
+        var value = this._valueToPositionMap[key];
+        indices[value] = key;
+      }
+      return indices;
+    }
+  }]);
+  return IntegerBufferSet;
+}();
+
+export default IntegerBufferSet;
+//# sourceMappingURL=integer-buffer-set.esm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integer-buffer-set.esm.js","sources":["../src/index.ts"],"sourcesContent":["// import invariant from 'invariant';\nimport Heap from '@x-oasis/heap';\n\ntype HeapItem = {\n  position: number;\n  value: number;\n};\n\n// Data structure that allows to store values and assign positions to them\n// in a way to minimize changing positions of stored values when new ones are\n// added or when some values are replaced. Stored elements are alwasy assigned\n// a consecutive set of positoins startin from 0 up to count of elements less 1\n// Following actions can be executed\n// * get position assigned to given value (null if value is not stored)\n// * create new entry for new value and get assigned position back\n// * replace value that is furthest from specified value range with new value\n//   and get it's position back\n// All operations take amortized log(n) time where n is number of elements in\n// the set.\nclass IntegerBufferSet {\n  private _size: number;\n  private _valueToPositionMap: {\n    [key: string]: number;\n  };\n  private _smallValues: Heap<HeapItem>;\n  private _largeValues: Heap<HeapItem>;\n\n  constructor() {\n    this._valueToPositionMap = {};\n    this._size = 0;\n    this._smallValues = new Heap([], this._smallerComparator);\n    this._largeValues = new Heap([], this._greaterComparator);\n\n    this.getNewPositionForValue = this.getNewPositionForValue.bind(this);\n    this.getValuePosition = this.getValuePosition.bind(this);\n    this.getSize = this.getSize.bind(this);\n    this.replaceFurthestValuePosition =\n      this.replaceFurthestValuePosition.bind(this);\n  }\n\n  getSize() {\n    return this._size;\n  }\n\n  get indices() {\n    const indices = [];\n    for (const key in this._valueToPositionMap) {\n      const value = this._valueToPositionMap[key];\n      indices[value] = key;\n    }\n    return indices;\n  }\n\n  getValuePosition(value: number): null | number {\n    if (this._valueToPositionMap[value] === undefined) {\n      return null;\n    }\n    return this._valueToPositionMap[value];\n  }\n\n  getNewPositionForValue(value: number) {\n    if (this._valueToPositionMap[value] !== undefined) {\n      console.warn(\n        \"Shouldn't try to find new position for value already stored in BufferSet\"\n      );\n    }\n    // invariant(\n    //   this._valueToPositionMap[value] === undefined,\n    //   \"Shouldn't try to find new position for value already stored in BufferSet\"\n    // );\n    const newPosition = this._size;\n    this._size++;\n    this._pushToHeaps(newPosition, value);\n    this._valueToPositionMap[value] = newPosition;\n    return newPosition;\n  }\n\n  getMinValue() {\n    return this._smallValues.peek()?.value;\n  }\n\n  getMaxValue() {\n    return this._largeValues.peek()?.value;\n  }\n\n  replaceFurthestValuePosition(\n    lowValue: number,\n    highValue: number,\n    newValue: number\n  ): null | number {\n    if (this._valueToPositionMap[newValue] !== undefined) {\n      console.warn(\n        \"Shouldn't try to replace values with value already stored value in \" +\n          'BufferSet'\n      );\n    }\n    // invariant(\n    //   this._valueToPositionMap[newValue] === undefined,\n    //   \"Shouldn't try to replace values with value already stored value in \" +\n    //     'BufferSet'\n    // );\n\n    this._cleanHeaps();\n    if (this._smallValues.empty() || this._largeValues.empty()) {\n      // Threre are currently no values stored. We will have to create new\n      // position for this value.\n      return null;\n    }\n\n    const minValue = this._smallValues.peek()!.value;\n    const maxValue = this._largeValues.peek()!.value;\n    if (minValue >= lowValue && maxValue <= highValue) {\n      // All values currently stored are necessary, we can't reuse any of them.\n      return null;\n    }\n\n    let valueToReplace;\n    if (lowValue - minValue > maxValue - highValue) {\n      // minValue is further from provided range. We will reuse it's position.\n      valueToReplace = minValue;\n      this._smallValues.pop();\n    } else {\n      valueToReplace = maxValue;\n      this._largeValues.pop();\n    }\n    const position = this._valueToPositionMap[valueToReplace];\n    delete this._valueToPositionMap[valueToReplace];\n    this._valueToPositionMap[newValue] = position;\n    this._pushToHeaps(position, newValue);\n\n    return position;\n  }\n\n  _pushToHeaps(position: number, value: number) {\n    const element = {\n      position,\n      value,\n    };\n    // We can reuse the same object in both heaps, because we don't mutate them\n    this._smallValues.push(element);\n    this._largeValues.push(element);\n  }\n\n  _cleanHeaps() {\n    // We not usually only remove object from one heap while moving value.\n    // Here we make sure that there is no stale data on top of heaps.\n    this._cleanHeap(this._smallValues);\n    this._cleanHeap(this._largeValues);\n    const minHeapSize = Math.min(\n      this._smallValues.size(),\n      this._largeValues.size()\n    );\n    const maxHeapSize = Math.max(\n      this._smallValues.size(),\n      this._largeValues.size()\n    );\n    if (maxHeapSize > 10 * minHeapSize) {\n      // There are many old values in one of heaps. We need to get rid of them\n      // to not use too avoid memory leaks\n      this._recreateHeaps();\n    }\n  }\n\n  _recreateHeaps() {\n    const sourceHeap =\n      this._smallValues.size() < this._largeValues.size()\n        ? this._smallValues\n        : this._largeValues;\n    const newSmallValues = new Heap<HeapItem>(\n      [], // Initial data in the heap\n      this._smallerComparator\n    );\n    const newLargeValues = new Heap<HeapItem>(\n      [], // Initial datat in the heap\n      this._greaterComparator\n    );\n    while (!sourceHeap.empty()) {\n      const element = sourceHeap.pop()!;\n      // Push all stil valid elements to new heaps\n      if (this._valueToPositionMap[element.value] !== undefined) {\n        newSmallValues.push(element);\n        newLargeValues.push(element);\n      }\n    }\n    this._smallValues = newSmallValues;\n    this._largeValues = newLargeValues;\n  }\n\n  _cleanHeap(heap: Heap<HeapItem>) {\n    while (\n      !heap.empty() &&\n      this._valueToPositionMap[heap.peek()!.value] === undefined\n    ) {\n      heap.pop();\n    }\n  }\n\n  _smallerComparator(lhs: HeapItem, rhs: HeapItem) {\n    return lhs.value < rhs.value;\n  }\n\n  _greaterComparator(lhs: HeapItem, rhs: HeapItem) {\n    return lhs.value > rhs.value;\n  }\n}\n\nexport default IntegerBufferSet;\n"],"names":["IntegerBufferSet","_valueToPositionMap","_size","_smallValues","Heap","_smallerComparator","_largeValues","_greaterComparator","getNewPositionForValue","bind","getValuePosition","getSize","replaceFurthestValuePosition","_proto","prototype","value","undefined","console","warn","newPosition","_pushToHeaps","getMinValue","_this$_smallValues$pe","peek","getMaxValue","_this$_largeValues$pe","lowValue","highValue","newValue","_cleanHeaps","empty","minValue","maxValue","valueToReplace","pop","position","element","push","_cleanHeap","minHeapSize","Math","min","size","maxHeapSize","max","_recreateHeaps","sourceHeap","newSmallValues","newLargeValues","heap","lhs","rhs","_createClass","key","get","indices"],"mappings":"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"}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@x-oasis/integer-buffer-set",
+  "version": "0.0.18",
+  "description": "IntegerBufferSet function",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "module": "dist/integer-buffer-set.esm.js",
+  "files": [
+    "dist",
+    "index.ts",
+    "src"
+  ],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "tsdx": "^0.14.1",
+    "@x-oasis/heap": "0.0.18"
+  },
+  "scripts": {
+    "build": "tsdx build --tsconfig tsconfig.build.json",
+    "clean": "rimraf ./dist",
+    "test": "vitest",
+    "compile": "tsc -p tsconfig.build.json"
+  }
+}

package/src/index.ts

@@ -0,0 +1,207 @@
+// import invariant from 'invariant';
+import Heap from '@x-oasis/heap';
+
+type HeapItem = {
+  position: number;
+  value: number;
+};
+
+// Data structure that allows to store values and assign positions to them
+// in a way to minimize changing positions of stored values when new ones are
+// added or when some values are replaced. Stored elements are alwasy assigned
+// a consecutive set of positoins startin from 0 up to count of elements less 1
+// Following actions can be executed
+// * get position assigned to given value (null if value is not stored)
+// * create new entry for new value and get assigned position back
+// * replace value that is furthest from specified value range with new value
+//   and get it's position back
+// All operations take amortized log(n) time where n is number of elements in
+// the set.
+class IntegerBufferSet {
+  private _size: number;
+  private _valueToPositionMap: {
+    [key: string]: number;
+  };
+  private _smallValues: Heap<HeapItem>;
+  private _largeValues: Heap<HeapItem>;
+
+  constructor() {
+    this._valueToPositionMap = {};
+    this._size = 0;
+    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);
+  }
+
+  getSize() {
+    return this._size;
+  }
+
+  get indices() {
+    const indices = [];
+    for (const key in this._valueToPositionMap) {
+      const value = this._valueToPositionMap[key];
+      indices[value] = key;
+    }
+    return indices;
+  }
+
+  getValuePosition(value: number): null | number {
+    if (this._valueToPositionMap[value] === undefined) {
+      return null;
+    }
+    return this._valueToPositionMap[value];
+  }
+
+  getNewPositionForValue(value: number) {
+    if (this._valueToPositionMap[value] !== undefined) {
+      console.warn(
+        "Shouldn't try to find new position for value already stored in BufferSet"
+      );
+    }
+    // invariant(
+    //   this._valueToPositionMap[value] === undefined,
+    //   "Shouldn't try to find new position for value already stored in BufferSet"
+    // );
+    const newPosition = this._size;
+    this._size++;
+    this._pushToHeaps(newPosition, value);
+    this._valueToPositionMap[value] = newPosition;
+    return newPosition;
+  }
+
+  getMinValue() {
+    return this._smallValues.peek()?.value;
+  }
+
+  getMaxValue() {
+    return this._largeValues.peek()?.value;
+  }
+
+  replaceFurthestValuePosition(
+    lowValue: number,
+    highValue: number,
+    newValue: number
+  ): null | number {
+    if (this._valueToPositionMap[newValue] !== undefined) {
+      console.warn(
+        "Shouldn't try to replace values with value already stored value in " +
+          'BufferSet'
+      );
+    }
+    // invariant(
+    //   this._valueToPositionMap[newValue] === undefined,
+    //   "Shouldn't try to replace values with value already stored value in " +
+    //     'BufferSet'
+    // );
+
+    this._cleanHeaps();
+    if (this._smallValues.empty() || this._largeValues.empty()) {
+      // Threre are currently no values stored. We will have to create new
+      // position for this value.
+      return null;
+    }
+
+    const minValue = this._smallValues.peek()!.value;
+    const maxValue = this._largeValues.peek()!.value;
+    if (minValue >= lowValue && maxValue <= highValue) {
+      // All values currently stored are necessary, we can't reuse any of them.
+      return null;
+    }
+
+    let valueToReplace;
+    if (lowValue - minValue > maxValue - highValue) {
+      // minValue is further from provided range. We will reuse it's position.
+      valueToReplace = minValue;
+      this._smallValues.pop();
+    } else {
+      valueToReplace = maxValue;
+      this._largeValues.pop();
+    }
+    const position = this._valueToPositionMap[valueToReplace];
+    delete this._valueToPositionMap[valueToReplace];
+    this._valueToPositionMap[newValue] = position;
+    this._pushToHeaps(position, newValue);
+
+    return position;
+  }
+
+  _pushToHeaps(position: number, value: number) {
+    const element = {
+      position,
+      value,
+    };
+    // We can reuse the same object in both heaps, because we don't mutate them
+    this._smallValues.push(element);
+    this._largeValues.push(element);
+  }
+
+  _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);
+    const minHeapSize = Math.min(
+      this._smallValues.size(),
+      this._largeValues.size()
+    );
+    const maxHeapSize = Math.max(
+      this._smallValues.size(),
+      this._largeValues.size()
+    );
+    if (maxHeapSize > 10 * minHeapSize) {
+      // There are many old values in one of heaps. We need to get rid of them
+      // to not use too avoid memory leaks
+      this._recreateHeaps();
+    }
+  }
+
+  _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 stil valid elements to new heaps
+      if (this._valueToPositionMap[element.value] !== undefined) {
+        newSmallValues.push(element);
+        newLargeValues.push(element);
+      }
+    }
+    this._smallValues = newSmallValues;
+    this._largeValues = newLargeValues;
+  }
+
+  _cleanHeap(heap: Heap<HeapItem>) {
+    while (
+      !heap.empty() &&
+      this._valueToPositionMap[heap.peek()!.value] === undefined
+    ) {
+      heap.pop();
+    }
+  }
+
+  _smallerComparator(lhs: HeapItem, rhs: HeapItem) {
+    return lhs.value < rhs.value;
+  }
+
+  _greaterComparator(lhs: HeapItem, rhs: HeapItem) {
+    return lhs.value > rhs.value;
+  }
+}
+
+export default IntegerBufferSet;