@x-oasis/prefix-interval-tree 0.0.10

package/README.md

@@ -0,0 +1,13 @@
+# @x-oasis/omit
+
+## Installation
+
+```bash
+$ npm i @x-oasis/omit
+```
+
+## How to use
+
+```typescript
+import omit from '@x-oasis/omit'
+```

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+declare class PrefixIntervalTree {
+    private _size;
+    private _half;
+    private _heap;
+    private _maxUsefulLength;
+    private _onUpdateItemLayout;
+    private _onUpdateIntervalTree;
+    constructor(xs: number[] | number, opts?: {
+        onUpdateItemLayout?: Function;
+        onUpdateIntervalTree?: Function;
+    });
+    initWithNumber(length: number): void;
+    initWithArray(arr: number[]): void;
+    static uniform(size: number, initialValue: number): PrefixIntervalTree;
+    static empty(size: number): PrefixIntervalTree;
+    stretch(): void;
+    remove(index: number): boolean;
+    set(index: number, value: number): void;
+    getMaxUsefulLength(): number;
+    get(index: number): number;
+    getSize(): number;
+    getHalf(): number;
+    getHeap(): number[];
+    getMaxValue(): number;
+    sumUntil(end: number): number;
+    sumTo(inclusiveEnd: number): number;
+    sum(begin: number, end: number): number;
+    greatestLowerBound(t: number): number;
+    greatestStrictLowerBound(t: number): number;
+    computeRange(minOffset: number, maxOffset: number): {
+        startIndex: number;
+        endIndex: number;
+    };
+    leastUpperBound(t: number): number;
+    leastStrictUpperBound(t: number): number;
+}
+export default PrefixIntervalTree;

package/dist/index.js

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

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

