@x-oasis/prefix-interval-tree 0.2.2 → 0.2.4

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+declare type OperationType = 'set' | 'remove';
 declare class PrefixIntervalTree {
     private _size;
     private _half;
@@ -5,7 +6,10 @@ declare class PrefixIntervalTree {
     private _actualSize;
     private _onUpdateItemLayout;
     private _onUpdateIntervalTree;
-    constructor(xs: number[] | number, opts?: {
+    private _affectedIndicesMap;
+    private _affectedMinimalIndex;
+    private _cachedSumUntilValues;
+    constructor(xs?: number[] | number, opts?: {
         onUpdateItemLayout?: Function;
         onUpdateIntervalTree?: Function;
     });
@@ -14,12 +18,21 @@ declare class PrefixIntervalTree {
     static uniform(size: number, initialValue: number): PrefixIntervalTree;
     static empty(size: number): PrefixIntervalTree;
     stretch(): void;
+    indexKey(index: number): string;
+    resolveKeyIndex(key: string): number;
     isValidIndex(index: number): boolean;
-    reflowHeap(startIndex: number, endIndex?: number): void;
+    reflowDirectParent(index: number): void;
+    reflowHeap(_startIndex: number, endIndex?: number): void;
+    dryRemove(index: number): void;
     remove(index: number): void;
-    batchRemove(indices: number[]): void;
+    removeIndices(indices: number[]): void;
     removeV0(index: number): void;
+    resetAffected(): void;
+    updateAffectedIndices(index: number, type: OperationType, value?: number): void;
+    onUpdateIntervalTree(): void;
+    drySet(index: number, value: number): boolean;
     set(index: number, value: number): boolean;
+    applyUpdate(): void;
     getMaxUsefulLength(): number;
     getActualSize(): number;
     get(index: number): number;

package/dist/prefix-interval-tree.cjs.development.js

@@ -21,6 +21,12 @@ function ceilLog2(x) {
 }
 var PrefixIntervalTree = /*#__PURE__*/function () {
   function PrefixIntervalTree(xs, opts) {
+    if (xs === void 0) {
+      xs = 10;
+    }
+    this._affectedIndicesMap = {};
+    this._affectedMinimalIndex = undefined;
+    this._cachedSumUntilValues = {};
     if (typeof xs === 'number') this.initWithNumber(xs);
     if (Array.isArray(xs)) this.initWithArray(xs);
     var _ref = opts || {},
@@ -72,17 +78,33 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     this._size = nextHeapHalf;
     this._heap = nextHeap;
   };
+  _proto.indexKey = function indexKey(index) {
+    return "" + index;
+  };
+  _proto.resolveKeyIndex = function resolveKeyIndex(key) {
+    return parseInt(key, 10);
+  };
   _proto.isValidIndex = function isValidIndex(index) {
     return typeof index === 'number' && index >= 0 && index < this._actualSize;
   };
-  _proto.reflowHeap = function reflowHeap(startIndex, endIndex) {
+  _proto.reflowDirectParent = function reflowDirectParent(index) {
+    this.resetAffected();
+    var node = this._half + index;
+    node = parent(node);
+    for (; node !== 0; node = parent(node)) {
+      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];
+    }
+  };
+  _proto.reflowHeap = function reflowHeap(_startIndex, endIndex) {
     var _this = this;
     if (endIndex === void 0) {
       endIndex = this._half * 2 - 2;
     }
-    var len = Math.log2(this._size);
+    this.resetAffected();
+    var depth = Math.log2(this._size);
+    var startIndex = _startIndex + this._half;
     Array.from({
-      length: len
+      length: depth
     }, function (v, i) {
       return i;
     }).reduce(function (acc) {
@@ -102,28 +124,30 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
       endIndex: endIndex
     });
   };
+  _proto.dryRemove = function dryRemove(index) {
+    if (!this.isValidIndex(index)) return;
+    if (isNaN(index)) {
+      console.warn('Passing a NaN value as interval tree index');
+      return;
+    }
+    this._heap.splice(this._half + index, 1);
+    this._heap.push(0);
+    this._actualSize = this._actualSize - 1;
+    this.updateAffectedIndices(index, 'remove');
+  };
   _proto.remove = function remove(index) {
-    this.batchRemove([index]);
+    this.removeIndices([index]);
   };
-  _proto.batchRemove = function batchRemove(indices) {
+  _proto.removeIndices = function removeIndices(indices) {
     var _this2 = this;
     indices.sort(function (a, b) {
       return a - b;
     });
     indices.forEach(function (index) {
-      if (!_this2.isValidIndex(index)) return;
-      if (isNaN(index)) {
-        console.warn('Passing a NaN value as interval tree index');
-        return;
-      }
-      _this2._heap.splice(_this2._half + index, 1);
-      _this2._heap.push(0);
-      _this2._actualSize = _this2._actualSize - 1;
+      return _this2.dryRemove(index);
     });
-    this.reflowHeap(indices[0] + this._half);
-    if (typeof this._onUpdateIntervalTree === 'function') {
-      this._onUpdateIntervalTree(this._heap);
-    }
+    this.reflowHeap(indices[0]);
+    this.onUpdateIntervalTree();
     if (typeof this._onUpdateItemLayout === 'function') {
       for (var idx = indices[0]; idx < this._half; idx++) {
         this._onUpdateItemLayout(idx, this.get(idx));
@@ -148,7 +172,26 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     this._actualSize = this._actualSize - 1;
     this._heap = nextHeap;
   };
-  _proto.set = function set(index, value) {
+  _proto.resetAffected = function resetAffected() {
+    this._affectedIndicesMap = {};
+    this._affectedMinimalIndex = undefined;
+  };
+  _proto.updateAffectedIndices = function updateAffectedIndices(index, type, value) {
+    if (typeof index === 'number') {
+      this._affectedMinimalIndex = typeof this._affectedMinimalIndex === 'number' ? Math.min(this._affectedMinimalIndex, index) : index;
+      this._affectedIndicesMap[this.indexKey(index)] = {
+        value: value,
+        type: type
+      };
+    }
+  };
+  _proto.onUpdateIntervalTree = function onUpdateIntervalTree() {
+    this._cachedSumUntilValues = {};
+    if (typeof this._onUpdateIntervalTree === 'function') {
+      this._onUpdateIntervalTree(this._heap);
+    }
+  };
+  _proto.drySet = function drySet(index, value) {
     if (typeof index !== 'number' || index < 0) return false;
     if (isNaN(index)) {
       console.warn('Passing a NaN value as interval tree index');
@@ -159,21 +202,45 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     }
     var node = this._half + index;
     this._heap[node] = value;
-    node = parent(node);
-    for (; node !== 0; node = parent(node)) {
-      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];
-    }
+    this.updateAffectedIndices(index, 'set', value);
     if (index + 1 > this._actualSize) {
       this._actualSize = index + 1;
     }
-    if (typeof this._onUpdateIntervalTree === 'function') {
-      this._onUpdateIntervalTree(this._heap);
-    }
+    return true;
+  };
+  _proto.set = function set(index, value) {
+    this.drySet(index, value);
+    this.reflowDirectParent(index);
+    this.onUpdateIntervalTree();
     if (typeof this._onUpdateItemLayout === 'function') {
       this._onUpdateItemLayout(index, value);
     }
     return true;
   };
+  _proto.applyUpdate = function applyUpdate() {
+    var _this3 = this;
+    if (typeof this._affectedMinimalIndex === 'number') {
+      var index = this._affectedMinimalIndex;
+      var keys = Object.keys(this._affectedIndicesMap);
+      var hasRemoveItem = keys.some(function (key) {
+        return _this3._affectedIndicesMap[key].type === 'remove';
+      });
+      if (hasRemoveItem) {
+        return this.reflowHeap(index);
+      }
+      var depth = Math.log2(this._size);
+      var itemLength = keys.length;
+      var reflowTimes = this._half - index - 1;
+      if (depth * itemLength > reflowTimes) {
+        return this.reflowHeap(index);
+      }
+      keys.forEach(function (key) {
+        return _this3.reflowDirectParent(_this3.resolveKeyIndex(key));
+      });
+      this.onUpdateIntervalTree();
+      this.resetAffected();
+    }
+  };
   _proto.getMaxUsefulLength = function getMaxUsefulLength() {
     return this.getActualSize();
   };
@@ -197,6 +264,7 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     return this._heap[1];
   };
   _proto.sumUntil = function sumUntil(end) {
+    if (this._cachedSumUntilValues["" + end] != null) return this._cachedSumUntilValues["" + end];
     if (end <= 0) {
       return 0;
     }
@@ -216,12 +284,12 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     return this.sumUntil(end) - this.sumUntil(begin);
   };
   _proto.greatestLowerBound = function greatestLowerBound(t) {
-    if (t < 0) {
+    if (t < 0 || !this._actualSize) {
       return -1;
     }
     var node = 1;
     if (this._heap[node] < t) {
-      return Math.max(this._actualSize - 1, 0);
+      return this._actualSize;
     }
     while (node < this._half) {
       var leftSum = this._heap[2 * node];
@@ -232,15 +300,15 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
         t -= leftSum;
       }
     }
-    return Math.min(node - this._half, this._actualSize - 1);
+    return Math.min(node - this._half, this._actualSize);
   };
   _proto.greatestStrictLowerBound = function greatestStrictLowerBound(t) {
-    if (t <= 0) {
+    if (t <= 0 || !this._actualSize) {
       return -1;
     }
     var node = 1;
     if (this._heap[node] < t) {
-      return Math.max(this._actualSize - 1, 0);
+      return this._actualSize;
     }
     while (node < this._half) {
       var leftSum = this._heap[2 * node];
@@ -251,7 +319,7 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
         t -= leftSum;
       }
     }
-    return Math.min(node - this._half, this._actualSize - 1);
+    return Math.min(node - this._half, this._actualSize);
   };
   _proto.computeRange = function computeRange(minOffset, maxOffset) {
     if (this.getHeap()[1] < minOffset) {
@@ -266,10 +334,10 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     };
   };
   _proto.leastUpperBound = function leastUpperBound(t) {
-    return this.greatestStrictLowerBound(t) + 1;
+    return Math.min(this.greatestStrictLowerBound(t) + 1, this._actualSize);
   };
   _proto.leastStrictUpperBound = function leastStrictUpperBound(t) {
-    return this.greatestLowerBound(t) + 1;
+    return Math.min(this.greatestLowerBound(t) + 1, this._actualSize);
   };
   return PrefixIntervalTree;
 }();

package/dist/prefix-interval-tree.cjs.development.js.map

@@ -1 +1 @@
-{"version":3,"file":"prefix-interval-tree.cjs.development.js","sources":["../src/index.ts"],"sourcesContent":["const parent = (node: number) => Math.floor(node / 2);\n\nconst createArray = function (size: number) {\n  const xs = [];\n  for (let i = size - 1; i >= 0; --i) {\n    xs[i] = 0;\n  }\n  return xs;\n};\n\n/**\n * Computes the next power of 2 after or equal to x.\n */\nfunction ceilLog2(x: number) {\n  let y = 1;\n  while (y < x) {\n    y *= 2;\n  }\n\n  return y;\n}\n\n/**\n * A prefix interval tree stores an numeric array and the partial sums of that\n * array. It is optimized for updating the values of the array without\n * recomputing all of the partial sums.\n *\n *   - O(ln n) update\n *   - O(1) lookup\n *   - O(ln n) compute a partial sum\n *   - O(n) space\n *\n * Note that the sequence of partial sums is one longer than the array, so that\n * the first partial sum is always 0, and the last partial sum is the sum of the\n * entire array.\n */\nclass PrefixIntervalTree {\n  private _size: number;\n  /**\n   * Half the size of the heap. It is also the number of non-leaf nodes, and the\n   * index of the first element in the heap. Always a power of 2.\n   */\n  private _half: number;\n  private _heap: number[];\n\n  private _actualSize: number;\n\n  private _onUpdateItemLayout: Function;\n  private _onUpdateIntervalTree: Function;\n\n  constructor(\n    xs: number[] | number,\n    opts?: {\n      onUpdateItemLayout?: Function;\n      onUpdateIntervalTree?: Function;\n    }\n  ) {\n    if (typeof xs === 'number') this.initWithNumber(xs);\n    if (Array.isArray(xs)) this.initWithArray(xs);\n\n    const { onUpdateItemLayout, onUpdateIntervalTree } = opts || {};\n    this._onUpdateIntervalTree = onUpdateIntervalTree;\n    this._onUpdateItemLayout = onUpdateItemLayout;\n  }\n\n  initWithNumber(length: number) {\n    this._half = ceilLog2(length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    this._actualSize = 0;\n  }\n\n  initWithArray(arr: number[]) {\n    this._half = ceilLog2(arr.length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    let i;\n    for (i = 0; i < this._size; ++i) {\n      this._heap[this._half + i] = arr[i];\n    }\n\n    for (i = this._half - 1; i > 0; --i) {\n      this._heap[i] = this._heap[2 * i] + this._heap[2 * i + 1];\n    }\n    this._actualSize = arr.length;\n  }\n\n  static uniform(size: number, initialValue: number) {\n    const xs = [];\n    for (let i = size - 1; i >= 0; --i) {\n      xs[i] = initialValue;\n    }\n\n    return new PrefixIntervalTree(xs);\n  }\n\n  static empty(size: number) {\n    return PrefixIntervalTree.uniform(size, 0);\n  }\n\n  /**\n   * the length should be 2\n   */\n  stretch() {\n    const nextHeap = createArray(2 * this._half * 2);\n    const nextHeapHalf = this._half * 2;\n\n    // copy old value to new one\n    for (let i = 0; i < this._size; i++) {\n      nextHeap[nextHeapHalf + i] = this._heap[this._half + i] || 0;\n    }\n\n    // sum old value to create new sum value\n    for (let i = nextHeapHalf - 1; i > 0; i--) {\n      nextHeap[i] = nextHeap[2 * i] + nextHeap[2 * i + 1];\n    }\n\n    this._half = nextHeapHalf;\n    this._size = nextHeapHalf;\n    this._heap = nextHeap;\n  }\n\n  isValidIndex(index: number) {\n    return typeof index === 'number' && index >= 0 && index < this._actualSize;\n  }\n\n  reflowHeap(startIndex: number, endIndex = this._half * 2 - 2) {\n    const len = Math.log2(this._size);\n\n    Array.from({ length: len }, (v, i) => i).reduce(\n      (acc) => {\n        const { startIndex, endIndex } = acc;\n        const _nextStart = parent(startIndex);\n        const _nextEnd = parent(endIndex);\n\n        for (let idx = _nextStart; idx <= _nextEnd; idx++) {\n          this._heap[idx] = this._heap[2 * idx] + this._heap[2 * idx + 1];\n        }\n\n        return {\n          startIndex: _nextStart,\n          endIndex: _nextEnd,\n        };\n      },\n      {\n        startIndex,\n        endIndex,\n      }\n    );\n  }\n\n  remove(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n\n    this.batchRemove([index]);\n  }\n\n  batchRemove(indices: number[]) {\n    indices.sort((a, b) => a - b);\n\n    indices.forEach((index) => {\n      if (!this.isValidIndex(index)) return;\n      if (isNaN(index)) {\n        console.warn('Passing a NaN value as interval tree index');\n        return;\n      }\n\n      this._heap.splice(this._half + index, 1);\n      this._heap.push(0);\n      this._actualSize = this._actualSize - 1;\n    });\n\n    this.reflowHeap(indices[0] + this._half);\n    if (typeof this._onUpdateIntervalTree === 'function') {\n      this._onUpdateIntervalTree(this._heap);\n    }\n\n    if (typeof this._onUpdateItemLayout === 'function') {\n      for (let idx = indices[0]; idx < this._half; idx++) {\n        this._onUpdateItemLayout(idx, this.get(idx));\n      }\n    }\n  }\n\n  removeV0(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n    if (!this.isValidIndex(index)) return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\n    }\n\n    const nextHeap = createArray(this._half * 2);\n    const copy = this._heap.slice(this._half);\n    copy.splice(index, 1);\n\n    for (let index = this._half; index < this._half * 2; index++) {\n      nextHeap[index] = copy[index - this._half] || 0;\n    }\n\n    for (let index = this._half - 1; index > 0; index--) {\n      nextHeap[index] = nextHeap[2 * index] + nextHeap[2 * index + 1];\n    }\n\n    this._actualSize = this._actualSize - 1;\n    this._heap = nextHeap;\n  }\n\n  set(index: number, value: number) {\n    if (typeof index !== 'number' || index < 0) return false;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return false;\n    }\n\n    while (index >= this._half) {\n      this.stretch();\n    }\n\n    let node = this._half + index;\n    this._heap[node] = value;\n\n    node = parent(node);\n    for (; node !== 0; node = parent(node)) {\n      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];\n    }\n\n    if (index + 1 > this._actualSize) {\n      this._actualSize = index + 1;\n    }\n\n    if (typeof this._onUpdateIntervalTree === 'function') {\n      this._onUpdateIntervalTree(this._heap);\n    }\n\n    if (typeof this._onUpdateItemLayout === 'function') {\n      this._onUpdateItemLayout(index, value);\n    }\n    return true;\n  }\n\n  getMaxUsefulLength() {\n    return this.getActualSize();\n  }\n\n  getActualSize() {\n    return this._actualSize;\n  }\n\n  get(index: number) {\n    // invariant(index >= 0 && index < this._size, 'Index out of range %s', index);\n    const node = this._half + index;\n    return this._heap[node];\n  }\n\n  getSize() {\n    return this._size;\n  }\n\n  getHalf() {\n    return this._half;\n  }\n\n  getHeap() {\n    return this._heap;\n  }\n\n  getMaxValue() {\n    return this._heap[1];\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(end - 1).\n   * End is not included. if end less than 0, then return 0\n   */\n  sumUntil(end: number) {\n    // invariant(end >= 0 && end < this._size + 1, 'Index out of range %s', end);\n\n    if (end <= 0) {\n      return 0;\n    }\n\n    let node = this._half + end - 1;\n    let sum = this._heap[node];\n\n    for (; node !== 1; node = parent(node)) {\n      if (node % 2 === 1) {\n        sum += this._heap[node - 1];\n      }\n    }\n\n    return sum;\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(inclusiveEnd).\n   */\n  sumTo(inclusiveEnd: number) {\n    // invariant(\n    //   inclusiveEnd >= 0 && inclusiveEnd < this._size,\n    //   'Index out of range %s',\n    //   inclusiveEnd\n    // );\n    return this.sumUntil(inclusiveEnd + 1);\n  }\n\n  /**\n   * Returns the sum get(begin) + get(begin + 1) + ... + get(end - 1).\n   * end length is not included\n   */\n  sum(begin: number, end: number) {\n    // invariant(begin <= end, 'Begin must precede end');\n    return this.sumUntil(end) - this.sumUntil(begin);\n  }\n\n  /**\n   * return the biggest i, sumUntil(i) === t\n   * return the biggest i, subUntil(i) < t\n   */\n  greatestLowerBound(t: number) {\n    if (t < 0) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      // not use this._size；this._size always be a big value\n      return Math.max(this._actualSize - 1, 0);\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t < leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize - 1);\n  }\n\n  /**\n   * Return the biggest i, subUntil(i) < t\n   * or -1 if no such i exists.\n   */\n  greatestStrictLowerBound(t: number) {\n    if (t <= 0) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      return Math.max(this._actualSize - 1, 0);\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t <= leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize - 1);\n  }\n\n  /**\n   *\n   * @param minOffset\n   * @param maxOffset\n   * @returns\n   *\n   * pending issue:\n   * when item with length list [100, 0, 100, 0, 0, 100].\n   * then computeRange(100, 200) => { startIndex: 2, endIndex: 6 }\n   *\n   * item index in viewport will be [2, 3, 4, 5], index 6 is not\n   * included just like Array.slice(start, end)\n   *\n   */\n  computeRange(minOffset: number, maxOffset: number) {\n    if (this.getHeap()[1] < minOffset) {\n      return {\n        startIndex: this._actualSize,\n        endIndex: this._actualSize,\n      };\n    }\n\n    return {\n      // the biggest item, value <= minOffset\n      startIndex: this.greatestLowerBound(minOffset),\n\n      // the smallest item, value > maxOffset\n      endIndex: this.leastStrictUpperBound(maxOffset),\n    };\n  }\n\n  /**\n   * Returns the smallest i such that 0 <= i <= size and t <= sumUntil(i), or\n   * size + 1 if no such i exists.\n   */\n  leastUpperBound(t: number) {\n    return this.greatestStrictLowerBound(t) + 1;\n  }\n\n  /**\n   * Returns the smallest i, t < sumUntil(i), it should be used as range end\n   * size + 1 if no such i exists.\n   */\n  leastStrictUpperBound(t: number) {\n    return this.greatestLowerBound(t) + 1;\n  }\n}\n\nexport default PrefixIntervalTree;\n"],"names":["parent","node","Math","floor","createArray","size","xs","i","ceilLog2","x","y","PrefixIntervalTree","opts","initWithNumber","Array","isArray","initWithArray","_ref","onUpdateItemLayout","onUpdateIntervalTree","_onUpdateIntervalTree","_onUpdateItemLayout","_proto","prototype","length","_half","_size","_heap","_actualSize","arr","uniform","initialValue","empty","stretch","nextHeap","nextHeapHalf","isValidIndex","index","reflowHeap","startIndex","endIndex","len","log2","from","v","reduce","acc","_nextStart","_nextEnd","idx","_this","remove","batchRemove","indices","sort","a","b","forEach","_this2","isNaN","console","warn","splice","push","get","removeV0","copy","slice","set","value","getMaxUsefulLength","getActualSize","getSize","getHalf","getHeap","getMaxValue","sumUntil","end","sum","sumTo","inclusiveEnd","begin","greatestLowerBound","t","max","leftSum","min","greatestStrictLowerBound","computeRange","minOffset","maxOffset","leastStrictUpperBound","leastUpperBound"],"mappings":"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"}
+{"version":3,"file":"prefix-interval-tree.cjs.development.js","sources":["../src/index.ts"],"sourcesContent":["const parent = (node: number) => Math.floor(node / 2);\n\nconst createArray = function (size: number) {\n  const xs = [];\n  for (let i = size - 1; i >= 0; --i) {\n    xs[i] = 0;\n  }\n  return xs;\n};\n\n/**\n * Computes the next power of 2 after or equal to x.\n */\nfunction ceilLog2(x: number) {\n  let y = 1;\n  while (y < x) {\n    y *= 2;\n  }\n\n  return y;\n}\n\ntype OperationType = 'set' | 'remove';\n\ntype Operation = {\n  type: OperationType;\n  value: any;\n};\n\n/**\n * A prefix interval tree stores an numeric array and the partial sums of that\n * array. It is optimized for updating the values of the array without\n * recomputing all of the partial sums.\n *\n *   - O(ln n) update\n *   - O(1) lookup\n *   - O(ln n) compute a partial sum\n *   - O(n) space\n *\n * Note that the sequence of partial sums is one longer than the array, so that\n * the first partial sum is always 0, and the last partial sum is the sum of the\n * entire array.\n */\nclass PrefixIntervalTree {\n  private _size: number;\n  /**\n   * Half the size of the heap. It is also the number of non-leaf nodes, and the\n   * index of the first element in the heap. Always a power of 2.\n   */\n  private _half: number;\n  private _heap: number[];\n\n  private _actualSize: number;\n\n  private _onUpdateItemLayout: Function;\n  private _onUpdateIntervalTree: Function;\n\n  private _affectedIndicesMap: {\n    [key: string]: Operation;\n  } = {};\n  private _affectedMinimalIndex: number = undefined;\n  private _cachedSumUntilValues: {\n    [key: string]: number;\n  } = {};\n\n  constructor(\n    xs: number[] | number = 10,\n    opts?: {\n      onUpdateItemLayout?: Function;\n      onUpdateIntervalTree?: Function;\n    }\n  ) {\n    if (typeof xs === 'number') this.initWithNumber(xs);\n    if (Array.isArray(xs)) this.initWithArray(xs);\n\n    const { onUpdateItemLayout, onUpdateIntervalTree } = opts || {};\n    this._onUpdateIntervalTree = onUpdateIntervalTree;\n    this._onUpdateItemLayout = onUpdateItemLayout;\n  }\n\n  initWithNumber(length: number) {\n    this._half = ceilLog2(length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    this._actualSize = 0;\n  }\n\n  initWithArray(arr: number[]) {\n    this._half = ceilLog2(arr.length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    let i;\n    for (i = 0; i < this._size; ++i) {\n      this._heap[this._half + i] = arr[i];\n    }\n\n    for (i = this._half - 1; i > 0; --i) {\n      this._heap[i] = this._heap[2 * i] + this._heap[2 * i + 1];\n    }\n    this._actualSize = arr.length;\n  }\n\n  static uniform(size: number, initialValue: number) {\n    const xs = [];\n    for (let i = size - 1; i >= 0; --i) {\n      xs[i] = initialValue;\n    }\n\n    return new PrefixIntervalTree(xs);\n  }\n\n  static empty(size: number) {\n    return PrefixIntervalTree.uniform(size, 0);\n  }\n\n  /**\n   * the length should be 2\n   * it will cause calculation of\n   */\n  stretch() {\n    const nextHeap = createArray(2 * this._half * 2);\n    const nextHeapHalf = this._half * 2;\n\n    // copy old value to new one\n    for (let i = 0; i < this._size; i++) {\n      nextHeap[nextHeapHalf + i] = this._heap[this._half + i] || 0;\n    }\n\n    // sum old value to create new sum value\n    for (let i = nextHeapHalf - 1; i > 0; i--) {\n      nextHeap[i] = nextHeap[2 * i] + nextHeap[2 * i + 1];\n    }\n\n    this._half = nextHeapHalf;\n    this._size = nextHeapHalf;\n    this._heap = nextHeap;\n  }\n\n  indexKey(index: number) {\n    return `${index}`;\n  }\n\n  resolveKeyIndex(key: string) {\n    return parseInt(key, 10);\n  }\n\n  isValidIndex(index: number) {\n    return typeof index === 'number' && index >= 0 && index < this._actualSize;\n  }\n\n  reflowDirectParent(index: number) {\n    this.resetAffected();\n    let node = this._half + index;\n\n    node = parent(node);\n    for (; node !== 0; node = parent(node)) {\n      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];\n    }\n  }\n\n  // recalculate parent value from startIndex to endIndex\n  reflowHeap(_startIndex: number, endIndex = this._half * 2 - 2) {\n    this.resetAffected();\n    const depth = Math.log2(this._size);\n    const startIndex = _startIndex + this._half;\n\n    Array.from({ length: depth }, (v, i) => i).reduce(\n      (acc) => {\n        const { startIndex, endIndex } = acc;\n        const _nextStart = parent(startIndex);\n        const _nextEnd = parent(endIndex);\n\n        for (let idx = _nextStart; idx <= _nextEnd; idx++) {\n          this._heap[idx] = this._heap[2 * idx] + this._heap[2 * idx + 1];\n        }\n\n        return {\n          startIndex: _nextStart,\n          endIndex: _nextEnd,\n        };\n      },\n      {\n        startIndex,\n        endIndex,\n      }\n    );\n  }\n\n  /**\n   *\n   * @param index index to remove\n   * @returns\n   *\n   * update heap only, but not recalculate interval tree value\n   */\n  dryRemove(index: number) {\n    if (!this.isValidIndex(index)) return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\n    }\n\n    this._heap.splice(this._half + index, 1);\n    this._heap.push(0);\n    this._actualSize = this._actualSize - 1;\n\n    this.updateAffectedIndices(index, 'remove');\n  }\n\n  remove(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n\n    this.removeIndices([index]);\n  }\n\n  removeIndices(indices: number[]) {\n    indices.sort((a, b) => a - b);\n\n    indices.forEach((index) => this.dryRemove(index));\n\n    this.reflowHeap(indices[0]);\n    this.onUpdateIntervalTree();\n\n    if (typeof this._onUpdateItemLayout === 'function') {\n      for (let idx = indices[0]; idx < this._half; idx++) {\n        this._onUpdateItemLayout(idx, this.get(idx));\n      }\n    }\n  }\n\n  removeV0(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n    if (!this.isValidIndex(index)) return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\n    }\n\n    const nextHeap = createArray(this._half * 2);\n    const copy = this._heap.slice(this._half);\n    copy.splice(index, 1);\n\n    for (let index = this._half; index < this._half * 2; index++) {\n      nextHeap[index] = copy[index - this._half] || 0;\n    }\n\n    for (let index = this._half - 1; index > 0; index--) {\n      nextHeap[index] = nextHeap[2 * index] + nextHeap[2 * index + 1];\n    }\n\n    this._actualSize = this._actualSize - 1;\n    this._heap = nextHeap;\n  }\n\n  resetAffected() {\n    this._affectedIndicesMap = {};\n    this._affectedMinimalIndex = undefined;\n  }\n\n  updateAffectedIndices(index: number, type: OperationType, value?: number) {\n    if (typeof index === 'number') {\n      this._affectedMinimalIndex =\n        typeof this._affectedMinimalIndex === 'number'\n          ? Math.min(this._affectedMinimalIndex, index)\n          : index;\n      this._affectedIndicesMap[this.indexKey(index)] = {\n        value,\n        type,\n      };\n    }\n  }\n\n  onUpdateIntervalTree() {\n    // reset cached value\n    this._cachedSumUntilValues = {};\n\n    if (typeof this._onUpdateIntervalTree === 'function') {\n      this._onUpdateIntervalTree(this._heap);\n    }\n  }\n\n  drySet(index: number, value: number) {\n    if (typeof index !== 'number' || index < 0) return false;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return false;\n    }\n\n    while (index >= this._half) {\n      this.stretch();\n    }\n\n    const node = this._half + index;\n    this._heap[node] = value;\n\n    this.updateAffectedIndices(index, 'set', value);\n\n    if (index + 1 > this._actualSize) {\n      this._actualSize = index + 1;\n    }\n    return true;\n  }\n\n  set(index: number, value: number) {\n    this.drySet(index, value);\n    this.reflowDirectParent(index);\n    this.onUpdateIntervalTree();\n    if (typeof this._onUpdateItemLayout === 'function') {\n      this._onUpdateItemLayout(index, value);\n    }\n    return true;\n  }\n\n  applyUpdate() {\n    if (typeof this._affectedMinimalIndex === 'number') {\n      const index = this._affectedMinimalIndex;\n\n      const keys = Object.keys(this._affectedIndicesMap);\n      const hasRemoveItem = keys.some(\n        (key) => this._affectedIndicesMap[key].type === 'remove'\n      );\n\n      if (hasRemoveItem) {\n        return this.reflowHeap(index);\n      }\n\n      const depth = Math.log2(this._size);\n      const itemLength = keys.length;\n\n      const reflowTimes = this._half - index - 1;\n\n      if (depth * itemLength > reflowTimes) {\n        return this.reflowHeap(index);\n      }\n\n      keys.forEach((key) => this.reflowDirectParent(this.resolveKeyIndex(key)));\n\n      this.onUpdateIntervalTree();\n\n      this.resetAffected();\n    }\n  }\n\n  getMaxUsefulLength() {\n    return this.getActualSize();\n  }\n\n  getActualSize() {\n    return this._actualSize;\n  }\n\n  get(index: number) {\n    // invariant(index >= 0 && index < this._size, 'Index out of range %s', index);\n    const node = this._half + index;\n    return this._heap[node];\n  }\n\n  getSize() {\n    return this._size;\n  }\n\n  getHalf() {\n    return this._half;\n  }\n\n  getHeap() {\n    return this._heap;\n  }\n\n  getMaxValue() {\n    return this._heap[1];\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(end - 1).\n   * End is not included. if end less than 0, then return 0\n   */\n  sumUntil(end: number) {\n    // invariant(end >= 0 && end < this._size + 1, 'Index out of range %s', end);\n\n    if (this._cachedSumUntilValues[`${end}`] != null)\n      return this._cachedSumUntilValues[`${end}`];\n    if (end <= 0) {\n      return 0;\n    }\n\n    let node = this._half + end - 1;\n    let sum = this._heap[node];\n\n    for (; node !== 1; node = parent(node)) {\n      if (node % 2 === 1) {\n        sum += this._heap[node - 1];\n      }\n    }\n\n    return sum;\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(inclusiveEnd).\n   */\n  sumTo(inclusiveEnd: number) {\n    // invariant(\n    //   inclusiveEnd >= 0 && inclusiveEnd < this._size,\n    //   'Index out of range %s',\n    //   inclusiveEnd\n    // );\n    return this.sumUntil(inclusiveEnd + 1);\n  }\n\n  /**\n   * Returns the sum get(begin) + get(begin + 1) + ... + get(end - 1).\n   * end length is not included\n   */\n  sum(begin: number, end: number) {\n    // invariant(begin <= end, 'Begin must precede end');\n    return this.sumUntil(end) - this.sumUntil(begin);\n  }\n\n  /**\n   * return the biggest i, sumUntil(i) === t\n   * return the biggest i, subUntil(i) < t\n   */\n  greatestLowerBound(t: number) {\n    if (t < 0 || !this._actualSize) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      // not use this._size；this._size always be a big value\n      return this._actualSize;\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t < leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize);\n  }\n\n  /**\n   * Return the biggest i, subUntil(i) < t\n   * or -1 if no such i exists.\n   */\n  greatestStrictLowerBound(t: number) {\n    if (t <= 0 || !this._actualSize) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      return this._actualSize;\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t <= leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize);\n  }\n\n  /**\n   *\n   * @param minOffset\n   * @param maxOffset\n   * @returns\n   *\n   * pending issue:\n   * when item with length list [100, 0, 100, 0, 0, 100].\n   * then computeRange(100, 200) => { startIndex: 2, endIndex: 6 }\n   *\n   * item index in viewport will be [2, 3, 4, 5], index 6 is not\n   * included just like Array.slice(start, end)\n   *\n   */\n  computeRange(minOffset: number, maxOffset: number) {\n    if (this.getHeap()[1] < minOffset) {\n      return {\n        startIndex: this._actualSize,\n        endIndex: this._actualSize,\n      };\n    }\n\n    return {\n      // the biggest item, value <= minOffset\n      startIndex: this.greatestLowerBound(minOffset),\n\n      // the smallest item, value > maxOffset\n      endIndex: this.leastStrictUpperBound(maxOffset),\n    };\n  }\n\n  /**\n   * Returns the smallest i such that 0 <= i <= size and t <= sumUntil(i), or\n   * size + 1 if no such i exists.\n   */\n  leastUpperBound(t: number) {\n    return Math.min(this.greatestStrictLowerBound(t) + 1, this._actualSize);\n  }\n\n  /**\n   * Returns the smallest i, t < sumUntil(i), it should be used as range end\n   * size + 1 if no such i exists.\n   */\n  leastStrictUpperBound(t: number) {\n    return Math.min(this.greatestLowerBound(t) + 1, this._actualSize);\n  }\n}\n\nexport default PrefixIntervalTree;\n"],"names":["parent","node","Math","floor","createArray","size","xs","i","ceilLog2","x","y","PrefixIntervalTree","opts","undefined","initWithNumber","Array","isArray","initWithArray","_ref","onUpdateItemLayout","onUpdateIntervalTree","_onUpdateIntervalTree","_onUpdateItemLayout","_proto","prototype","length","_half","_size","_heap","_actualSize","arr","uniform","initialValue","empty","stretch","nextHeap","nextHeapHalf","indexKey","index","resolveKeyIndex","key","parseInt","isValidIndex","reflowDirectParent","resetAffected","reflowHeap","_startIndex","endIndex","depth","log2","startIndex","from","v","reduce","acc","_nextStart","_nextEnd","idx","_this","dryRemove","isNaN","console","warn","splice","push","updateAffectedIndices","remove","removeIndices","indices","sort","a","b","forEach","_this2","get","removeV0","copy","slice","_affectedIndicesMap","_affectedMinimalIndex","type","value","min","_cachedSumUntilValues","drySet","set","applyUpdate","keys","Object","hasRemoveItem","some","_this3","itemLength","reflowTimes","getMaxUsefulLength","getActualSize","getSize","getHalf","getHeap","getMaxValue","sumUntil","end","sum","sumTo","inclusiveEnd","begin","greatestLowerBound","t","leftSum","greatestStrictLowerBound","computeRange","minOffset","maxOffset","leastStrictUpperBound","leastUpperBound"],"mappings":"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"}

package/dist/prefix-interval-tree.cjs.production.min.js

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=function(t){return Math.floor(t/2)},e=function(t){for(var e=[],i=t-1;i>=0;--i)e[i]=0;return e};function i(t){for(var e=1;e<t;)e*=2;return e}exports.default=function(){function a(t,e){"number"==typeof t&&this.initWithNumber(t),Array.isArray(t)&&this.initWithArray(t);var i=e||{},a=i.onUpdateItemLayout;this._onUpdateIntervalTree=i.onUpdateIntervalTree,this._onUpdateItemLayout=a}var n=a.prototype;return n.initWithNumber=function(t){this._half=i(t),this._size=this._half,this._heap=e(2*this._half),this._actualSize=0},n.initWithArray=function(t){var a;for(this._half=i(t.length),this._size=this._half,this._heap=e(2*this._half),a=0;a<this._size;++a)this._heap[this._half+a]=t[a];for(a=this._half-1;a>0;--a)this._heap[a]=this._heap[2*a]+this._heap[2*a+1];this._actualSize=t.length},a.uniform=function(t,e){for(var i=[],n=t-1;n>=0;--n)i[n]=e;return new a(i)},a.empty=function(t){return a.uniform(t,0)},n.stretch=function(){for(var t=e(2*this._half*2),i=2*this._half,a=0;a<this._size;a++)t[i+a]=this._heap[this._half+a]||0;for(var n=i-1;n>0;n--)t[n]=t[2*n]+t[2*n+1];this._half=i,this._size=i,this._heap=t},n.isValidIndex=function(t){return"number"==typeof t&&t>=0&&t<this._actualSize},n.reflowHeap=function(e,i){var a=this;void 0===i&&(i=2*this._half-2);var n=Math.log2(this._size);Array.from({length:n},(function(t,e){return e})).reduce((function(e){for(var i=e.endIndex,n=t(e.startIndex),h=t(i),r=n;r<=h;r++)a._heap[r]=a._heap[2*r]+a._heap[2*r+1];return{startIndex:n,endIndex:h}}),{startIndex:e,endIndex:i})},n.remove=function(t){this.batchRemove([t])},n.batchRemove=function(t){var e=this;if(t.sort((function(t,e){return t-e})),t.forEach((function(t){e.isValidIndex(t)&&(isNaN(t)?console.warn("Passing a NaN value as interval tree index"):(e._heap.splice(e._half+t,1),e._heap.push(0),e._actualSize=e._actualSize-1))})),this.reflowHeap(t[0]+this._half),"function"==typeof this._onUpdateIntervalTree&&this._onUpdateIntervalTree(this._heap),"function"==typeof this._onUpdateItemLayout)for(var i=t[0];i<this._half;i++)this._onUpdateItemLayout(i,this.get(i))},n.removeV0=function(t){if(this.isValidIndex(t))if(isNaN(t))console.warn("Passing a NaN value as interval tree index");else{var i=e(2*this._half),a=this._heap.slice(this._half);a.splice(t,1);for(var n=this._half;n<2*this._half;n++)i[n]=a[n-this._half]||0;for(var h=this._half-1;h>0;h--)i[h]=i[2*h]+i[2*h+1];this._actualSize=this._actualSize-1,this._heap=i}},n.set=function(e,i){if("number"!=typeof e||e<0)return!1;if(isNaN(e))return console.warn("Passing a NaN value as interval tree index"),!1;for(;e>=this._half;)this.stretch();var a=this._half+e;for(this._heap[a]=i,a=t(a);0!==a;a=t(a))this._heap[a]=this._heap[2*a]+this._heap[2*a+1];return e+1>this._actualSize&&(this._actualSize=e+1),"function"==typeof this._onUpdateIntervalTree&&this._onUpdateIntervalTree(this._heap),"function"==typeof this._onUpdateItemLayout&&this._onUpdateItemLayout(e,i),!0},n.getMaxUsefulLength=function(){return this.getActualSize()},n.getActualSize=function(){return this._actualSize},n.get=function(t){return this._heap[this._half+t]},n.getSize=function(){return this._size},n.getHalf=function(){return this._half},n.getHeap=function(){return this._heap},n.getMaxValue=function(){return this._heap[1]},n.sumUntil=function(e){if(e<=0)return 0;for(var i=this._half+e-1,a=this._heap[i];1!==i;i=t(i))i%2==1&&(a+=this._heap[i-1]);return a},n.sumTo=function(t){return this.sumUntil(t+1)},n.sum=function(t,e){return this.sumUntil(e)-this.sumUntil(t)},n.greatestLowerBound=function(t){if(t<0)return-1;var e=1;if(this._heap[e]<t)return Math.max(this._actualSize-1,0);for(;e<this._half;){var i=this._heap[2*e];t<i?e*=2:(e=2*e+1,t-=i)}return Math.min(e-this._half,this._actualSize-1)},n.greatestStrictLowerBound=function(t){if(t<=0)return-1;var e=1;if(this._heap[e]<t)return Math.max(this._actualSize-1,0);for(;e<this._half;){var i=this._heap[2*e];t<=i?e*=2:(e=2*e+1,t-=i)}return Math.min(e-this._half,this._actualSize-1)},n.computeRange=function(t,e){return this.getHeap()[1]<t?{startIndex:this._actualSize,endIndex:this._actualSize}:{startIndex:this.greatestLowerBound(t),endIndex:this.leastStrictUpperBound(e)}},n.leastUpperBound=function(t){return this.greatestStrictLowerBound(t)+1},n.leastStrictUpperBound=function(t){return this.greatestLowerBound(t)+1},a}();
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=function(t){return Math.floor(t/2)},e=function(t){for(var e=[],i=t-1;i>=0;--i)e[i]=0;return e};function i(t){for(var e=1;e<t;)e*=2;return e}exports.default=function(){function n(t,e){void 0===t&&(t=10),this._affectedIndicesMap={},this._affectedMinimalIndex=void 0,this._cachedSumUntilValues={},"number"==typeof t&&this.initWithNumber(t),Array.isArray(t)&&this.initWithArray(t);var i=e||{},n=i.onUpdateItemLayout;this._onUpdateIntervalTree=i.onUpdateIntervalTree,this._onUpdateItemLayout=n}var a=n.prototype;return a.initWithNumber=function(t){this._half=i(t),this._size=this._half,this._heap=e(2*this._half),this._actualSize=0},a.initWithArray=function(t){var n;for(this._half=i(t.length),this._size=this._half,this._heap=e(2*this._half),n=0;n<this._size;++n)this._heap[this._half+n]=t[n];for(n=this._half-1;n>0;--n)this._heap[n]=this._heap[2*n]+this._heap[2*n+1];this._actualSize=t.length},n.uniform=function(t,e){for(var i=[],a=t-1;a>=0;--a)i[a]=e;return new n(i)},n.empty=function(t){return n.uniform(t,0)},a.stretch=function(){for(var t=e(2*this._half*2),i=2*this._half,n=0;n<this._size;n++)t[i+n]=this._heap[this._half+n]||0;for(var a=i-1;a>0;a--)t[a]=t[2*a]+t[2*a+1];this._half=i,this._size=i,this._heap=t},a.indexKey=function(t){return""+t},a.resolveKeyIndex=function(t){return parseInt(t,10)},a.isValidIndex=function(t){return"number"==typeof t&&t>=0&&t<this._actualSize},a.reflowDirectParent=function(e){this.resetAffected();var i=this._half+e;for(i=t(i);0!==i;i=t(i))this._heap[i]=this._heap[2*i]+this._heap[2*i+1]},a.reflowHeap=function(e,i){var n=this;void 0===i&&(i=2*this._half-2),this.resetAffected();var a=Math.log2(this._size),r=e+this._half;Array.from({length:a},(function(t,e){return e})).reduce((function(e){for(var i=e.endIndex,a=t(e.startIndex),r=t(i),h=a;h<=r;h++)n._heap[h]=n._heap[2*h]+n._heap[2*h+1];return{startIndex:a,endIndex:r}}),{startIndex:r,endIndex:i})},a.dryRemove=function(t){this.isValidIndex(t)&&(isNaN(t)?console.warn("Passing a NaN value as interval tree index"):(this._heap.splice(this._half+t,1),this._heap.push(0),this._actualSize=this._actualSize-1,this.updateAffectedIndices(t,"remove")))},a.remove=function(t){this.removeIndices([t])},a.removeIndices=function(t){var e=this;if(t.sort((function(t,e){return t-e})),t.forEach((function(t){return e.dryRemove(t)})),this.reflowHeap(t[0]),this.onUpdateIntervalTree(),"function"==typeof this._onUpdateItemLayout)for(var i=t[0];i<this._half;i++)this._onUpdateItemLayout(i,this.get(i))},a.removeV0=function(t){if(this.isValidIndex(t))if(isNaN(t))console.warn("Passing a NaN value as interval tree index");else{var i=e(2*this._half),n=this._heap.slice(this._half);n.splice(t,1);for(var a=this._half;a<2*this._half;a++)i[a]=n[a-this._half]||0;for(var r=this._half-1;r>0;r--)i[r]=i[2*r]+i[2*r+1];this._actualSize=this._actualSize-1,this._heap=i}},a.resetAffected=function(){this._affectedIndicesMap={},this._affectedMinimalIndex=void 0},a.updateAffectedIndices=function(t,e,i){"number"==typeof t&&(this._affectedMinimalIndex="number"==typeof this._affectedMinimalIndex?Math.min(this._affectedMinimalIndex,t):t,this._affectedIndicesMap[this.indexKey(t)]={value:i,type:e})},a.onUpdateIntervalTree=function(){this._cachedSumUntilValues={},"function"==typeof this._onUpdateIntervalTree&&this._onUpdateIntervalTree(this._heap)},a.drySet=function(t,e){if("number"!=typeof t||t<0)return!1;if(isNaN(t))return console.warn("Passing a NaN value as interval tree index"),!1;for(;t>=this._half;)this.stretch();return this._heap[this._half+t]=e,this.updateAffectedIndices(t,"set",e),t+1>this._actualSize&&(this._actualSize=t+1),!0},a.set=function(t,e){return this.drySet(t,e),this.reflowDirectParent(t),this.onUpdateIntervalTree(),"function"==typeof this._onUpdateItemLayout&&this._onUpdateItemLayout(t,e),!0},a.applyUpdate=function(){var t=this;if("number"==typeof this._affectedMinimalIndex){var e=this._affectedMinimalIndex,i=Object.keys(this._affectedIndicesMap);if(i.some((function(e){return"remove"===t._affectedIndicesMap[e].type})))return this.reflowHeap(e);if(Math.log2(this._size)*i.length>this._half-e-1)return this.reflowHeap(e);i.forEach((function(e){return t.reflowDirectParent(t.resolveKeyIndex(e))})),this.onUpdateIntervalTree(),this.resetAffected()}},a.getMaxUsefulLength=function(){return this.getActualSize()},a.getActualSize=function(){return this._actualSize},a.get=function(t){return this._heap[this._half+t]},a.getSize=function(){return this._size},a.getHalf=function(){return this._half},a.getHeap=function(){return this._heap},a.getMaxValue=function(){return this._heap[1]},a.sumUntil=function(e){if(null!=this._cachedSumUntilValues[""+e])return this._cachedSumUntilValues[""+e];if(e<=0)return 0;for(var i=this._half+e-1,n=this._heap[i];1!==i;i=t(i))i%2==1&&(n+=this._heap[i-1]);return n},a.sumTo=function(t){return this.sumUntil(t+1)},a.sum=function(t,e){return this.sumUntil(e)-this.sumUntil(t)},a.greatestLowerBound=function(t){if(t<0||!this._actualSize)return-1;var e=1;if(this._heap[e]<t)return this._actualSize;for(;e<this._half;){var i=this._heap[2*e];t<i?e*=2:(e=2*e+1,t-=i)}return Math.min(e-this._half,this._actualSize)},a.greatestStrictLowerBound=function(t){if(t<=0||!this._actualSize)return-1;var e=1;if(this._heap[e]<t)return this._actualSize;for(;e<this._half;){var i=this._heap[2*e];t<=i?e*=2:(e=2*e+1,t-=i)}return Math.min(e-this._half,this._actualSize)},a.computeRange=function(t,e){return this.getHeap()[1]<t?{startIndex:this._actualSize,endIndex:this._actualSize}:{startIndex:this.greatestLowerBound(t),endIndex:this.leastStrictUpperBound(e)}},a.leastUpperBound=function(t){return Math.min(this.greatestStrictLowerBound(t)+1,this._actualSize)},a.leastStrictUpperBound=function(t){return Math.min(this.greatestLowerBound(t)+1,this._actualSize)},n}();
 //# sourceMappingURL=prefix-interval-tree.cjs.production.min.js.map

package/dist/prefix-interval-tree.cjs.production.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"prefix-interval-tree.cjs.production.min.js","sources":["../src/index.ts"],"sourcesContent":["const parent = (node: number) => Math.floor(node / 2);\n\nconst createArray = function (size: number) {\n  const xs = [];\n  for (let i = size - 1; i >= 0; --i) {\n    xs[i] = 0;\n  }\n  return xs;\n};\n\n/**\n * Computes the next power of 2 after or equal to x.\n */\nfunction ceilLog2(x: number) {\n  let y = 1;\n  while (y < x) {\n    y *= 2;\n  }\n\n  return y;\n}\n\n/**\n * A prefix interval tree stores an numeric array and the partial sums of that\n * array. It is optimized for updating the values of the array without\n * recomputing all of the partial sums.\n *\n *   - O(ln n) update\n *   - O(1) lookup\n *   - O(ln n) compute a partial sum\n *   - O(n) space\n *\n * Note that the sequence of partial sums is one longer than the array, so that\n * the first partial sum is always 0, and the last partial sum is the sum of the\n * entire array.\n */\nclass PrefixIntervalTree {\n  private _size: number;\n  /**\n   * Half the size of the heap. It is also the number of non-leaf nodes, and the\n   * index of the first element in the heap. Always a power of 2.\n   */\n  private _half: number;\n  private _heap: number[];\n\n  private _actualSize: number;\n\n  private _onUpdateItemLayout: Function;\n  private _onUpdateIntervalTree: Function;\n\n  constructor(\n    xs: number[] | number,\n    opts?: {\n      onUpdateItemLayout?: Function;\n      onUpdateIntervalTree?: Function;\n    }\n  ) {\n    if (typeof xs === 'number') this.initWithNumber(xs);\n    if (Array.isArray(xs)) this.initWithArray(xs);\n\n    const { onUpdateItemLayout, onUpdateIntervalTree } = opts || {};\n    this._onUpdateIntervalTree = onUpdateIntervalTree;\n    this._onUpdateItemLayout = onUpdateItemLayout;\n  }\n\n  initWithNumber(length: number) {\n    this._half = ceilLog2(length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    this._actualSize = 0;\n  }\n\n  initWithArray(arr: number[]) {\n    this._half = ceilLog2(arr.length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    let i;\n    for (i = 0; i < this._size; ++i) {\n      this._heap[this._half + i] = arr[i];\n    }\n\n    for (i = this._half - 1; i > 0; --i) {\n      this._heap[i] = this._heap[2 * i] + this._heap[2 * i + 1];\n    }\n    this._actualSize = arr.length;\n  }\n\n  static uniform(size: number, initialValue: number) {\n    const xs = [];\n    for (let i = size - 1; i >= 0; --i) {\n      xs[i] = initialValue;\n    }\n\n    return new PrefixIntervalTree(xs);\n  }\n\n  static empty(size: number) {\n    return PrefixIntervalTree.uniform(size, 0);\n  }\n\n  /**\n   * the length should be 2\n   */\n  stretch() {\n    const nextHeap = createArray(2 * this._half * 2);\n    const nextHeapHalf = this._half * 2;\n\n    // copy old value to new one\n    for (let i = 0; i < this._size; i++) {\n      nextHeap[nextHeapHalf + i] = this._heap[this._half + i] || 0;\n    }\n\n    // sum old value to create new sum value\n    for (let i = nextHeapHalf - 1; i > 0; i--) {\n      nextHeap[i] = nextHeap[2 * i] + nextHeap[2 * i + 1];\n    }\n\n    this._half = nextHeapHalf;\n    this._size = nextHeapHalf;\n    this._heap = nextHeap;\n  }\n\n  isValidIndex(index: number) {\n    return typeof index === 'number' && index >= 0 && index < this._actualSize;\n  }\n\n  reflowHeap(startIndex: number, endIndex = this._half * 2 - 2) {\n    const len = Math.log2(this._size);\n\n    Array.from({ length: len }, (v, i) => i).reduce(\n      (acc) => {\n        const { startIndex, endIndex } = acc;\n        const _nextStart = parent(startIndex);\n        const _nextEnd = parent(endIndex);\n\n        for (let idx = _nextStart; idx <= _nextEnd; idx++) {\n          this._heap[idx] = this._heap[2 * idx] + this._heap[2 * idx + 1];\n        }\n\n        return {\n          startIndex: _nextStart,\n          endIndex: _nextEnd,\n        };\n      },\n      {\n        startIndex,\n        endIndex,\n      }\n    );\n  }\n\n  remove(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n\n    this.batchRemove([index]);\n  }\n\n  batchRemove(indices: number[]) {\n    indices.sort((a, b) => a - b);\n\n    indices.forEach((index) => {\n      if (!this.isValidIndex(index)) return;\n      if (isNaN(index)) {\n        console.warn('Passing a NaN value as interval tree index');\n        return;\n      }\n\n      this._heap.splice(this._half + index, 1);\n      this._heap.push(0);\n      this._actualSize = this._actualSize - 1;\n    });\n\n    this.reflowHeap(indices[0] + this._half);\n    if (typeof this._onUpdateIntervalTree === 'function') {\n      this._onUpdateIntervalTree(this._heap);\n    }\n\n    if (typeof this._onUpdateItemLayout === 'function') {\n      for (let idx = indices[0]; idx < this._half; idx++) {\n        this._onUpdateItemLayout(idx, this.get(idx));\n      }\n    }\n  }\n\n  removeV0(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n    if (!this.isValidIndex(index)) return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\n    }\n\n    const nextHeap = createArray(this._half * 2);\n    const copy = this._heap.slice(this._half);\n    copy.splice(index, 1);\n\n    for (let index = this._half; index < this._half * 2; index++) {\n      nextHeap[index] = copy[index - this._half] || 0;\n    }\n\n    for (let index = this._half - 1; index > 0; index--) {\n      nextHeap[index] = nextHeap[2 * index] + nextHeap[2 * index + 1];\n    }\n\n    this._actualSize = this._actualSize - 1;\n    this._heap = nextHeap;\n  }\n\n  set(index: number, value: number) {\n    if (typeof index !== 'number' || index < 0) return false;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return false;\n    }\n\n    while (index >= this._half) {\n      this.stretch();\n    }\n\n    let node = this._half + index;\n    this._heap[node] = value;\n\n    node = parent(node);\n    for (; node !== 0; node = parent(node)) {\n      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];\n    }\n\n    if (index + 1 > this._actualSize) {\n      this._actualSize = index + 1;\n    }\n\n    if (typeof this._onUpdateIntervalTree === 'function') {\n      this._onUpdateIntervalTree(this._heap);\n    }\n\n    if (typeof this._onUpdateItemLayout === 'function') {\n      this._onUpdateItemLayout(index, value);\n    }\n    return true;\n  }\n\n  getMaxUsefulLength() {\n    return this.getActualSize();\n  }\n\n  getActualSize() {\n    return this._actualSize;\n  }\n\n  get(index: number) {\n    // invariant(index >= 0 && index < this._size, 'Index out of range %s', index);\n    const node = this._half + index;\n    return this._heap[node];\n  }\n\n  getSize() {\n    return this._size;\n  }\n\n  getHalf() {\n    return this._half;\n  }\n\n  getHeap() {\n    return this._heap;\n  }\n\n  getMaxValue() {\n    return this._heap[1];\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(end - 1).\n   * End is not included. if end less than 0, then return 0\n   */\n  sumUntil(end: number) {\n    // invariant(end >= 0 && end < this._size + 1, 'Index out of range %s', end);\n\n    if (end <= 0) {\n      return 0;\n    }\n\n    let node = this._half + end - 1;\n    let sum = this._heap[node];\n\n    for (; node !== 1; node = parent(node)) {\n      if (node % 2 === 1) {\n        sum += this._heap[node - 1];\n      }\n    }\n\n    return sum;\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(inclusiveEnd).\n   */\n  sumTo(inclusiveEnd: number) {\n    // invariant(\n    //   inclusiveEnd >= 0 && inclusiveEnd < this._size,\n    //   'Index out of range %s',\n    //   inclusiveEnd\n    // );\n    return this.sumUntil(inclusiveEnd + 1);\n  }\n\n  /**\n   * Returns the sum get(begin) + get(begin + 1) + ... + get(end - 1).\n   * end length is not included\n   */\n  sum(begin: number, end: number) {\n    // invariant(begin <= end, 'Begin must precede end');\n    return this.sumUntil(end) - this.sumUntil(begin);\n  }\n\n  /**\n   * return the biggest i, sumUntil(i) === t\n   * return the biggest i, subUntil(i) < t\n   */\n  greatestLowerBound(t: number) {\n    if (t < 0) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      // not use this._size；this._size always be a big value\n      return Math.max(this._actualSize - 1, 0);\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t < leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize - 1);\n  }\n\n  /**\n   * Return the biggest i, subUntil(i) < t\n   * or -1 if no such i exists.\n   */\n  greatestStrictLowerBound(t: number) {\n    if (t <= 0) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      return Math.max(this._actualSize - 1, 0);\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t <= leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize - 1);\n  }\n\n  /**\n   *\n   * @param minOffset\n   * @param maxOffset\n   * @returns\n   *\n   * pending issue:\n   * when item with length list [100, 0, 100, 0, 0, 100].\n   * then computeRange(100, 200) => { startIndex: 2, endIndex: 6 }\n   *\n   * item index in viewport will be [2, 3, 4, 5], index 6 is not\n   * included just like Array.slice(start, end)\n   *\n   */\n  computeRange(minOffset: number, maxOffset: number) {\n    if (this.getHeap()[1] < minOffset) {\n      return {\n        startIndex: this._actualSize,\n        endIndex: this._actualSize,\n      };\n    }\n\n    return {\n      // the biggest item, value <= minOffset\n      startIndex: this.greatestLowerBound(minOffset),\n\n      // the smallest item, value > maxOffset\n      endIndex: this.leastStrictUpperBound(maxOffset),\n    };\n  }\n\n  /**\n   * Returns the smallest i such that 0 <= i <= size and t <= sumUntil(i), or\n   * size + 1 if no such i exists.\n   */\n  leastUpperBound(t: number) {\n    return this.greatestStrictLowerBound(t) + 1;\n  }\n\n  /**\n   * Returns the smallest i, t < sumUntil(i), it should be used as range end\n   * size + 1 if no such i exists.\n   */\n  leastStrictUpperBound(t: number) {\n    return this.greatestLowerBound(t) + 1;\n  }\n}\n\nexport default PrefixIntervalTree;\n"],"names":["parent","node","Math","floor","createArray","size","xs","i","ceilLog2","x","y","PrefixIntervalTree","opts","this","initWithNumber","Array","isArray","initWithArray","_ref","onUpdateItemLayout","_onUpdateIntervalTree","onUpdateIntervalTree","_onUpdateItemLayout","_proto","prototype","length","_half","_size","_heap","_actualSize","arr","uniform","initialValue","empty","stretch","nextHeap","nextHeapHalf","isValidIndex","index","reflowHeap","startIndex","endIndex","len","log2","from","v","reduce","acc","_nextStart","_nextEnd","idx","_this","remove","batchRemove","indices","sort","a","b","forEach","_this2","isNaN","console","warn","splice","push","get","removeV0","copy","slice","set","value","getMaxUsefulLength","getActualSize","getSize","getHalf","getHeap","getMaxValue","sumUntil","end","sum","sumTo","inclusiveEnd","begin","greatestLowerBound","t","max","leftSum","min","greatestStrictLowerBound","computeRange","minOffset","maxOffset","leastStrictUpperBound","leastUpperBound"],"mappings":"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"}
+{"version":3,"file":"prefix-interval-tree.cjs.production.min.js","sources":["../src/index.ts"],"sourcesContent":["const parent = (node: number) => Math.floor(node / 2);\n\nconst createArray = function (size: number) {\n  const xs = [];\n  for (let i = size - 1; i >= 0; --i) {\n    xs[i] = 0;\n  }\n  return xs;\n};\n\n/**\n * Computes the next power of 2 after or equal to x.\n */\nfunction ceilLog2(x: number) {\n  let y = 1;\n  while (y < x) {\n    y *= 2;\n  }\n\n  return y;\n}\n\ntype OperationType = 'set' | 'remove';\n\ntype Operation = {\n  type: OperationType;\n  value: any;\n};\n\n/**\n * A prefix interval tree stores an numeric array and the partial sums of that\n * array. It is optimized for updating the values of the array without\n * recomputing all of the partial sums.\n *\n *   - O(ln n) update\n *   - O(1) lookup\n *   - O(ln n) compute a partial sum\n *   - O(n) space\n *\n * Note that the sequence of partial sums is one longer than the array, so that\n * the first partial sum is always 0, and the last partial sum is the sum of the\n * entire array.\n */\nclass PrefixIntervalTree {\n  private _size: number;\n  /**\n   * Half the size of the heap. It is also the number of non-leaf nodes, and the\n   * index of the first element in the heap. Always a power of 2.\n   */\n  private _half: number;\n  private _heap: number[];\n\n  private _actualSize: number;\n\n  private _onUpdateItemLayout: Function;\n  private _onUpdateIntervalTree: Function;\n\n  private _affectedIndicesMap: {\n    [key: string]: Operation;\n  } = {};\n  private _affectedMinimalIndex: number = undefined;\n  private _cachedSumUntilValues: {\n    [key: string]: number;\n  } = {};\n\n  constructor(\n    xs: number[] | number = 10,\n    opts?: {\n      onUpdateItemLayout?: Function;\n      onUpdateIntervalTree?: Function;\n    }\n  ) {\n    if (typeof xs === 'number') this.initWithNumber(xs);\n    if (Array.isArray(xs)) this.initWithArray(xs);\n\n    const { onUpdateItemLayout, onUpdateIntervalTree } = opts || {};\n    this._onUpdateIntervalTree = onUpdateIntervalTree;\n    this._onUpdateItemLayout = onUpdateItemLayout;\n  }\n\n  initWithNumber(length: number) {\n    this._half = ceilLog2(length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    this._actualSize = 0;\n  }\n\n  initWithArray(arr: number[]) {\n    this._half = ceilLog2(arr.length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    let i;\n    for (i = 0; i < this._size; ++i) {\n      this._heap[this._half + i] = arr[i];\n    }\n\n    for (i = this._half - 1; i > 0; --i) {\n      this._heap[i] = this._heap[2 * i] + this._heap[2 * i + 1];\n    }\n    this._actualSize = arr.length;\n  }\n\n  static uniform(size: number, initialValue: number) {\n    const xs = [];\n    for (let i = size - 1; i >= 0; --i) {\n      xs[i] = initialValue;\n    }\n\n    return new PrefixIntervalTree(xs);\n  }\n\n  static empty(size: number) {\n    return PrefixIntervalTree.uniform(size, 0);\n  }\n\n  /**\n   * the length should be 2\n   * it will cause calculation of\n   */\n  stretch() {\n    const nextHeap = createArray(2 * this._half * 2);\n    const nextHeapHalf = this._half * 2;\n\n    // copy old value to new one\n    for (let i = 0; i < this._size; i++) {\n      nextHeap[nextHeapHalf + i] = this._heap[this._half + i] || 0;\n    }\n\n    // sum old value to create new sum value\n    for (let i = nextHeapHalf - 1; i > 0; i--) {\n      nextHeap[i] = nextHeap[2 * i] + nextHeap[2 * i + 1];\n    }\n\n    this._half = nextHeapHalf;\n    this._size = nextHeapHalf;\n    this._heap = nextHeap;\n  }\n\n  indexKey(index: number) {\n    return `${index}`;\n  }\n\n  resolveKeyIndex(key: string) {\n    return parseInt(key, 10);\n  }\n\n  isValidIndex(index: number) {\n    return typeof index === 'number' && index >= 0 && index < this._actualSize;\n  }\n\n  reflowDirectParent(index: number) {\n    this.resetAffected();\n    let node = this._half + index;\n\n    node = parent(node);\n    for (; node !== 0; node = parent(node)) {\n      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];\n    }\n  }\n\n  // recalculate parent value from startIndex to endIndex\n  reflowHeap(_startIndex: number, endIndex = this._half * 2 - 2) {\n    this.resetAffected();\n    const depth = Math.log2(this._size);\n    const startIndex = _startIndex + this._half;\n\n    Array.from({ length: depth }, (v, i) => i).reduce(\n      (acc) => {\n        const { startIndex, endIndex } = acc;\n        const _nextStart = parent(startIndex);\n        const _nextEnd = parent(endIndex);\n\n        for (let idx = _nextStart; idx <= _nextEnd; idx++) {\n          this._heap[idx] = this._heap[2 * idx] + this._heap[2 * idx + 1];\n        }\n\n        return {\n          startIndex: _nextStart,\n          endIndex: _nextEnd,\n        };\n      },\n      {\n        startIndex,\n        endIndex,\n      }\n    );\n  }\n\n  /**\n   *\n   * @param index index to remove\n   * @returns\n   *\n   * update heap only, but not recalculate interval tree value\n   */\n  dryRemove(index: number) {\n    if (!this.isValidIndex(index)) return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\n    }\n\n    this._heap.splice(this._half + index, 1);\n    this._heap.push(0);\n    this._actualSize = this._actualSize - 1;\n\n    this.updateAffectedIndices(index, 'remove');\n  }\n\n  remove(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n\n    this.removeIndices([index]);\n  }\n\n  removeIndices(indices: number[]) {\n    indices.sort((a, b) => a - b);\n\n    indices.forEach((index) => this.dryRemove(index));\n\n    this.reflowHeap(indices[0]);\n    this.onUpdateIntervalTree();\n\n    if (typeof this._onUpdateItemLayout === 'function') {\n      for (let idx = indices[0]; idx < this._half; idx++) {\n        this._onUpdateItemLayout(idx, this.get(idx));\n      }\n    }\n  }\n\n  removeV0(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n    if (!this.isValidIndex(index)) return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\n    }\n\n    const nextHeap = createArray(this._half * 2);\n    const copy = this._heap.slice(this._half);\n    copy.splice(index, 1);\n\n    for (let index = this._half; index < this._half * 2; index++) {\n      nextHeap[index] = copy[index - this._half] || 0;\n    }\n\n    for (let index = this._half - 1; index > 0; index--) {\n      nextHeap[index] = nextHeap[2 * index] + nextHeap[2 * index + 1];\n    }\n\n    this._actualSize = this._actualSize - 1;\n    this._heap = nextHeap;\n  }\n\n  resetAffected() {\n    this._affectedIndicesMap = {};\n    this._affectedMinimalIndex = undefined;\n  }\n\n  updateAffectedIndices(index: number, type: OperationType, value?: number) {\n    if (typeof index === 'number') {\n      this._affectedMinimalIndex =\n        typeof this._affectedMinimalIndex === 'number'\n          ? Math.min(this._affectedMinimalIndex, index)\n          : index;\n      this._affectedIndicesMap[this.indexKey(index)] = {\n        value,\n        type,\n      };\n    }\n  }\n\n  onUpdateIntervalTree() {\n    // reset cached value\n    this._cachedSumUntilValues = {};\n\n    if (typeof this._onUpdateIntervalTree === 'function') {\n      this._onUpdateIntervalTree(this._heap);\n    }\n  }\n\n  drySet(index: number, value: number) {\n    if (typeof index !== 'number' || index < 0) return false;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return false;\n    }\n\n    while (index >= this._half) {\n      this.stretch();\n    }\n\n    const node = this._half + index;\n    this._heap[node] = value;\n\n    this.updateAffectedIndices(index, 'set', value);\n\n    if (index + 1 > this._actualSize) {\n      this._actualSize = index + 1;\n    }\n    return true;\n  }\n\n  set(index: number, value: number) {\n    this.drySet(index, value);\n    this.reflowDirectParent(index);\n    this.onUpdateIntervalTree();\n    if (typeof this._onUpdateItemLayout === 'function') {\n      this._onUpdateItemLayout(index, value);\n    }\n    return true;\n  }\n\n  applyUpdate() {\n    if (typeof this._affectedMinimalIndex === 'number') {\n      const index = this._affectedMinimalIndex;\n\n      const keys = Object.keys(this._affectedIndicesMap);\n      const hasRemoveItem = keys.some(\n        (key) => this._affectedIndicesMap[key].type === 'remove'\n      );\n\n      if (hasRemoveItem) {\n        return this.reflowHeap(index);\n      }\n\n      const depth = Math.log2(this._size);\n      const itemLength = keys.length;\n\n      const reflowTimes = this._half - index - 1;\n\n      if (depth * itemLength > reflowTimes) {\n        return this.reflowHeap(index);\n      }\n\n      keys.forEach((key) => this.reflowDirectParent(this.resolveKeyIndex(key)));\n\n      this.onUpdateIntervalTree();\n\n      this.resetAffected();\n    }\n  }\n\n  getMaxUsefulLength() {\n    return this.getActualSize();\n  }\n\n  getActualSize() {\n    return this._actualSize;\n  }\n\n  get(index: number) {\n    // invariant(index >= 0 && index < this._size, 'Index out of range %s', index);\n    const node = this._half + index;\n    return this._heap[node];\n  }\n\n  getSize() {\n    return this._size;\n  }\n\n  getHalf() {\n    return this._half;\n  }\n\n  getHeap() {\n    return this._heap;\n  }\n\n  getMaxValue() {\n    return this._heap[1];\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(end - 1).\n   * End is not included. if end less than 0, then return 0\n   */\n  sumUntil(end: number) {\n    // invariant(end >= 0 && end < this._size + 1, 'Index out of range %s', end);\n\n    if (this._cachedSumUntilValues[`${end}`] != null)\n      return this._cachedSumUntilValues[`${end}`];\n    if (end <= 0) {\n      return 0;\n    }\n\n    let node = this._half + end - 1;\n    let sum = this._heap[node];\n\n    for (; node !== 1; node = parent(node)) {\n      if (node % 2 === 1) {\n        sum += this._heap[node - 1];\n      }\n    }\n\n    return sum;\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(inclusiveEnd).\n   */\n  sumTo(inclusiveEnd: number) {\n    // invariant(\n    //   inclusiveEnd >= 0 && inclusiveEnd < this._size,\n    //   'Index out of range %s',\n    //   inclusiveEnd\n    // );\n    return this.sumUntil(inclusiveEnd + 1);\n  }\n\n  /**\n   * Returns the sum get(begin) + get(begin + 1) + ... + get(end - 1).\n   * end length is not included\n   */\n  sum(begin: number, end: number) {\n    // invariant(begin <= end, 'Begin must precede end');\n    return this.sumUntil(end) - this.sumUntil(begin);\n  }\n\n  /**\n   * return the biggest i, sumUntil(i) === t\n   * return the biggest i, subUntil(i) < t\n   */\n  greatestLowerBound(t: number) {\n    if (t < 0 || !this._actualSize) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      // not use this._size；this._size always be a big value\n      return this._actualSize;\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t < leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize);\n  }\n\n  /**\n   * Return the biggest i, subUntil(i) < t\n   * or -1 if no such i exists.\n   */\n  greatestStrictLowerBound(t: number) {\n    if (t <= 0 || !this._actualSize) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      return this._actualSize;\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t <= leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize);\n  }\n\n  /**\n   *\n   * @param minOffset\n   * @param maxOffset\n   * @returns\n   *\n   * pending issue:\n   * when item with length list [100, 0, 100, 0, 0, 100].\n   * then computeRange(100, 200) => { startIndex: 2, endIndex: 6 }\n   *\n   * item index in viewport will be [2, 3, 4, 5], index 6 is not\n   * included just like Array.slice(start, end)\n   *\n   */\n  computeRange(minOffset: number, maxOffset: number) {\n    if (this.getHeap()[1] < minOffset) {\n      return {\n        startIndex: this._actualSize,\n        endIndex: this._actualSize,\n      };\n    }\n\n    return {\n      // the biggest item, value <= minOffset\n      startIndex: this.greatestLowerBound(minOffset),\n\n      // the smallest item, value > maxOffset\n      endIndex: this.leastStrictUpperBound(maxOffset),\n    };\n  }\n\n  /**\n   * Returns the smallest i such that 0 <= i <= size and t <= sumUntil(i), or\n   * size + 1 if no such i exists.\n   */\n  leastUpperBound(t: number) {\n    return Math.min(this.greatestStrictLowerBound(t) + 1, this._actualSize);\n  }\n\n  /**\n   * Returns the smallest i, t < sumUntil(i), it should be used as range end\n   * size + 1 if no such i exists.\n   */\n  leastStrictUpperBound(t: number) {\n    return Math.min(this.greatestLowerBound(t) + 1, this._actualSize);\n  }\n}\n\nexport default PrefixIntervalTree;\n"],"names":["parent","node","Math","floor","createArray","size","xs","i","ceilLog2","x","y","PrefixIntervalTree","opts","this","undefined","initWithNumber","Array","isArray","initWithArray","_ref","onUpdateItemLayout","_onUpdateIntervalTree","onUpdateIntervalTree","_onUpdateItemLayout","_proto","prototype","length","_half","_size","_heap","_actualSize","arr","uniform","initialValue","empty","stretch","nextHeap","nextHeapHalf","indexKey","index","resolveKeyIndex","key","parseInt","isValidIndex","reflowDirectParent","resetAffected","reflowHeap","_startIndex","endIndex","depth","log2","startIndex","from","v","reduce","acc","_nextStart","_nextEnd","idx","_this","dryRemove","isNaN","console","warn","splice","push","updateAffectedIndices","remove","removeIndices","indices","sort","a","b","forEach","_this2","get","removeV0","copy","slice","_affectedIndicesMap","_affectedMinimalIndex","type","value","min","_cachedSumUntilValues","drySet","set","applyUpdate","keys","Object","some","_this3","getMaxUsefulLength","getActualSize","getSize","getHalf","getHeap","getMaxValue","sumUntil","end","sum","sumTo","inclusiveEnd","begin","greatestLowerBound","t","leftSum","greatestStrictLowerBound","computeRange","minOffset","maxOffset","leastStrictUpperBound","leastUpperBound"],"mappings":"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"}

package/dist/prefix-interval-tree.esm.js

@@ -17,6 +17,12 @@ function ceilLog2(x) {
 }
 var PrefixIntervalTree = /*#__PURE__*/function () {
   function PrefixIntervalTree(xs, opts) {
+    if (xs === void 0) {
+      xs = 10;
+    }
+    this._affectedIndicesMap = {};
+    this._affectedMinimalIndex = undefined;
+    this._cachedSumUntilValues = {};
     if (typeof xs === 'number') this.initWithNumber(xs);
     if (Array.isArray(xs)) this.initWithArray(xs);
     var _ref = opts || {},
@@ -68,17 +74,33 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     this._size = nextHeapHalf;
     this._heap = nextHeap;
   };
+  _proto.indexKey = function indexKey(index) {
+    return "" + index;
+  };
+  _proto.resolveKeyIndex = function resolveKeyIndex(key) {
+    return parseInt(key, 10);
+  };
   _proto.isValidIndex = function isValidIndex(index) {
     return typeof index === 'number' && index >= 0 && index < this._actualSize;
   };
-  _proto.reflowHeap = function reflowHeap(startIndex, endIndex) {
+  _proto.reflowDirectParent = function reflowDirectParent(index) {
+    this.resetAffected();
+    var node = this._half + index;
+    node = parent(node);
+    for (; node !== 0; node = parent(node)) {
+      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];
+    }
+  };
+  _proto.reflowHeap = function reflowHeap(_startIndex, endIndex) {
     var _this = this;
     if (endIndex === void 0) {
       endIndex = this._half * 2 - 2;
     }
-    var len = Math.log2(this._size);
+    this.resetAffected();
+    var depth = Math.log2(this._size);
+    var startIndex = _startIndex + this._half;
     Array.from({
-      length: len
+      length: depth
     }, function (v, i) {
       return i;
     }).reduce(function (acc) {
@@ -98,28 +120,30 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
       endIndex: endIndex
     });
   };
+  _proto.dryRemove = function dryRemove(index) {
+    if (!this.isValidIndex(index)) return;
+    if (isNaN(index)) {
+      console.warn('Passing a NaN value as interval tree index');
+      return;
+    }
+    this._heap.splice(this._half + index, 1);
+    this._heap.push(0);
+    this._actualSize = this._actualSize - 1;
+    this.updateAffectedIndices(index, 'remove');
+  };
   _proto.remove = function remove(index) {
-    this.batchRemove([index]);
+    this.removeIndices([index]);
   };
-  _proto.batchRemove = function batchRemove(indices) {
+  _proto.removeIndices = function removeIndices(indices) {
     var _this2 = this;
     indices.sort(function (a, b) {
       return a - b;
     });
     indices.forEach(function (index) {
-      if (!_this2.isValidIndex(index)) return;
-      if (isNaN(index)) {
-        console.warn('Passing a NaN value as interval tree index');
-        return;
-      }
-      _this2._heap.splice(_this2._half + index, 1);
-      _this2._heap.push(0);
-      _this2._actualSize = _this2._actualSize - 1;
+      return _this2.dryRemove(index);
     });
-    this.reflowHeap(indices[0] + this._half);
-    if (typeof this._onUpdateIntervalTree === 'function') {
-      this._onUpdateIntervalTree(this._heap);
-    }
+    this.reflowHeap(indices[0]);
+    this.onUpdateIntervalTree();
     if (typeof this._onUpdateItemLayout === 'function') {
       for (var idx = indices[0]; idx < this._half; idx++) {
         this._onUpdateItemLayout(idx, this.get(idx));
@@ -144,7 +168,26 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     this._actualSize = this._actualSize - 1;
     this._heap = nextHeap;
   };
-  _proto.set = function set(index, value) {
+  _proto.resetAffected = function resetAffected() {
+    this._affectedIndicesMap = {};
+    this._affectedMinimalIndex = undefined;
+  };
+  _proto.updateAffectedIndices = function updateAffectedIndices(index, type, value) {
+    if (typeof index === 'number') {
+      this._affectedMinimalIndex = typeof this._affectedMinimalIndex === 'number' ? Math.min(this._affectedMinimalIndex, index) : index;
+      this._affectedIndicesMap[this.indexKey(index)] = {
+        value: value,
+        type: type
+      };
+    }
+  };
+  _proto.onUpdateIntervalTree = function onUpdateIntervalTree() {
+    this._cachedSumUntilValues = {};
+    if (typeof this._onUpdateIntervalTree === 'function') {
+      this._onUpdateIntervalTree(this._heap);
+    }
+  };
+  _proto.drySet = function drySet(index, value) {
     if (typeof index !== 'number' || index < 0) return false;
     if (isNaN(index)) {
       console.warn('Passing a NaN value as interval tree index');
@@ -155,21 +198,45 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     }
     var node = this._half + index;
     this._heap[node] = value;
-    node = parent(node);
-    for (; node !== 0; node = parent(node)) {
-      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];
-    }
+    this.updateAffectedIndices(index, 'set', value);
     if (index + 1 > this._actualSize) {
       this._actualSize = index + 1;
     }
-    if (typeof this._onUpdateIntervalTree === 'function') {
-      this._onUpdateIntervalTree(this._heap);
-    }
+    return true;
+  };
+  _proto.set = function set(index, value) {
+    this.drySet(index, value);
+    this.reflowDirectParent(index);
+    this.onUpdateIntervalTree();
     if (typeof this._onUpdateItemLayout === 'function') {
       this._onUpdateItemLayout(index, value);
     }
     return true;
   };
+  _proto.applyUpdate = function applyUpdate() {
+    var _this3 = this;
+    if (typeof this._affectedMinimalIndex === 'number') {
+      var index = this._affectedMinimalIndex;
+      var keys = Object.keys(this._affectedIndicesMap);
+      var hasRemoveItem = keys.some(function (key) {
+        return _this3._affectedIndicesMap[key].type === 'remove';
+      });
+      if (hasRemoveItem) {
+        return this.reflowHeap(index);
+      }
+      var depth = Math.log2(this._size);
+      var itemLength = keys.length;
+      var reflowTimes = this._half - index - 1;
+      if (depth * itemLength > reflowTimes) {
+        return this.reflowHeap(index);
+      }
+      keys.forEach(function (key) {
+        return _this3.reflowDirectParent(_this3.resolveKeyIndex(key));
+      });
+      this.onUpdateIntervalTree();
+      this.resetAffected();
+    }
+  };
   _proto.getMaxUsefulLength = function getMaxUsefulLength() {
     return this.getActualSize();
   };
@@ -193,6 +260,7 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     return this._heap[1];
   };
   _proto.sumUntil = function sumUntil(end) {
+    if (this._cachedSumUntilValues["" + end] != null) return this._cachedSumUntilValues["" + end];
     if (end <= 0) {
       return 0;
     }
@@ -212,12 +280,12 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     return this.sumUntil(end) - this.sumUntil(begin);
   };
   _proto.greatestLowerBound = function greatestLowerBound(t) {
-    if (t < 0) {
+    if (t < 0 || !this._actualSize) {
       return -1;
     }
     var node = 1;
     if (this._heap[node] < t) {
-      return Math.max(this._actualSize - 1, 0);
+      return this._actualSize;
     }
     while (node < this._half) {
       var leftSum = this._heap[2 * node];
@@ -228,15 +296,15 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
         t -= leftSum;
       }
     }
-    return Math.min(node - this._half, this._actualSize - 1);
+    return Math.min(node - this._half, this._actualSize);
   };
   _proto.greatestStrictLowerBound = function greatestStrictLowerBound(t) {
-    if (t <= 0) {
+    if (t <= 0 || !this._actualSize) {
       return -1;
     }
     var node = 1;
     if (this._heap[node] < t) {
-      return Math.max(this._actualSize - 1, 0);
+      return this._actualSize;
     }
     while (node < this._half) {
       var leftSum = this._heap[2 * node];
@@ -247,7 +315,7 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
         t -= leftSum;
       }
     }
-    return Math.min(node - this._half, this._actualSize - 1);
+    return Math.min(node - this._half, this._actualSize);
   };
   _proto.computeRange = function computeRange(minOffset, maxOffset) {
     if (this.getHeap()[1] < minOffset) {
@@ -262,10 +330,10 @@ var PrefixIntervalTree = /*#__PURE__*/function () {
     };
   };
   _proto.leastUpperBound = function leastUpperBound(t) {
-    return this.greatestStrictLowerBound(t) + 1;
+    return Math.min(this.greatestStrictLowerBound(t) + 1, this._actualSize);
   };
   _proto.leastStrictUpperBound = function leastStrictUpperBound(t) {
-    return this.greatestLowerBound(t) + 1;
+    return Math.min(this.greatestLowerBound(t) + 1, this._actualSize);
   };
   return PrefixIntervalTree;
 }();

package/dist/prefix-interval-tree.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"prefix-interval-tree.esm.js","sources":["../src/index.ts"],"sourcesContent":["const parent = (node: number) => Math.floor(node / 2);\n\nconst createArray = function (size: number) {\n  const xs = [];\n  for (let i = size - 1; i >= 0; --i) {\n    xs[i] = 0;\n  }\n  return xs;\n};\n\n/**\n * Computes the next power of 2 after or equal to x.\n */\nfunction ceilLog2(x: number) {\n  let y = 1;\n  while (y < x) {\n    y *= 2;\n  }\n\n  return y;\n}\n\n/**\n * A prefix interval tree stores an numeric array and the partial sums of that\n * array. It is optimized for updating the values of the array without\n * recomputing all of the partial sums.\n *\n *   - O(ln n) update\n *   - O(1) lookup\n *   - O(ln n) compute a partial sum\n *   - O(n) space\n *\n * Note that the sequence of partial sums is one longer than the array, so that\n * the first partial sum is always 0, and the last partial sum is the sum of the\n * entire array.\n */\nclass PrefixIntervalTree {\n  private _size: number;\n  /**\n   * Half the size of the heap. It is also the number of non-leaf nodes, and the\n   * index of the first element in the heap. Always a power of 2.\n   */\n  private _half: number;\n  private _heap: number[];\n\n  private _actualSize: number;\n\n  private _onUpdateItemLayout: Function;\n  private _onUpdateIntervalTree: Function;\n\n  constructor(\n    xs: number[] | number,\n    opts?: {\n      onUpdateItemLayout?: Function;\n      onUpdateIntervalTree?: Function;\n    }\n  ) {\n    if (typeof xs === 'number') this.initWithNumber(xs);\n    if (Array.isArray(xs)) this.initWithArray(xs);\n\n    const { onUpdateItemLayout, onUpdateIntervalTree } = opts || {};\n    this._onUpdateIntervalTree = onUpdateIntervalTree;\n    this._onUpdateItemLayout = onUpdateItemLayout;\n  }\n\n  initWithNumber(length: number) {\n    this._half = ceilLog2(length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    this._actualSize = 0;\n  }\n\n  initWithArray(arr: number[]) {\n    this._half = ceilLog2(arr.length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    let i;\n    for (i = 0; i < this._size; ++i) {\n      this._heap[this._half + i] = arr[i];\n    }\n\n    for (i = this._half - 1; i > 0; --i) {\n      this._heap[i] = this._heap[2 * i] + this._heap[2 * i + 1];\n    }\n    this._actualSize = arr.length;\n  }\n\n  static uniform(size: number, initialValue: number) {\n    const xs = [];\n    for (let i = size - 1; i >= 0; --i) {\n      xs[i] = initialValue;\n    }\n\n    return new PrefixIntervalTree(xs);\n  }\n\n  static empty(size: number) {\n    return PrefixIntervalTree.uniform(size, 0);\n  }\n\n  /**\n   * the length should be 2\n   */\n  stretch() {\n    const nextHeap = createArray(2 * this._half * 2);\n    const nextHeapHalf = this._half * 2;\n\n    // copy old value to new one\n    for (let i = 0; i < this._size; i++) {\n      nextHeap[nextHeapHalf + i] = this._heap[this._half + i] || 0;\n    }\n\n    // sum old value to create new sum value\n    for (let i = nextHeapHalf - 1; i > 0; i--) {\n      nextHeap[i] = nextHeap[2 * i] + nextHeap[2 * i + 1];\n    }\n\n    this._half = nextHeapHalf;\n    this._size = nextHeapHalf;\n    this._heap = nextHeap;\n  }\n\n  isValidIndex(index: number) {\n    return typeof index === 'number' && index >= 0 && index < this._actualSize;\n  }\n\n  reflowHeap(startIndex: number, endIndex = this._half * 2 - 2) {\n    const len = Math.log2(this._size);\n\n    Array.from({ length: len }, (v, i) => i).reduce(\n      (acc) => {\n        const { startIndex, endIndex } = acc;\n        const _nextStart = parent(startIndex);\n        const _nextEnd = parent(endIndex);\n\n        for (let idx = _nextStart; idx <= _nextEnd; idx++) {\n          this._heap[idx] = this._heap[2 * idx] + this._heap[2 * idx + 1];\n        }\n\n        return {\n          startIndex: _nextStart,\n          endIndex: _nextEnd,\n        };\n      },\n      {\n        startIndex,\n        endIndex,\n      }\n    );\n  }\n\n  remove(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n\n    this.batchRemove([index]);\n  }\n\n  batchRemove(indices: number[]) {\n    indices.sort((a, b) => a - b);\n\n    indices.forEach((index) => {\n      if (!this.isValidIndex(index)) return;\n      if (isNaN(index)) {\n        console.warn('Passing a NaN value as interval tree index');\n        return;\n      }\n\n      this._heap.splice(this._half + index, 1);\n      this._heap.push(0);\n      this._actualSize = this._actualSize - 1;\n    });\n\n    this.reflowHeap(indices[0] + this._half);\n    if (typeof this._onUpdateIntervalTree === 'function') {\n      this._onUpdateIntervalTree(this._heap);\n    }\n\n    if (typeof this._onUpdateItemLayout === 'function') {\n      for (let idx = indices[0]; idx < this._half; idx++) {\n        this._onUpdateItemLayout(idx, this.get(idx));\n      }\n    }\n  }\n\n  removeV0(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n    if (!this.isValidIndex(index)) return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\n    }\n\n    const nextHeap = createArray(this._half * 2);\n    const copy = this._heap.slice(this._half);\n    copy.splice(index, 1);\n\n    for (let index = this._half; index < this._half * 2; index++) {\n      nextHeap[index] = copy[index - this._half] || 0;\n    }\n\n    for (let index = this._half - 1; index > 0; index--) {\n      nextHeap[index] = nextHeap[2 * index] + nextHeap[2 * index + 1];\n    }\n\n    this._actualSize = this._actualSize - 1;\n    this._heap = nextHeap;\n  }\n\n  set(index: number, value: number) {\n    if (typeof index !== 'number' || index < 0) return false;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return false;\n    }\n\n    while (index >= this._half) {\n      this.stretch();\n    }\n\n    let node = this._half + index;\n    this._heap[node] = value;\n\n    node = parent(node);\n    for (; node !== 0; node = parent(node)) {\n      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];\n    }\n\n    if (index + 1 > this._actualSize) {\n      this._actualSize = index + 1;\n    }\n\n    if (typeof this._onUpdateIntervalTree === 'function') {\n      this._onUpdateIntervalTree(this._heap);\n    }\n\n    if (typeof this._onUpdateItemLayout === 'function') {\n      this._onUpdateItemLayout(index, value);\n    }\n    return true;\n  }\n\n  getMaxUsefulLength() {\n    return this.getActualSize();\n  }\n\n  getActualSize() {\n    return this._actualSize;\n  }\n\n  get(index: number) {\n    // invariant(index >= 0 && index < this._size, 'Index out of range %s', index);\n    const node = this._half + index;\n    return this._heap[node];\n  }\n\n  getSize() {\n    return this._size;\n  }\n\n  getHalf() {\n    return this._half;\n  }\n\n  getHeap() {\n    return this._heap;\n  }\n\n  getMaxValue() {\n    return this._heap[1];\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(end - 1).\n   * End is not included. if end less than 0, then return 0\n   */\n  sumUntil(end: number) {\n    // invariant(end >= 0 && end < this._size + 1, 'Index out of range %s', end);\n\n    if (end <= 0) {\n      return 0;\n    }\n\n    let node = this._half + end - 1;\n    let sum = this._heap[node];\n\n    for (; node !== 1; node = parent(node)) {\n      if (node % 2 === 1) {\n        sum += this._heap[node - 1];\n      }\n    }\n\n    return sum;\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(inclusiveEnd).\n   */\n  sumTo(inclusiveEnd: number) {\n    // invariant(\n    //   inclusiveEnd >= 0 && inclusiveEnd < this._size,\n    //   'Index out of range %s',\n    //   inclusiveEnd\n    // );\n    return this.sumUntil(inclusiveEnd + 1);\n  }\n\n  /**\n   * Returns the sum get(begin) + get(begin + 1) + ... + get(end - 1).\n   * end length is not included\n   */\n  sum(begin: number, end: number) {\n    // invariant(begin <= end, 'Begin must precede end');\n    return this.sumUntil(end) - this.sumUntil(begin);\n  }\n\n  /**\n   * return the biggest i, sumUntil(i) === t\n   * return the biggest i, subUntil(i) < t\n   */\n  greatestLowerBound(t: number) {\n    if (t < 0) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      // not use this._size；this._size always be a big value\n      return Math.max(this._actualSize - 1, 0);\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t < leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize - 1);\n  }\n\n  /**\n   * Return the biggest i, subUntil(i) < t\n   * or -1 if no such i exists.\n   */\n  greatestStrictLowerBound(t: number) {\n    if (t <= 0) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      return Math.max(this._actualSize - 1, 0);\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t <= leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize - 1);\n  }\n\n  /**\n   *\n   * @param minOffset\n   * @param maxOffset\n   * @returns\n   *\n   * pending issue:\n   * when item with length list [100, 0, 100, 0, 0, 100].\n   * then computeRange(100, 200) => { startIndex: 2, endIndex: 6 }\n   *\n   * item index in viewport will be [2, 3, 4, 5], index 6 is not\n   * included just like Array.slice(start, end)\n   *\n   */\n  computeRange(minOffset: number, maxOffset: number) {\n    if (this.getHeap()[1] < minOffset) {\n      return {\n        startIndex: this._actualSize,\n        endIndex: this._actualSize,\n      };\n    }\n\n    return {\n      // the biggest item, value <= minOffset\n      startIndex: this.greatestLowerBound(minOffset),\n\n      // the smallest item, value > maxOffset\n      endIndex: this.leastStrictUpperBound(maxOffset),\n    };\n  }\n\n  /**\n   * Returns the smallest i such that 0 <= i <= size and t <= sumUntil(i), or\n   * size + 1 if no such i exists.\n   */\n  leastUpperBound(t: number) {\n    return this.greatestStrictLowerBound(t) + 1;\n  }\n\n  /**\n   * Returns the smallest i, t < sumUntil(i), it should be used as range end\n   * size + 1 if no such i exists.\n   */\n  leastStrictUpperBound(t: number) {\n    return this.greatestLowerBound(t) + 1;\n  }\n}\n\nexport default PrefixIntervalTree;\n"],"names":["parent","node","Math","floor","createArray","size","xs","i","ceilLog2","x","y","PrefixIntervalTree","opts","initWithNumber","Array","isArray","initWithArray","_ref","onUpdateItemLayout","onUpdateIntervalTree","_onUpdateIntervalTree","_onUpdateItemLayout","_proto","prototype","length","_half","_size","_heap","_actualSize","arr","uniform","initialValue","empty","stretch","nextHeap","nextHeapHalf","isValidIndex","index","reflowHeap","startIndex","endIndex","len","log2","from","v","reduce","acc","_nextStart","_nextEnd","idx","_this","remove","batchRemove","indices","sort","a","b","forEach","_this2","isNaN","console","warn","splice","push","get","removeV0","copy","slice","set","value","getMaxUsefulLength","getActualSize","getSize","getHalf","getHeap","getMaxValue","sumUntil","end","sum","sumTo","inclusiveEnd","begin","greatestLowerBound","t","max","leftSum","min","greatestStrictLowerBound","computeRange","minOffset","maxOffset","leastStrictUpperBound","leastUpperBound"],"mappings":"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"}
+{"version":3,"file":"prefix-interval-tree.esm.js","sources":["../src/index.ts"],"sourcesContent":["const parent = (node: number) => Math.floor(node / 2);\n\nconst createArray = function (size: number) {\n  const xs = [];\n  for (let i = size - 1; i >= 0; --i) {\n    xs[i] = 0;\n  }\n  return xs;\n};\n\n/**\n * Computes the next power of 2 after or equal to x.\n */\nfunction ceilLog2(x: number) {\n  let y = 1;\n  while (y < x) {\n    y *= 2;\n  }\n\n  return y;\n}\n\ntype OperationType = 'set' | 'remove';\n\ntype Operation = {\n  type: OperationType;\n  value: any;\n};\n\n/**\n * A prefix interval tree stores an numeric array and the partial sums of that\n * array. It is optimized for updating the values of the array without\n * recomputing all of the partial sums.\n *\n *   - O(ln n) update\n *   - O(1) lookup\n *   - O(ln n) compute a partial sum\n *   - O(n) space\n *\n * Note that the sequence of partial sums is one longer than the array, so that\n * the first partial sum is always 0, and the last partial sum is the sum of the\n * entire array.\n */\nclass PrefixIntervalTree {\n  private _size: number;\n  /**\n   * Half the size of the heap. It is also the number of non-leaf nodes, and the\n   * index of the first element in the heap. Always a power of 2.\n   */\n  private _half: number;\n  private _heap: number[];\n\n  private _actualSize: number;\n\n  private _onUpdateItemLayout: Function;\n  private _onUpdateIntervalTree: Function;\n\n  private _affectedIndicesMap: {\n    [key: string]: Operation;\n  } = {};\n  private _affectedMinimalIndex: number = undefined;\n  private _cachedSumUntilValues: {\n    [key: string]: number;\n  } = {};\n\n  constructor(\n    xs: number[] | number = 10,\n    opts?: {\n      onUpdateItemLayout?: Function;\n      onUpdateIntervalTree?: Function;\n    }\n  ) {\n    if (typeof xs === 'number') this.initWithNumber(xs);\n    if (Array.isArray(xs)) this.initWithArray(xs);\n\n    const { onUpdateItemLayout, onUpdateIntervalTree } = opts || {};\n    this._onUpdateIntervalTree = onUpdateIntervalTree;\n    this._onUpdateItemLayout = onUpdateItemLayout;\n  }\n\n  initWithNumber(length: number) {\n    this._half = ceilLog2(length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    this._actualSize = 0;\n  }\n\n  initWithArray(arr: number[]) {\n    this._half = ceilLog2(arr.length);\n    this._size = this._half;\n    this._heap = createArray(2 * this._half);\n    let i;\n    for (i = 0; i < this._size; ++i) {\n      this._heap[this._half + i] = arr[i];\n    }\n\n    for (i = this._half - 1; i > 0; --i) {\n      this._heap[i] = this._heap[2 * i] + this._heap[2 * i + 1];\n    }\n    this._actualSize = arr.length;\n  }\n\n  static uniform(size: number, initialValue: number) {\n    const xs = [];\n    for (let i = size - 1; i >= 0; --i) {\n      xs[i] = initialValue;\n    }\n\n    return new PrefixIntervalTree(xs);\n  }\n\n  static empty(size: number) {\n    return PrefixIntervalTree.uniform(size, 0);\n  }\n\n  /**\n   * the length should be 2\n   * it will cause calculation of\n   */\n  stretch() {\n    const nextHeap = createArray(2 * this._half * 2);\n    const nextHeapHalf = this._half * 2;\n\n    // copy old value to new one\n    for (let i = 0; i < this._size; i++) {\n      nextHeap[nextHeapHalf + i] = this._heap[this._half + i] || 0;\n    }\n\n    // sum old value to create new sum value\n    for (let i = nextHeapHalf - 1; i > 0; i--) {\n      nextHeap[i] = nextHeap[2 * i] + nextHeap[2 * i + 1];\n    }\n\n    this._half = nextHeapHalf;\n    this._size = nextHeapHalf;\n    this._heap = nextHeap;\n  }\n\n  indexKey(index: number) {\n    return `${index}`;\n  }\n\n  resolveKeyIndex(key: string) {\n    return parseInt(key, 10);\n  }\n\n  isValidIndex(index: number) {\n    return typeof index === 'number' && index >= 0 && index < this._actualSize;\n  }\n\n  reflowDirectParent(index: number) {\n    this.resetAffected();\n    let node = this._half + index;\n\n    node = parent(node);\n    for (; node !== 0; node = parent(node)) {\n      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];\n    }\n  }\n\n  // recalculate parent value from startIndex to endIndex\n  reflowHeap(_startIndex: number, endIndex = this._half * 2 - 2) {\n    this.resetAffected();\n    const depth = Math.log2(this._size);\n    const startIndex = _startIndex + this._half;\n\n    Array.from({ length: depth }, (v, i) => i).reduce(\n      (acc) => {\n        const { startIndex, endIndex } = acc;\n        const _nextStart = parent(startIndex);\n        const _nextEnd = parent(endIndex);\n\n        for (let idx = _nextStart; idx <= _nextEnd; idx++) {\n          this._heap[idx] = this._heap[2 * idx] + this._heap[2 * idx + 1];\n        }\n\n        return {\n          startIndex: _nextStart,\n          endIndex: _nextEnd,\n        };\n      },\n      {\n        startIndex,\n        endIndex,\n      }\n    );\n  }\n\n  /**\n   *\n   * @param index index to remove\n   * @returns\n   *\n   * update heap only, but not recalculate interval tree value\n   */\n  dryRemove(index: number) {\n    if (!this.isValidIndex(index)) return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\n    }\n\n    this._heap.splice(this._half + index, 1);\n    this._heap.push(0);\n    this._actualSize = this._actualSize - 1;\n\n    this.updateAffectedIndices(index, 'remove');\n  }\n\n  remove(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n\n    this.removeIndices([index]);\n  }\n\n  removeIndices(indices: number[]) {\n    indices.sort((a, b) => a - b);\n\n    indices.forEach((index) => this.dryRemove(index));\n\n    this.reflowHeap(indices[0]);\n    this.onUpdateIntervalTree();\n\n    if (typeof this._onUpdateItemLayout === 'function') {\n      for (let idx = indices[0]; idx < this._half; idx++) {\n        this._onUpdateItemLayout(idx, this.get(idx));\n      }\n    }\n  }\n\n  removeV0(index: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n    if (!this.isValidIndex(index)) return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\n    }\n\n    const nextHeap = createArray(this._half * 2);\n    const copy = this._heap.slice(this._half);\n    copy.splice(index, 1);\n\n    for (let index = this._half; index < this._half * 2; index++) {\n      nextHeap[index] = copy[index - this._half] || 0;\n    }\n\n    for (let index = this._half - 1; index > 0; index--) {\n      nextHeap[index] = nextHeap[2 * index] + nextHeap[2 * index + 1];\n    }\n\n    this._actualSize = this._actualSize - 1;\n    this._heap = nextHeap;\n  }\n\n  resetAffected() {\n    this._affectedIndicesMap = {};\n    this._affectedMinimalIndex = undefined;\n  }\n\n  updateAffectedIndices(index: number, type: OperationType, value?: number) {\n    if (typeof index === 'number') {\n      this._affectedMinimalIndex =\n        typeof this._affectedMinimalIndex === 'number'\n          ? Math.min(this._affectedMinimalIndex, index)\n          : index;\n      this._affectedIndicesMap[this.indexKey(index)] = {\n        value,\n        type,\n      };\n    }\n  }\n\n  onUpdateIntervalTree() {\n    // reset cached value\n    this._cachedSumUntilValues = {};\n\n    if (typeof this._onUpdateIntervalTree === 'function') {\n      this._onUpdateIntervalTree(this._heap);\n    }\n  }\n\n  drySet(index: number, value: number) {\n    if (typeof index !== 'number' || index < 0) return false;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return false;\n    }\n\n    while (index >= this._half) {\n      this.stretch();\n    }\n\n    const node = this._half + index;\n    this._heap[node] = value;\n\n    this.updateAffectedIndices(index, 'set', value);\n\n    if (index + 1 > this._actualSize) {\n      this._actualSize = index + 1;\n    }\n    return true;\n  }\n\n  set(index: number, value: number) {\n    this.drySet(index, value);\n    this.reflowDirectParent(index);\n    this.onUpdateIntervalTree();\n    if (typeof this._onUpdateItemLayout === 'function') {\n      this._onUpdateItemLayout(index, value);\n    }\n    return true;\n  }\n\n  applyUpdate() {\n    if (typeof this._affectedMinimalIndex === 'number') {\n      const index = this._affectedMinimalIndex;\n\n      const keys = Object.keys(this._affectedIndicesMap);\n      const hasRemoveItem = keys.some(\n        (key) => this._affectedIndicesMap[key].type === 'remove'\n      );\n\n      if (hasRemoveItem) {\n        return this.reflowHeap(index);\n      }\n\n      const depth = Math.log2(this._size);\n      const itemLength = keys.length;\n\n      const reflowTimes = this._half - index - 1;\n\n      if (depth * itemLength > reflowTimes) {\n        return this.reflowHeap(index);\n      }\n\n      keys.forEach((key) => this.reflowDirectParent(this.resolveKeyIndex(key)));\n\n      this.onUpdateIntervalTree();\n\n      this.resetAffected();\n    }\n  }\n\n  getMaxUsefulLength() {\n    return this.getActualSize();\n  }\n\n  getActualSize() {\n    return this._actualSize;\n  }\n\n  get(index: number) {\n    // invariant(index >= 0 && index < this._size, 'Index out of range %s', index);\n    const node = this._half + index;\n    return this._heap[node];\n  }\n\n  getSize() {\n    return this._size;\n  }\n\n  getHalf() {\n    return this._half;\n  }\n\n  getHeap() {\n    return this._heap;\n  }\n\n  getMaxValue() {\n    return this._heap[1];\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(end - 1).\n   * End is not included. if end less than 0, then return 0\n   */\n  sumUntil(end: number) {\n    // invariant(end >= 0 && end < this._size + 1, 'Index out of range %s', end);\n\n    if (this._cachedSumUntilValues[`${end}`] != null)\n      return this._cachedSumUntilValues[`${end}`];\n    if (end <= 0) {\n      return 0;\n    }\n\n    let node = this._half + end - 1;\n    let sum = this._heap[node];\n\n    for (; node !== 1; node = parent(node)) {\n      if (node % 2 === 1) {\n        sum += this._heap[node - 1];\n      }\n    }\n\n    return sum;\n  }\n\n  /**\n   * Returns the sum get(0) + get(1) + ... + get(inclusiveEnd).\n   */\n  sumTo(inclusiveEnd: number) {\n    // invariant(\n    //   inclusiveEnd >= 0 && inclusiveEnd < this._size,\n    //   'Index out of range %s',\n    //   inclusiveEnd\n    // );\n    return this.sumUntil(inclusiveEnd + 1);\n  }\n\n  /**\n   * Returns the sum get(begin) + get(begin + 1) + ... + get(end - 1).\n   * end length is not included\n   */\n  sum(begin: number, end: number) {\n    // invariant(begin <= end, 'Begin must precede end');\n    return this.sumUntil(end) - this.sumUntil(begin);\n  }\n\n  /**\n   * return the biggest i, sumUntil(i) === t\n   * return the biggest i, subUntil(i) < t\n   */\n  greatestLowerBound(t: number) {\n    if (t < 0 || !this._actualSize) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      // not use this._size；this._size always be a big value\n      return this._actualSize;\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t < leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize);\n  }\n\n  /**\n   * Return the biggest i, subUntil(i) < t\n   * or -1 if no such i exists.\n   */\n  greatestStrictLowerBound(t: number) {\n    if (t <= 0 || !this._actualSize) {\n      return -1;\n    }\n\n    let node = 1;\n    if (this._heap[node] < t) {\n      return this._actualSize;\n    }\n\n    while (node < this._half) {\n      const leftSum = this._heap[2 * node];\n      if (t <= leftSum) {\n        node = 2 * node;\n      } else {\n        node = 2 * node + 1;\n        t -= leftSum;\n      }\n    }\n\n    return Math.min(node - this._half, this._actualSize);\n  }\n\n  /**\n   *\n   * @param minOffset\n   * @param maxOffset\n   * @returns\n   *\n   * pending issue:\n   * when item with length list [100, 0, 100, 0, 0, 100].\n   * then computeRange(100, 200) => { startIndex: 2, endIndex: 6 }\n   *\n   * item index in viewport will be [2, 3, 4, 5], index 6 is not\n   * included just like Array.slice(start, end)\n   *\n   */\n  computeRange(minOffset: number, maxOffset: number) {\n    if (this.getHeap()[1] < minOffset) {\n      return {\n        startIndex: this._actualSize,\n        endIndex: this._actualSize,\n      };\n    }\n\n    return {\n      // the biggest item, value <= minOffset\n      startIndex: this.greatestLowerBound(minOffset),\n\n      // the smallest item, value > maxOffset\n      endIndex: this.leastStrictUpperBound(maxOffset),\n    };\n  }\n\n  /**\n   * Returns the smallest i such that 0 <= i <= size and t <= sumUntil(i), or\n   * size + 1 if no such i exists.\n   */\n  leastUpperBound(t: number) {\n    return Math.min(this.greatestStrictLowerBound(t) + 1, this._actualSize);\n  }\n\n  /**\n   * Returns the smallest i, t < sumUntil(i), it should be used as range end\n   * size + 1 if no such i exists.\n   */\n  leastStrictUpperBound(t: number) {\n    return Math.min(this.greatestLowerBound(t) + 1, this._actualSize);\n  }\n}\n\nexport default PrefixIntervalTree;\n"],"names":["parent","node","Math","floor","createArray","size","xs","i","ceilLog2","x","y","PrefixIntervalTree","opts","undefined","initWithNumber","Array","isArray","initWithArray","_ref","onUpdateItemLayout","onUpdateIntervalTree","_onUpdateIntervalTree","_onUpdateItemLayout","_proto","prototype","length","_half","_size","_heap","_actualSize","arr","uniform","initialValue","empty","stretch","nextHeap","nextHeapHalf","indexKey","index","resolveKeyIndex","key","parseInt","isValidIndex","reflowDirectParent","resetAffected","reflowHeap","_startIndex","endIndex","depth","log2","startIndex","from","v","reduce","acc","_nextStart","_nextEnd","idx","_this","dryRemove","isNaN","console","warn","splice","push","updateAffectedIndices","remove","removeIndices","indices","sort","a","b","forEach","_this2","get","removeV0","copy","slice","_affectedIndicesMap","_affectedMinimalIndex","type","value","min","_cachedSumUntilValues","drySet","set","applyUpdate","keys","Object","hasRemoveItem","some","_this3","itemLength","reflowTimes","getMaxUsefulLength","getActualSize","getSize","getHalf","getHeap","getMaxValue","sumUntil","end","sum","sumTo","inclusiveEnd","begin","greatestLowerBound","t","leftSum","greatestStrictLowerBound","computeRange","minOffset","maxOffset","leastStrictUpperBound","leastUpperBound"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@x-oasis/prefix-interval-tree",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "prefix interval tree function",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/index.ts

@@ -20,6 +20,13 @@ function ceilLog2(x: number) {
   return y;
 }
 
+type OperationType = 'set' | 'remove';
+
+type Operation = {
+  type: OperationType;
+  value: any;
+};
+
 /**
  * A prefix interval tree stores an numeric array and the partial sums of that
  * array. It is optimized for updating the values of the array without
@@ -48,8 +55,16 @@ class PrefixIntervalTree {
   private _onUpdateItemLayout: Function;
   private _onUpdateIntervalTree: Function;
 
+  private _affectedIndicesMap: {
+    [key: string]: Operation;
+  } = {};
+  private _affectedMinimalIndex: number = undefined;
+  private _cachedSumUntilValues: {
+    [key: string]: number;
+  } = {};
+
   constructor(
-    xs: number[] | number,
+    xs: number[] | number = 10,
     opts?: {
       onUpdateItemLayout?: Function;
       onUpdateIntervalTree?: Function;
@@ -100,6 +115,7 @@ class PrefixIntervalTree {
 
   /**
    * the length should be 2
+   * it will cause calculation of
    */
   stretch() {
     const nextHeap = createArray(2 * this._half * 2);
@@ -120,14 +136,35 @@ class PrefixIntervalTree {
     this._heap = nextHeap;
   }
 
+  indexKey(index: number) {
+    return `${index}`;
+  }
+
+  resolveKeyIndex(key: string) {
+    return parseInt(key, 10);
+  }
+
   isValidIndex(index: number) {
     return typeof index === 'number' && index >= 0 && index < this._actualSize;
   }
 
-  reflowHeap(startIndex: number, endIndex = this._half * 2 - 2) {
-    const len = Math.log2(this._size);
+  reflowDirectParent(index: number) {
+    this.resetAffected();
+    let node = this._half + index;
 
-    Array.from({ length: len }, (v, i) => i).reduce(
+    node = parent(node);
+    for (; node !== 0; node = parent(node)) {
+      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];
+    }
+  }
+
+  // recalculate parent value from startIndex to endIndex
+  reflowHeap(_startIndex: number, endIndex = this._half * 2 - 2) {
+    this.resetAffected();
+    const depth = Math.log2(this._size);
+    const startIndex = _startIndex + this._half;
+
+    Array.from({ length: depth }, (v, i) => i).reduce(
       (acc) => {
         const { startIndex, endIndex } = acc;
         const _nextStart = parent(startIndex);
@@ -149,31 +186,40 @@ class PrefixIntervalTree {
     );
   }
 
+  /**
+   *
+   * @param index index to remove
+   * @returns
+   *
+   * update heap only, but not recalculate interval tree value
+   */
+  dryRemove(index: number) {
+    if (!this.isValidIndex(index)) return;
+    if (isNaN(index)) {
+      console.warn('Passing a NaN value as interval tree index');
+      return;
+    }
+
+    this._heap.splice(this._half + index, 1);
+    this._heap.push(0);
+    this._actualSize = this._actualSize - 1;
+
+    this.updateAffectedIndices(index, 'remove');
+  }
+
   remove(index: number) {
     // if typeof index === 'undefined', then it will go into looooooooop
 
-    this.batchRemove([index]);
+    this.removeIndices([index]);
   }
 
-  batchRemove(indices: number[]) {
+  removeIndices(indices: number[]) {
     indices.sort((a, b) => a - b);
 
-    indices.forEach((index) => {
-      if (!this.isValidIndex(index)) return;
-      if (isNaN(index)) {
-        console.warn('Passing a NaN value as interval tree index');
-        return;
-      }
+    indices.forEach((index) => this.dryRemove(index));
 
-      this._heap.splice(this._half + index, 1);
-      this._heap.push(0);
-      this._actualSize = this._actualSize - 1;
-    });
-
-    this.reflowHeap(indices[0] + this._half);
-    if (typeof this._onUpdateIntervalTree === 'function') {
-      this._onUpdateIntervalTree(this._heap);
-    }
+    this.reflowHeap(indices[0]);
+    this.onUpdateIntervalTree();
 
     if (typeof this._onUpdateItemLayout === 'function') {
       for (let idx = indices[0]; idx < this._half; idx++) {
@@ -206,7 +252,34 @@ class PrefixIntervalTree {
     this._heap = nextHeap;
   }
 
-  set(index: number, value: number) {
+  resetAffected() {
+    this._affectedIndicesMap = {};
+    this._affectedMinimalIndex = undefined;
+  }
+
+  updateAffectedIndices(index: number, type: OperationType, value?: number) {
+    if (typeof index === 'number') {
+      this._affectedMinimalIndex =
+        typeof this._affectedMinimalIndex === 'number'
+          ? Math.min(this._affectedMinimalIndex, index)
+          : index;
+      this._affectedIndicesMap[this.indexKey(index)] = {
+        value,
+        type,
+      };
+    }
+  }
+
+  onUpdateIntervalTree() {
+    // reset cached value
+    this._cachedSumUntilValues = {};
+
+    if (typeof this._onUpdateIntervalTree === 'function') {
+      this._onUpdateIntervalTree(this._heap);
+    }
+  }
+
+  drySet(index: number, value: number) {
     if (typeof index !== 'number' || index < 0) return false;
     if (isNaN(index)) {
       console.warn('Passing a NaN value as interval tree index');
@@ -217,28 +290,57 @@ class PrefixIntervalTree {
       this.stretch();
     }
 
-    let node = this._half + index;
+    const node = this._half + index;
     this._heap[node] = value;
 
-    node = parent(node);
-    for (; node !== 0; node = parent(node)) {
-      this._heap[node] = this._heap[2 * node] + this._heap[2 * node + 1];
-    }
+    this.updateAffectedIndices(index, 'set', value);
 
     if (index + 1 > this._actualSize) {
       this._actualSize = index + 1;
     }
+    return true;
+  }
 
-    if (typeof this._onUpdateIntervalTree === 'function') {
-      this._onUpdateIntervalTree(this._heap);
-    }
-
+  set(index: number, value: number) {
+    this.drySet(index, value);
+    this.reflowDirectParent(index);
+    this.onUpdateIntervalTree();
     if (typeof this._onUpdateItemLayout === 'function') {
       this._onUpdateItemLayout(index, value);
     }
     return true;
   }
 
+  applyUpdate() {
+    if (typeof this._affectedMinimalIndex === 'number') {
+      const index = this._affectedMinimalIndex;
+
+      const keys = Object.keys(this._affectedIndicesMap);
+      const hasRemoveItem = keys.some(
+        (key) => this._affectedIndicesMap[key].type === 'remove'
+      );
+
+      if (hasRemoveItem) {
+        return this.reflowHeap(index);
+      }
+
+      const depth = Math.log2(this._size);
+      const itemLength = keys.length;
+
+      const reflowTimes = this._half - index - 1;
+
+      if (depth * itemLength > reflowTimes) {
+        return this.reflowHeap(index);
+      }
+
+      keys.forEach((key) => this.reflowDirectParent(this.resolveKeyIndex(key)));
+
+      this.onUpdateIntervalTree();
+
+      this.resetAffected();
+    }
+  }
+
   getMaxUsefulLength() {
     return this.getActualSize();
   }
@@ -276,6 +378,8 @@ class PrefixIntervalTree {
   sumUntil(end: number) {
     // invariant(end >= 0 && end < this._size + 1, 'Index out of range %s', end);
 
+    if (this._cachedSumUntilValues[`${end}`] != null)
+      return this._cachedSumUntilValues[`${end}`];
     if (end <= 0) {
       return 0;
     }
@@ -318,14 +422,14 @@ class PrefixIntervalTree {
    * return the biggest i, subUntil(i) < t
    */
   greatestLowerBound(t: number) {
-    if (t < 0) {
+    if (t < 0 || !this._actualSize) {
       return -1;
     }
 
     let node = 1;
     if (this._heap[node] < t) {
       // not use this._size；this._size always be a big value
-      return Math.max(this._actualSize - 1, 0);
+      return this._actualSize;
     }
 
     while (node < this._half) {
@@ -338,7 +442,7 @@ class PrefixIntervalTree {
       }
     }
 
-    return Math.min(node - this._half, this._actualSize - 1);
+    return Math.min(node - this._half, this._actualSize);
   }
 
   /**
@@ -346,13 +450,13 @@ class PrefixIntervalTree {
    * or -1 if no such i exists.
    */
   greatestStrictLowerBound(t: number) {
-    if (t <= 0) {
+    if (t <= 0 || !this._actualSize) {
       return -1;
     }
 
     let node = 1;
     if (this._heap[node] < t) {
-      return Math.max(this._actualSize - 1, 0);
+      return this._actualSize;
     }
 
     while (node < this._half) {
@@ -365,7 +469,7 @@ class PrefixIntervalTree {
       }
     }
 
-    return Math.min(node - this._half, this._actualSize - 1);
+    return Math.min(node - this._half, this._actualSize);
   }
 
   /**
@@ -404,7 +508,7 @@ class PrefixIntervalTree {
    * size + 1 if no such i exists.
    */
   leastUpperBound(t: number) {
-    return this.greatestStrictLowerBound(t) + 1;
+    return Math.min(this.greatestStrictLowerBound(t) + 1, this._actualSize);
   }
 
   /**
@@ -412,7 +516,7 @@ class PrefixIntervalTree {
    * size + 1 if no such i exists.
    */
   leastStrictUpperBound(t: number) {
-    return this.greatestLowerBound(t) + 1;
+    return Math.min(this.greatestLowerBound(t) + 1, this._actualSize);
   }
 }