@@ -0,0 +1,217 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var parent = function parent(node) {
+  return Math.floor(node / 2);
+};
+var createArray = function createArray(size) {
+  var xs = [];
+  for (var i = size - 1; i >= 0; --i) {
+    xs[i] = 0;
+  }
+  return xs;
+};
+function ceilLog2(x) {
+  var y = 1;
+  while (y < x) {
+    y *= 2;
+  }
+  return y;
+}
+var PrefixIntervalTree = /*#__PURE__*/function () {
+  function PrefixIntervalTree(xs, opts) {
+    if (typeof xs === 'number') this.initWithNumber(xs);
+    if (Array.isArray(xs)) this.initWithArray(xs);
+    var _ref = opts || {},
+      onUpdateItemLayout = _ref.onUpdateItemLayout,
+      onUpdateIntervalTree = _ref.onUpdateIntervalTree;
+    this._onUpdateIntervalTree = onUpdateIntervalTree;
+    this._onUpdateItemLayout = onUpdateItemLayout;
+  }
+  var _proto = PrefixIntervalTree.prototype;
+  _proto.initWithNumber = function initWithNumber(length) {
+    this._half = ceilLog2(length);
+    this._size = this._half;
+    this._heap = createArray(2 * this._half);
+    this._maxUsefulLength = 0;
+  };
+  _proto.initWithArray = function initWithArray(arr) {
+    this._half = ceilLog2(arr.length);
+    this._size = this._half;
+    this._heap = createArray(2 * this._half);
+    var i;
+    for (i = 0; i < this._size; ++i) {
+      this._heap[this._half + i] = arr[i];
+    }
+    for (i = this._half - 1; i > 0; --i) {
+      this._heap[i] = this._heap[2 * i] + this._heap[2 * i + 1];
+    }
+  };
+  PrefixIntervalTree.uniform = function uniform(size, initialValue) {
+    var xs = [];
+    for (var i = size - 1; i >= 0; --i) {
+      xs[i] = initialValue;
+    }
+    return new PrefixIntervalTree(xs);
+  };
+  PrefixIntervalTree.empty = function empty(size) {
+    return PrefixIntervalTree.uniform(size, 0);
+  };
+  _proto.stretch = function stretch() {
+    var nextHeap = createArray(2 * this._half * 2);
+    var nextHeapHalf = this._half * 2;
+    for (var i = 0; i < this._size; i++) {
+      nextHeap[nextHeapHalf + i] = this._heap[this._half + i] || 0;
+    }
+    for (var _i = nextHeapHalf - 1; _i > 0; _i--) {
+      nextHeap[_i] = nextHeap[2 * _i] + nextHeap[2 * _i + 1];
+    }
+    this._half = nextHeapHalf;
+    this._size = nextHeapHalf;
+    this._heap = nextHeap;
+  };
+  _proto.remove = function remove(index) {
+    if (index > this._size) return false;
+    var nextHeap = createArray(this._half * 2);
+    for (var i = 0; i < this._size; i++) {
+      var step = 0;
+      if (index === i) {
+        step = 1;
+        continue;
+      }
+      nextHeap[this._half + i - step] = this._heap[this._half + i] || 0;
+    }
+    for (var _i2 = this._half - 1; _i2 > 0; _i2--) {
+      nextHeap[_i2] = nextHeap[2 * _i2] + nextHeap[2 * _i2 + 1];
+    }
+    this._heap = nextHeap;
+    this._maxUsefulLength = Math.max(0, this._maxUsefulLength - 1);
+    return true;
+  };
+  _proto.set = function set(index, value) {
+    if (typeof index !== 'number') return;
+    if (isNaN(index)) {
+      console.warn('Passing a NaN value as interval tree index');
+      return;
+    }
+    while (index >= this._half) {
+      this.stretch();
+    }
+    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];
+    }
+    if (index + 1 > this._maxUsefulLength) {
+      this._maxUsefulLength = index + 1;
+    }
+    if (typeof this._onUpdateIntervalTree === 'function') {
+      this._onUpdateIntervalTree(this._heap);
+    }
+    if (typeof this._onUpdateItemLayout === 'function') {
+      this._onUpdateItemLayout(index, value);
+    }
+  };
+  _proto.getMaxUsefulLength = function getMaxUsefulLength() {
+    return this._maxUsefulLength;
+  };
+  _proto.get = function get(index) {
+    var node = this._half + index;
+    return this._heap[node];
+  };
+  _proto.getSize = function getSize() {
+    return this._size;
+  };
+  _proto.getHalf = function getHalf() {
+    return this._half;
+  };
+  _proto.getHeap = function getHeap() {
+    return this._heap;
+  };
+  _proto.getMaxValue = function getMaxValue() {
+    return this._heap[1];
+  };
+  _proto.sumUntil = function sumUntil(end) {
+    if (end === 0) {
+      return 0;
+    }
+    var node = this._half + end - 1;
+    var sum = this._heap[node];
+    for (; node !== 1; node = parent(node)) {
+      if (node % 2 === 1) {
+        sum += this._heap[node - 1];
+      }
+    }
+    return sum;
+  };
+  _proto.sumTo = function sumTo(inclusiveEnd) {
+    return this.sumUntil(inclusiveEnd + 1);
+  };
+  _proto.sum = function sum(begin, end) {
+    return this.sumUntil(end) - this.sumUntil(begin);
+  };
+  _proto.greatestLowerBound = function greatestLowerBound(t) {
+    if (t < 0) {
+      return -1;
+    }
+    var node = 1;
+    if (this._heap[node] < t) {
+      return Math.max(this._maxUsefulLength - 1, 0);
+    }
+    while (node < this._half) {
+      var leftSum = this._heap[2 * node];
+      if (t < leftSum) {
+        node = 2 * node;
+      } else {
+        node = 2 * node + 1;
+        t -= leftSum;
+      }
+    }
+    return Math.min(node - this._half, this._maxUsefulLength - 1);
+  };
+  _proto.greatestStrictLowerBound = function greatestStrictLowerBound(t) {
+    if (t <= 0) {
+      return -1;
+    }
+    var node = 1;
+    if (this._heap[node] < t) {
+      return Math.max(this._maxUsefulLength - 1, 0);
+    }
+    while (node < this._half) {
+      var leftSum = this._heap[2 * node];
+      if (t <= leftSum) {
+        node = 2 * node;
+      } else {
+        node = 2 * node + 1;
+        t -= leftSum;
+      }
+    }
+    return Math.min(node - this._half, this._maxUsefulLength - 1);
+  };
+  _proto.computeRange = function computeRange(minOffset, maxOffset) {
+    if (this.getHeap()[1] < minOffset) {
+      return {
+        startIndex: this._maxUsefulLength - 1,
+        endIndex: this._maxUsefulLength - 1
+      };
+    }
+    var startIndex = this.leastStrictUpperBound(minOffset);
+    var endIndex = Math.min(this.greatestStrictLowerBound(maxOffset), Math.max(this._maxUsefulLength - 1, 0));
+    return {
+      startIndex: endIndex >= 0 ? Math.max(startIndex, 0) : -1,
+      endIndex: endIndex
+    };
+  };
+  _proto.leastUpperBound = function leastUpperBound(t) {
+    return this.greatestLowerBound(t) + 1;
+  };
+  _proto.leastStrictUpperBound = function leastStrictUpperBound(t) {
+    return this.greatestStrictLowerBound(t);
+  };
+  return PrefixIntervalTree;
+}();
+
+exports.default = PrefixIntervalTree;
+//# sourceMappingURL=prefix-interval-tree.cjs.development.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefix-interval-tree.cjs.development.js","sources":["../src/index.ts"],"sourcesContent":["// import invariant from 'invariant';\n\nconst 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 _maxUsefulLength: 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._maxUsefulLength = 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    // this._maxUsefulLength = arr.length;\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  }\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  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  remove(index: number) {\n    if (index > this._size) return false;\n    const nextHeap = createArray(this._half * 2);\n\n    for (let i = 0; i < this._size; i++) {\n      let step = 0;\n      if (index === i) {\n        step = 1;\n        continue;\n      }\n      nextHeap[this._half + i - step] = this._heap[this._half + i] || 0;\n    }\n\n    for (let i = this._half - 1; i > 0; i--) {\n      nextHeap[i] = nextHeap[2 * i] + nextHeap[2 * i + 1];\n    }\n\n    this._heap = nextHeap;\n\n    this._maxUsefulLength = Math.max(0, this._maxUsefulLength - 1);\n\n    return true;\n  }\n\n  set(index: number, value: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n    if (typeof index !== 'number') return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\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._maxUsefulLength) {\n      this._maxUsefulLength = 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  }\n\n  getMaxUsefulLength() {\n    return this._maxUsefulLength;\n  }\n\n  get(index: number) {\n    // invariant(index >= 0 && index < this._size, 'Index out of range %s', index);\n\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   */\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   */\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   * Returns the smallest i such that 0 <= i <= size and sumUntil(i) <= t, or\n   * -1 if no such i exists.\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._maxUsefulLength - 1, 0);\n    }\n\n    // 这种写法的结果就是，如果中间一个item的length为0的话，那么它会一直往右边查；\n    // 比如初始化的时候是[0, 0, 0, 0, 0, 0, 0, 0]；\n    // 你会发现node最后会是7，this._half为4；最终即使data没有数据，那么它的index算出来的也是\n    // 7 - 4 = 3；所以，考虑到会存在一些item length为0的情况，所以，这个其实是比较合理的方式，\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    return Math.min(node - this._half, this._maxUsefulLength - 1);\n  }\n\n  /**\n   * Returns the smallest i such that 0 <= i <= size and sumUntil(i) < t, or\n   * -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._maxUsefulLength - 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._maxUsefulLength - 1);\n  }\n\n  computeRange(minOffset: number, maxOffset: number) {\n    if (this.getHeap()[1] < minOffset) {\n      return {\n        startIndex: this._maxUsefulLength - 1,\n        endIndex: this._maxUsefulLength - 1,\n      };\n    }\n    const startIndex = this.leastStrictUpperBound(minOffset);\n    // end的话，需要把index + 1，这样才能够把自个也加进去\n    const endIndex = Math.min(\n      this.greatestStrictLowerBound(maxOffset),\n      Math.max(this._maxUsefulLength - 1, 0)\n    );\n\n    return {\n      startIndex: endIndex >= 0 ? Math.max(startIndex, 0) : -1,\n      endIndex,\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.greatestLowerBound(t) + 1;\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  leastStrictUpperBound(t: number) {\n    return this.greatestStrictLowerBound(t);\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","_maxUsefulLength","arr","uniform","initialValue","empty","stretch","nextHeap","nextHeapHalf","remove","index","step","max","set","value","isNaN","console","warn","getMaxUsefulLength","get","getSize","getHalf","getHeap","getMaxValue","sumUntil","end","sum","sumTo","inclusiveEnd","begin","greatestLowerBound","t","leftSum","min","greatestStrictLowerBound","computeRange","minOffset","maxOffset","startIndex","endIndex","leastStrictUpperBound","leastUpperBound"],"mappings":"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"}

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

@@ -0,0 +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=[],h=t-1;h>=0;--h)e[h]=0;return e};function h(t){for(var e=1;e<t;)e*=2;return e}exports.default=function(){function i(t,e){"number"==typeof t&&this.initWithNumber(t),Array.isArray(t)&&this.initWithArray(t);var h=e||{},i=h.onUpdateItemLayout;this._onUpdateIntervalTree=h.onUpdateIntervalTree,this._onUpdateItemLayout=i}var n=i.prototype;return n.initWithNumber=function(t){this._half=h(t),this._size=this._half,this._heap=e(2*this._half),this._maxUsefulLength=0},n.initWithArray=function(t){var i;for(this._half=h(t.length),this._size=this._half,this._heap=e(2*this._half),i=0;i<this._size;++i)this._heap[this._half+i]=t[i];for(i=this._half-1;i>0;--i)this._heap[i]=this._heap[2*i]+this._heap[2*i+1]},i.uniform=function(t,e){for(var h=[],n=t-1;n>=0;--n)h[n]=e;return new i(h)},i.empty=function(t){return i.uniform(t,0)},n.stretch=function(){for(var t=e(2*this._half*2),h=2*this._half,i=0;i<this._size;i++)t[h+i]=this._heap[this._half+i]||0;for(var n=h-1;n>0;n--)t[n]=t[2*n]+t[2*n+1];this._half=h,this._size=h,this._heap=t},n.remove=function(t){if(t>this._size)return!1;for(var h=e(2*this._half),i=0;i<this._size;i++){var n=0;t!==i?h[this._half+i-n]=this._heap[this._half+i]||0:n=1}for(var r=this._half-1;r>0;r--)h[r]=h[2*r]+h[2*r+1];return this._heap=h,this._maxUsefulLength=Math.max(0,this._maxUsefulLength-1),!0},n.set=function(e,h){if("number"==typeof e)if(isNaN(e))console.warn("Passing a NaN value as interval tree index");else{for(;e>=this._half;)this.stretch();var i=this._half+e;for(this._heap[i]=h,i=t(i);0!==i;i=t(i))this._heap[i]=this._heap[2*i]+this._heap[2*i+1];e+1>this._maxUsefulLength&&(this._maxUsefulLength=e+1),"function"==typeof this._onUpdateIntervalTree&&this._onUpdateIntervalTree(this._heap),"function"==typeof this._onUpdateItemLayout&&this._onUpdateItemLayout(e,h)}},n.getMaxUsefulLength=function(){return this._maxUsefulLength},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(0===e)return 0;for(var h=this._half+e-1,i=this._heap[h];1!==h;h=t(h))h%2==1&&(i+=this._heap[h-1]);return i},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._maxUsefulLength-1,0);for(;e<this._half;){var h=this._heap[2*e];t<h?e*=2:(e=2*e+1,t-=h)}return Math.min(e-this._half,this._maxUsefulLength-1)},n.greatestStrictLowerBound=function(t){if(t<=0)return-1;var e=1;if(this._heap[e]<t)return Math.max(this._maxUsefulLength-1,0);for(;e<this._half;){var h=this._heap[2*e];t<=h?e*=2:(e=2*e+1,t-=h)}return Math.min(e-this._half,this._maxUsefulLength-1)},n.computeRange=function(t,e){if(this.getHeap()[1]<t)return{startIndex:this._maxUsefulLength-1,endIndex:this._maxUsefulLength-1};var h=this.leastStrictUpperBound(t),i=Math.min(this.greatestStrictLowerBound(e),Math.max(this._maxUsefulLength-1,0));return{startIndex:i>=0?Math.max(h,0):-1,endIndex:i}},n.leastUpperBound=function(t){return this.greatestLowerBound(t)+1},n.leastStrictUpperBound=function(t){return this.greatestStrictLowerBound(t)},i}();
+//# sourceMappingURL=prefix-interval-tree.cjs.production.min.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefix-interval-tree.cjs.production.min.js","sources":["../src/index.ts"],"sourcesContent":["// import invariant from 'invariant';\n\nconst 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 _maxUsefulLength: 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._maxUsefulLength = 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    // this._maxUsefulLength = arr.length;\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  }\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  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  remove(index: number) {\n    if (index > this._size) return false;\n    const nextHeap = createArray(this._half * 2);\n\n    for (let i = 0; i < this._size; i++) {\n      let step = 0;\n      if (index === i) {\n        step = 1;\n        continue;\n      }\n      nextHeap[this._half + i - step] = this._heap[this._half + i] || 0;\n    }\n\n    for (let i = this._half - 1; i > 0; i--) {\n      nextHeap[i] = nextHeap[2 * i] + nextHeap[2 * i + 1];\n    }\n\n    this._heap = nextHeap;\n\n    this._maxUsefulLength = Math.max(0, this._maxUsefulLength - 1);\n\n    return true;\n  }\n\n  set(index: number, value: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n    if (typeof index !== 'number') return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\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._maxUsefulLength) {\n      this._maxUsefulLength = 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  }\n\n  getMaxUsefulLength() {\n    return this._maxUsefulLength;\n  }\n\n  get(index: number) {\n    // invariant(index >= 0 && index < this._size, 'Index out of range %s', index);\n\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   */\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   */\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   * Returns the smallest i such that 0 <= i <= size and sumUntil(i) <= t, or\n   * -1 if no such i exists.\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._maxUsefulLength - 1, 0);\n    }\n\n    // 这种写法的结果就是，如果中间一个item的length为0的话，那么它会一直往右边查；\n    // 比如初始化的时候是[0, 0, 0, 0, 0, 0, 0, 0]；\n    // 你会发现node最后会是7，this._half为4；最终即使data没有数据，那么它的index算出来的也是\n    // 7 - 4 = 3；所以，考虑到会存在一些item length为0的情况，所以，这个其实是比较合理的方式，\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    return Math.min(node - this._half, this._maxUsefulLength - 1);\n  }\n\n  /**\n   * Returns the smallest i such that 0 <= i <= size and sumUntil(i) < t, or\n   * -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._maxUsefulLength - 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._maxUsefulLength - 1);\n  }\n\n  computeRange(minOffset: number, maxOffset: number) {\n    if (this.getHeap()[1] < minOffset) {\n      return {\n        startIndex: this._maxUsefulLength - 1,\n        endIndex: this._maxUsefulLength - 1,\n      };\n    }\n    const startIndex = this.leastStrictUpperBound(minOffset);\n    // end的话，需要把index + 1，这样才能够把自个也加进去\n    const endIndex = Math.min(\n      this.greatestStrictLowerBound(maxOffset),\n      Math.max(this._maxUsefulLength - 1, 0)\n    );\n\n    return {\n      startIndex: endIndex >= 0 ? Math.max(startIndex, 0) : -1,\n      endIndex,\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.greatestLowerBound(t) + 1;\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  leastStrictUpperBound(t: number) {\n    return this.greatestStrictLowerBound(t);\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","_maxUsefulLength","arr","uniform","initialValue","empty","stretch","nextHeap","nextHeapHalf","remove","index","step","max","set","value","isNaN","console","warn","getMaxUsefulLength","get","getSize","getHalf","getHeap","getMaxValue","sumUntil","end","sum","sumTo","inclusiveEnd","begin","greatestLowerBound","t","leftSum","min","greatestStrictLowerBound","computeRange","minOffset","maxOffset","startIndex","endIndex","leastStrictUpperBound","leastUpperBound"],"mappings":"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"}

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

@@ -0,0 +1,213 @@
+var parent = function parent(node) {
+  return Math.floor(node / 2);
+};
+var createArray = function createArray(size) {
+  var xs = [];
+  for (var i = size - 1; i >= 0; --i) {
+    xs[i] = 0;
+  }
+  return xs;
+};
+function ceilLog2(x) {
+  var y = 1;
+  while (y < x) {
+    y *= 2;
+  }
+  return y;
+}
+var PrefixIntervalTree = /*#__PURE__*/function () {
+  function PrefixIntervalTree(xs, opts) {
+    if (typeof xs === 'number') this.initWithNumber(xs);
+    if (Array.isArray(xs)) this.initWithArray(xs);
+    var _ref = opts || {},
+      onUpdateItemLayout = _ref.onUpdateItemLayout,
+      onUpdateIntervalTree = _ref.onUpdateIntervalTree;
+    this._onUpdateIntervalTree = onUpdateIntervalTree;
+    this._onUpdateItemLayout = onUpdateItemLayout;
+  }
+  var _proto = PrefixIntervalTree.prototype;
+  _proto.initWithNumber = function initWithNumber(length) {
+    this._half = ceilLog2(length);
+    this._size = this._half;
+    this._heap = createArray(2 * this._half);
+    this._maxUsefulLength = 0;
+  };
+  _proto.initWithArray = function initWithArray(arr) {
+    this._half = ceilLog2(arr.length);
+    this._size = this._half;
+    this._heap = createArray(2 * this._half);
+    var i;
+    for (i = 0; i < this._size; ++i) {
+      this._heap[this._half + i] = arr[i];
+    }
+    for (i = this._half - 1; i > 0; --i) {
+      this._heap[i] = this._heap[2 * i] + this._heap[2 * i + 1];
+    }
+  };
+  PrefixIntervalTree.uniform = function uniform(size, initialValue) {
+    var xs = [];
+    for (var i = size - 1; i >= 0; --i) {
+      xs[i] = initialValue;
+    }
+    return new PrefixIntervalTree(xs);
+  };
+  PrefixIntervalTree.empty = function empty(size) {
+    return PrefixIntervalTree.uniform(size, 0);
+  };
+  _proto.stretch = function stretch() {
+    var nextHeap = createArray(2 * this._half * 2);
+    var nextHeapHalf = this._half * 2;
+    for (var i = 0; i < this._size; i++) {
+      nextHeap[nextHeapHalf + i] = this._heap[this._half + i] || 0;
+    }
+    for (var _i = nextHeapHalf - 1; _i > 0; _i--) {
+      nextHeap[_i] = nextHeap[2 * _i] + nextHeap[2 * _i + 1];
+    }
+    this._half = nextHeapHalf;
+    this._size = nextHeapHalf;
+    this._heap = nextHeap;
+  };
+  _proto.remove = function remove(index) {
+    if (index > this._size) return false;
+    var nextHeap = createArray(this._half * 2);
+    for (var i = 0; i < this._size; i++) {
+      var step = 0;
+      if (index === i) {
+        step = 1;
+        continue;
+      }
+      nextHeap[this._half + i - step] = this._heap[this._half + i] || 0;
+    }
+    for (var _i2 = this._half - 1; _i2 > 0; _i2--) {
+      nextHeap[_i2] = nextHeap[2 * _i2] + nextHeap[2 * _i2 + 1];
+    }
+    this._heap = nextHeap;
+    this._maxUsefulLength = Math.max(0, this._maxUsefulLength - 1);
+    return true;
+  };
+  _proto.set = function set(index, value) {
+    if (typeof index !== 'number') return;
+    if (isNaN(index)) {
+      console.warn('Passing a NaN value as interval tree index');
+      return;
+    }
+    while (index >= this._half) {
+      this.stretch();
+    }
+    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];
+    }
+    if (index + 1 > this._maxUsefulLength) {
+      this._maxUsefulLength = index + 1;
+    }
+    if (typeof this._onUpdateIntervalTree === 'function') {
+      this._onUpdateIntervalTree(this._heap);
+    }
+    if (typeof this._onUpdateItemLayout === 'function') {
+      this._onUpdateItemLayout(index, value);
+    }
+  };
+  _proto.getMaxUsefulLength = function getMaxUsefulLength() {
+    return this._maxUsefulLength;
+  };
+  _proto.get = function get(index) {
+    var node = this._half + index;
+    return this._heap[node];
+  };
+  _proto.getSize = function getSize() {
+    return this._size;
+  };
+  _proto.getHalf = function getHalf() {
+    return this._half;
+  };
+  _proto.getHeap = function getHeap() {
+    return this._heap;
+  };
+  _proto.getMaxValue = function getMaxValue() {
+    return this._heap[1];
+  };
+  _proto.sumUntil = function sumUntil(end) {
+    if (end === 0) {
+      return 0;
+    }
+    var node = this._half + end - 1;
+    var sum = this._heap[node];
+    for (; node !== 1; node = parent(node)) {
+      if (node % 2 === 1) {
+        sum += this._heap[node - 1];
+      }
+    }
+    return sum;
+  };
+  _proto.sumTo = function sumTo(inclusiveEnd) {
+    return this.sumUntil(inclusiveEnd + 1);
+  };
+  _proto.sum = function sum(begin, end) {
+    return this.sumUntil(end) - this.sumUntil(begin);
+  };
+  _proto.greatestLowerBound = function greatestLowerBound(t) {
+    if (t < 0) {
+      return -1;
+    }
+    var node = 1;
+    if (this._heap[node] < t) {
+      return Math.max(this._maxUsefulLength - 1, 0);
+    }
+    while (node < this._half) {
+      var leftSum = this._heap[2 * node];
+      if (t < leftSum) {
+        node = 2 * node;
+      } else {
+        node = 2 * node + 1;
+        t -= leftSum;
+      }
+    }
+    return Math.min(node - this._half, this._maxUsefulLength - 1);
+  };
+  _proto.greatestStrictLowerBound = function greatestStrictLowerBound(t) {
+    if (t <= 0) {
+      return -1;
+    }
+    var node = 1;
+    if (this._heap[node] < t) {
+      return Math.max(this._maxUsefulLength - 1, 0);
+    }
+    while (node < this._half) {
+      var leftSum = this._heap[2 * node];
+      if (t <= leftSum) {
+        node = 2 * node;
+      } else {
+        node = 2 * node + 1;
+        t -= leftSum;
+      }
+    }
+    return Math.min(node - this._half, this._maxUsefulLength - 1);
+  };
+  _proto.computeRange = function computeRange(minOffset, maxOffset) {
+    if (this.getHeap()[1] < minOffset) {
+      return {
+        startIndex: this._maxUsefulLength - 1,
+        endIndex: this._maxUsefulLength - 1
+      };
+    }
+    var startIndex = this.leastStrictUpperBound(minOffset);
+    var endIndex = Math.min(this.greatestStrictLowerBound(maxOffset), Math.max(this._maxUsefulLength - 1, 0));
+    return {
+      startIndex: endIndex >= 0 ? Math.max(startIndex, 0) : -1,
+      endIndex: endIndex
+    };
+  };
+  _proto.leastUpperBound = function leastUpperBound(t) {
+    return this.greatestLowerBound(t) + 1;
+  };
+  _proto.leastStrictUpperBound = function leastStrictUpperBound(t) {
+    return this.greatestStrictLowerBound(t);
+  };
+  return PrefixIntervalTree;
+}();
+
+export default PrefixIntervalTree;
+//# sourceMappingURL=prefix-interval-tree.esm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefix-interval-tree.esm.js","sources":["../src/index.ts"],"sourcesContent":["// import invariant from 'invariant';\n\nconst 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 _maxUsefulLength: 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._maxUsefulLength = 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    // this._maxUsefulLength = arr.length;\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  }\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  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  remove(index: number) {\n    if (index > this._size) return false;\n    const nextHeap = createArray(this._half * 2);\n\n    for (let i = 0; i < this._size; i++) {\n      let step = 0;\n      if (index === i) {\n        step = 1;\n        continue;\n      }\n      nextHeap[this._half + i - step] = this._heap[this._half + i] || 0;\n    }\n\n    for (let i = this._half - 1; i > 0; i--) {\n      nextHeap[i] = nextHeap[2 * i] + nextHeap[2 * i + 1];\n    }\n\n    this._heap = nextHeap;\n\n    this._maxUsefulLength = Math.max(0, this._maxUsefulLength - 1);\n\n    return true;\n  }\n\n  set(index: number, value: number) {\n    // if typeof index === 'undefined', then it will go into looooooooop\n    if (typeof index !== 'number') return;\n    if (isNaN(index)) {\n      console.warn('Passing a NaN value as interval tree index');\n      return;\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._maxUsefulLength) {\n      this._maxUsefulLength = 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  }\n\n  getMaxUsefulLength() {\n    return this._maxUsefulLength;\n  }\n\n  get(index: number) {\n    // invariant(index >= 0 && index < this._size, 'Index out of range %s', index);\n\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   */\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   */\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   * Returns the smallest i such that 0 <= i <= size and sumUntil(i) <= t, or\n   * -1 if no such i exists.\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._maxUsefulLength - 1, 0);\n    }\n\n    // 这种写法的结果就是，如果中间一个item的length为0的话，那么它会一直往右边查；\n    // 比如初始化的时候是[0, 0, 0, 0, 0, 0, 0, 0]；\n    // 你会发现node最后会是7，this._half为4；最终即使data没有数据，那么它的index算出来的也是\n    // 7 - 4 = 3；所以，考虑到会存在一些item length为0的情况，所以，这个其实是比较合理的方式，\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    return Math.min(node - this._half, this._maxUsefulLength - 1);\n  }\n\n  /**\n   * Returns the smallest i such that 0 <= i <= size and sumUntil(i) < t, or\n   * -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._maxUsefulLength - 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._maxUsefulLength - 1);\n  }\n\n  computeRange(minOffset: number, maxOffset: number) {\n    if (this.getHeap()[1] < minOffset) {\n      return {\n        startIndex: this._maxUsefulLength - 1,\n        endIndex: this._maxUsefulLength - 1,\n      };\n    }\n    const startIndex = this.leastStrictUpperBound(minOffset);\n    // end的话，需要把index + 1，这样才能够把自个也加进去\n    const endIndex = Math.min(\n      this.greatestStrictLowerBound(maxOffset),\n      Math.max(this._maxUsefulLength - 1, 0)\n    );\n\n    return {\n      startIndex: endIndex >= 0 ? Math.max(startIndex, 0) : -1,\n      endIndex,\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.greatestLowerBound(t) + 1;\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  leastStrictUpperBound(t: number) {\n    return this.greatestStrictLowerBound(t);\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","_maxUsefulLength","arr","uniform","initialValue","empty","stretch","nextHeap","nextHeapHalf","remove","index","step","max","set","value","isNaN","console","warn","getMaxUsefulLength","get","getSize","getHalf","getHeap","getMaxValue","sumUntil","end","sum","sumTo","inclusiveEnd","begin","greatestLowerBound","t","leftSum","min","greatestStrictLowerBound","computeRange","minOffset","maxOffset","startIndex","endIndex","leastStrictUpperBound","leastUpperBound"],"mappings":"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"}

package/package.json

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

package/src/index.ts

@@ -0,0 +1,344 @@
+// import invariant from 'invariant';
+
+const parent = (node: number) => Math.floor(node / 2);
+
+const createArray = function (size: number) {
+  const xs = [];
+  for (let i = size - 1; i >= 0; --i) {
+    xs[i] = 0;
+  }
+  return xs;
+};
+
+/**
+ * Computes the next power of 2 after or equal to x.
+ */
+function ceilLog2(x: number) {
+  let y = 1;
+  while (y < x) {
+    y *= 2;
+  }
+
+  return y;
+}
+
+/**
+ * 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
+ * recomputing all of the partial sums.
+ *
+ *   - O(ln n) update
+ *   - O(1) lookup
+ *   - O(ln n) compute a partial sum
+ *   - O(n) space
+ *
+ * Note that the sequence of partial sums is one longer than the array, so that
+ * the first partial sum is always 0, and the last partial sum is the sum of the
+ * entire array.
+ */
+class PrefixIntervalTree {
+  private _size: number;
+  /**
+   * Half the size of the heap. It is also the number of non-leaf nodes, and the
+   * index of the first element in the heap. Always a power of 2.
+   */
+  private _half: number;
+  private _heap: number[];
+
+  private _maxUsefulLength: number;
+
+  private _onUpdateItemLayout: Function;
+  private _onUpdateIntervalTree: Function;
+
+  constructor(
+    xs: number[] | number,
+    opts?: {
+      onUpdateItemLayout?: Function;
+      onUpdateIntervalTree?: Function;
+    }
+  ) {
+    if (typeof xs === 'number') this.initWithNumber(xs);
+    if (Array.isArray(xs)) this.initWithArray(xs);
+
+    const { onUpdateItemLayout, onUpdateIntervalTree } = opts || {};
+    this._onUpdateIntervalTree = onUpdateIntervalTree;
+    this._onUpdateItemLayout = onUpdateItemLayout;
+  }
+
+  initWithNumber(length: number) {
+    this._half = ceilLog2(length);
+    this._size = this._half;
+    this._heap = createArray(2 * this._half);
+    this._maxUsefulLength = 0;
+  }
+
+  initWithArray(arr: number[]) {
+    this._half = ceilLog2(arr.length);
+    this._size = this._half;
+    this._heap = createArray(2 * this._half);
+    // this._maxUsefulLength = arr.length;
+    let i;
+    for (i = 0; i < this._size; ++i) {
+      this._heap[this._half + i] = arr[i];
+    }
+
+    for (i = this._half - 1; i > 0; --i) {
+      this._heap[i] = this._heap[2 * i] + this._heap[2 * i + 1];
+    }
+  }
+
+  static uniform(size: number, initialValue: number) {
+    const xs = [];
+    for (let i = size - 1; i >= 0; --i) {
+      xs[i] = initialValue;
+    }
+
+    return new PrefixIntervalTree(xs);
+  }
+
+  static empty(size: number) {
+    return PrefixIntervalTree.uniform(size, 0);
+  }
+
+  stretch() {
+    const nextHeap = createArray(2 * this._half * 2);
+    const nextHeapHalf = this._half * 2;
+
+    // copy old value to new one
+    for (let i = 0; i < this._size; i++) {
+      nextHeap[nextHeapHalf + i] = this._heap[this._half + i] || 0;
+    }
+
+    // sum old value to create new sum value
+    for (let i = nextHeapHalf - 1; i > 0; i--) {
+      nextHeap[i] = nextHeap[2 * i] + nextHeap[2 * i + 1];
+    }
+
+    this._half = nextHeapHalf;
+    this._size = nextHeapHalf;
+    this._heap = nextHeap;
+  }
+
+  remove(index: number) {
+    if (index > this._size) return false;
+    const nextHeap = createArray(this._half * 2);
+
+    for (let i = 0; i < this._size; i++) {
+      let step = 0;
+      if (index === i) {
+        step = 1;
+        continue;
+      }
+      nextHeap[this._half + i - step] = this._heap[this._half + i] || 0;
+    }
+
+    for (let i = this._half - 1; i > 0; i--) {
+      nextHeap[i] = nextHeap[2 * i] + nextHeap[2 * i + 1];
+    }
+
+    this._heap = nextHeap;
+
+    this._maxUsefulLength = Math.max(0, this._maxUsefulLength - 1);
+
+    return true;
+  }
+
+  set(index: number, value: number) {
+    // if typeof index === 'undefined', then it will go into looooooooop
+    if (typeof index !== 'number') return;
+    if (isNaN(index)) {
+      console.warn('Passing a NaN value as interval tree index');
+      return;
+    }
+
+    while (index >= this._half) {
+      this.stretch();
+    }
+
+    let 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];
+    }
+
+    if (index + 1 > this._maxUsefulLength) {
+      this._maxUsefulLength = index + 1;
+    }
+
+    if (typeof this._onUpdateIntervalTree === 'function') {
+      this._onUpdateIntervalTree(this._heap);
+    }
+
+    if (typeof this._onUpdateItemLayout === 'function') {
+      this._onUpdateItemLayout(index, value);
+    }
+  }
+
+  getMaxUsefulLength() {
+    return this._maxUsefulLength;
+  }
+
+  get(index: number) {
+    // invariant(index >= 0 && index < this._size, 'Index out of range %s', index);
+
+    const node = this._half + index;
+    return this._heap[node];
+  }
+
+  getSize() {
+    return this._size;
+  }
+
+  getHalf() {
+    return this._half;
+  }
+
+  getHeap() {
+    return this._heap;
+  }
+
+  getMaxValue() {
+    return this._heap[1];
+  }
+
+  /**
+   * Returns the sum get(0) + get(1) + ... + get(end - 1).
+   */
+  sumUntil(end: number) {
+    // invariant(end >= 0 && end < this._size + 1, 'Index out of range %s', end);
+
+    if (end === 0) {
+      return 0;
+    }
+
+    let node = this._half + end - 1;
+    let sum = this._heap[node];
+
+    for (; node !== 1; node = parent(node)) {
+      if (node % 2 === 1) {
+        sum += this._heap[node - 1];
+      }
+    }
+
+    return sum;
+  }
+
+  /**
+   * Returns the sum get(0) + get(1) + ... + get(inclusiveEnd).
+   */
+  sumTo(inclusiveEnd: number) {
+    // invariant(
+    //   inclusiveEnd >= 0 && inclusiveEnd < this._size,
+    //   'Index out of range %s',
+    //   inclusiveEnd
+    // );
+    return this.sumUntil(inclusiveEnd + 1);
+  }
+
+  /**
+   * Returns the sum get(begin) + get(begin + 1) + ... + get(end - 1).
+   */
+  sum(begin: number, end: number) {
+    // invariant(begin <= end, 'Begin must precede end');
+    return this.sumUntil(end) - this.sumUntil(begin);
+  }
+
+  /**
+   * Returns the smallest i such that 0 <= i <= size and sumUntil(i) <= t, or
+   * -1 if no such i exists.
+   */
+  greatestLowerBound(t: number) {
+    if (t < 0) {
+      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._maxUsefulLength - 1, 0);
+    }
+
+    // 这种写法的结果就是，如果中间一个item的length为0的话，那么它会一直往右边查；
+    // 比如初始化的时候是[0, 0, 0, 0, 0, 0, 0, 0]；
+    // 你会发现node最后会是7，this._half为4；最终即使data没有数据，那么它的index算出来的也是
+    // 7 - 4 = 3；所以，考虑到会存在一些item length为0的情况，所以，这个其实是比较合理的方式，
+    // 拿右边的
+    while (node < this._half) {
+      const leftSum = this._heap[2 * node];
+      if (t < leftSum) {
+        node = 2 * node;
+      } else {
+        node = 2 * node + 1;
+        t -= leftSum;
+      }
+    }
+    return Math.min(node - this._half, this._maxUsefulLength - 1);
+  }
+
+  /**
+   * Returns the smallest i such that 0 <= i <= size and sumUntil(i) < t, or
+   * -1 if no such i exists.
+   */
+  greatestStrictLowerBound(t: number) {
+    if (t <= 0) {
+      return -1;
+    }
+
+    let node = 1;
+    if (this._heap[node] < t) {
+      return Math.max(this._maxUsefulLength - 1, 0);
+    }
+
+    while (node < this._half) {
+      const leftSum = this._heap[2 * node];
+      if (t <= leftSum) {
+        node = 2 * node;
+      } else {
+        node = 2 * node + 1;
+        t -= leftSum;
+      }
+    }
+
+    return Math.min(node - this._half, this._maxUsefulLength - 1);
+  }
+
+  computeRange(minOffset: number, maxOffset: number) {
+    if (this.getHeap()[1] < minOffset) {
+      return {
+        startIndex: this._maxUsefulLength - 1,
+        endIndex: this._maxUsefulLength - 1,
+      };
+    }
+    const startIndex = this.leastStrictUpperBound(minOffset);
+    // end的话，需要把index + 1，这样才能够把自个也加进去
+    const endIndex = Math.min(
+      this.greatestStrictLowerBound(maxOffset),
+      Math.max(this._maxUsefulLength - 1, 0)
+    );
+
+    return {
+      startIndex: endIndex >= 0 ? Math.max(startIndex, 0) : -1,
+      endIndex,
+    };
+  }
+
+  /**
+   * Returns the smallest i such that 0 <= i <= size and t <= sumUntil(i), or
+   * size + 1 if no such i exists.
+   */
+  leastUpperBound(t: number) {
+    return this.greatestLowerBound(t) + 1;
+  }
+
+  /**
+   * Returns the smallest i such that 0 <= i <= size and t < sumUntil(i), or
+   * size + 1 if no such i exists.
+   */
+  leastStrictUpperBound(t: number) {
+    return this.greatestStrictLowerBound(t);
+  }
+}
+
+export default PrefixIntervalTree;