list-toolkit 1.0.1 → 2.0.0

package/src/{MinHeap.js → heap/min-heap.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-import {copyOptions} from './utils.js';
+import {copyOptions} from '../meta-utils.js';
 
 // the following functions are inlined:
 
@@ -45,7 +45,7 @@ const down = (array, i, less = defaultLess, n = array.length) => {
   return array;
 };
 
-class MinHeap {
+export class MinHeap {
   constructor(options, ...args) {
     copyOptions(this, MinHeap.defaults, options);
     this.array = [];
@@ -64,9 +64,8 @@ class MinHeap {
     return this.array[0];
   }
 
-  clear() {
-    this.array = [];
-    return this;
+  peek() {
+    return this.array[0];
   }
 
   pop() {
@@ -175,6 +174,50 @@ class MinHeap {
     return top;
   }
 
+  has(value) {
+    // return MinHeap.has(this.array, value, this.equal); // inlined
+    return this.array.findIndex(element => this.equal(element, value)) >= 0;
+  }
+
+  findIndex(value) {
+    return this.array.findIndex(element => this.equal(element, value));
+  }
+
+  remove(value) {
+    MinHeap.remove(this.array, value, this.less, this.equal);
+    return this;
+  }
+
+  removeByIndex(index) {
+    MinHeap.removeByIndex(this.array, index, this.less);
+    return this;
+  }
+
+  replace(value, newValue) {
+    MinHeap.replace(this.array, value, newValue, this.less, this.equal);
+    return this;
+  }
+
+  replaceByIndex(index, newValue) {
+    MinHeap.replaceByIndex(this.array, index, newValue, this.less);
+    return this;
+  }
+
+  updateTop() {
+    down(this.array, 0, this.less);
+    return this;
+  }
+
+  updateByIndex(index, isDecreased) {
+    MinHeap.updateByIndex(this.array, index, isDecreased, this.less);
+    return this;
+  }
+
+  clear() {
+    this.array = [];
+    return this;
+  }
+
   releaseSorted() {
     MinHeap.sort(this.array, this.less);
     const array = this.array;
@@ -255,10 +298,7 @@ class MinHeap {
 
   static pushPop(heapArray, item, less = MinHeap.defaults.less) {
     if (!heapArray.length || less(item, heapArray[0])) return item;
-    const top = heapArray[0];
-    heapArray[0] = item;
-    down(heapArray, 0, less);
-    return top;
+    return MinHeap.replaceTop(heapArray, item, less);
   }
 
   static replaceTop(heapArray, item, less = MinHeap.defaults.less) {
@@ -268,6 +308,48 @@ class MinHeap {
     return top;
   }
 
+  static has(heapArray, item, equal = MinHeap.defaults.equal) {
+    return heapArray.findIndex(element => equal(element, item)) >= 0;
+  }
+
+  static findIndex(heapArray, item, equal = MinHeap.defaults.equal) {
+    return heapArray.findIndex(element => equal(element, item));
+  }
+
+  static removeByIndex(heapArray, index, less = MinHeap.defaults.less) {
+    if (index < 0 || index >= heapArray.length) return this;
+    const last = heapArray.length - 1;
+    if (index !== last) {
+      const item = heapArray[index],
+        newItem = heapArray[index] = heapArray.pop();
+      return MinHeap.updateByIndex(heapArray, index, less(newItem, item), less);
+    }
+    heapArray.pop();
+    return heapArray;
+  }
+
+  static remove(heapArray, item, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
+    const index = heapArray.findIndex(element => equal(element, item));
+    return MinHeap.removeByIndex(heapArray, index, less);
+  }
+
+  static replaceByIndex(heapArray, index, newItem, less = MinHeap.defaults.less) {
+    if (index < 0 || index >= heapArray.length) return this;
+    const item = heapArray[index];
+    heapArray[index] = newItem;
+    return MinHeap.updateByIndex(heapArray, index, less(newItem, item), less);
+  }
+
+  static replace(heapArray, item, newItem, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
+    const index = heapArray.findIndex(element => equal(element, item));
+    return MinHeap.replaceByIndex(heapArray, index, newItem, less);
+  }
+
+  static updateByIndex(heapArray, index, isDecreased, less = MinHeap.defaults.less) {
+    if (index < 0 || index >= heapArray.length) return this;
+    return (isDecreased ? up : down)(heapArray, index, less);
+  }
+
   static sort(heapArray, less = MinHeap.defaults.less) {
     if (heapArray.length <= 1) return heapArray;
     for (let n = heapArray.length - 1; n; --n) {

package/src/heap.js

@@ -0,0 +1,6 @@
+'use strict';
+
+export * from './heap/min-heap.js';
+import Heap from './heap/min-heap.js';
+
+export default Heap;

package/src/list/basics.js

@@ -0,0 +1,64 @@
+'use strict';
+
+// useful low-level operations on doubly linked lists
+
+export const extract = ({nextName, prevName}, {from, to = from}) => {
+  const next = to[nextName],
+    prev = from[prevName];
+
+  // extract
+  prev[nextName] = next;
+  next[prevName] = prev;
+
+  // clear
+  from[prevName] = to;
+  to[nextName] = from;
+
+  return {extracted: from, rest: next === from ? null : next};
+};
+
+// pop(options, head).node === extract(options, {from: node})
+
+export const pop = ({nextName, prevName}, node) => {
+  const next = node[nextName],
+    prev = node[prevName];
+
+  // extract
+  prev[nextName] = next;
+  next[prevName] = prev;
+
+  // clear
+  node[prevName] = node[nextName] = node;
+
+  return {extracted: node, rest: next === node ? null : next};
+};
+
+export const splice = ({nextName, prevName}, target, circularList) => {
+  const next = target[nextName],
+    from = circularList,
+    to = from[prevName];
+
+  // splice
+  target[nextName] = from;
+  from[prevName] = target;
+  to[nextName] = next;
+  next[prevName] = to;
+
+  return target;
+};
+
+// append(options, target, range) === splice(options, target, extract(options, range))
+
+export const append = ({nextName, prevName}, target, {from, to = from}) => {
+  // extract
+  from[prevName][nextName] = to[nextName];
+  to[nextName][prevName] = from[prevName];
+
+  // splice
+  to[nextName] = target[nextName];
+  to[nextName][prevName] = to;
+  target[nextName] = from;
+  from[prevName] = target;
+
+  return target;
+};

package/src/list/core.js

@@ -0,0 +1,314 @@
+'use strict';
+
+import {ExtListBase, HeadNode} from './nodes.js';
+import {pop, splice, append} from './basics.js';
+import Ptr from './ptr.js';
+import {addAliases, mapIterator, normalizeIterator} from '../meta-utils.js';
+
+export class List extends HeadNode {
+  get frontPtr() {
+    return new Ptr(this, this.front);
+  }
+
+  get backPtr() {
+    return new Ptr(this, this.back);
+  }
+
+  makePtr(node) {
+    if (node && !this.isNodeLike(node)) throw new Error('"node" is not a compatible node');
+    return new Ptr(this, node || this.front);
+  }
+
+  makePtrFromPrev(prev) {
+    if (prev && !this.isNodeLike(prev)) throw new Error('"prev" is not a compatible node');
+    return new Ptr(this, prev ? prev[this.nextName] : this.front);
+  }
+
+  pushFront(value) {
+    const node = this.adoptValue(value);
+    splice(this, this, node);
+    return this.makePtr(node);
+  }
+
+  pushBack(value) {
+    const node = this.adoptValue(value);
+    splice(this, this[this.prevName], node);
+    return this.makePtr(node);
+  }
+
+  popFrontNode() {
+    if (!this.isEmpty) return pop(this, this[this.nextName]).extracted;
+  }
+
+  popBackNode() {
+    if (!this.isEmpty) return pop(this, this[this.prevName]).extracted;
+  }
+
+  pushFrontNode(nodeOrPtr) {
+    const node = this.adoptNode(nodeOrPtr);
+    splice(this, this, node);
+    return this.makePtr(node);
+  }
+
+  pushBackNode(nodeOrPtr) {
+    const node = this.adoptNode(nodeOrPtr);
+    splice(this, this[this.prevName], node);
+    return this.makePtr(node);
+  }
+
+  appendFront(list) {
+    if (!this.isCompatible(list)) throw new Error('Incompatible lists');
+    if (list.isEmpty) return this;
+
+    const head = list[this.nextName];
+    append(this, this, {from: head, to: list[this.prevName]});
+
+    return this.makePtr();
+  }
+
+  appendBack(list) {
+    if (!this.isCompatible(list)) throw new Error('Incompatible lists');
+    if (list.isEmpty) return this;
+
+    const head = list[this.nextName];
+    append(this, this[this.prevName], {from: head, to: list[this.prevName]});
+
+    return this.makePtr(head);
+  }
+
+  moveToFront(nodeOrPtr) {
+    const node = this.normalizeNode(nodeOrPtr);
+    if (this[this.nextName] !== node) {
+      splice(this, this, pop(this, node).extracted);
+    }
+    return this.frontPtr;
+  }
+
+  moveToBack(nodeOrPtr) {
+    const node = this.normalizeNode(nodeOrPtr);
+    if (this[this.prevName] !== node) {
+      splice(this, this[this.prevName], pop(this, node).extracted);
+    }
+    return this.backPtr;
+  }
+
+  clear(drop) {
+    if (drop) {
+      while (!this.isEmpty) this.popFrontNode();
+    } else {
+      this[this.nextName] = this[this.prevName] = this;
+    }
+    return this;
+  }
+
+  removeNode(nodeOrPtr) {
+    return pop(this, this.normalizeNode(nodeOrPtr)).extracted;
+  }
+
+  removeRange(range, drop) {
+    return this.extractRange(range).clear(drop);
+  }
+
+  extractRange(range = {}) {
+    range = this.normalizeRange(range);
+    range.from ||= this.front;
+    range.to ||= this.back;
+    return append(this, this.make(), range);
+  }
+
+  extractBy(condition) {
+    const extracted = this.make();
+    if (this.isEmpty) return extracted;
+
+    while (this.isEmpty && condition(this.front)) extracted.pushBack(this.popFront());
+    if (this.isOneOrEmpty) return extracted;
+
+    for (const ptr of this.getPtrIterator({from: this.front[this.nextName]})) {
+      if (condition(ptr.node)) extracted.pushBack(ptr.removeCurrent());
+    }
+
+    return extracted;
+  }
+
+  reverse() {
+    let current = this;
+    do {
+      const next = current[this.nextName];
+      current[this.nextName] = current[this.prevName];
+      current[this.prevName] = next;
+      current = next;
+    } while (current !== this);
+    return this;
+  }
+
+  sort(lessFn) {
+    if (this.isOneOrEmpty) return this;
+
+    const left = this.make(),
+      right = this.make();
+
+    // split into two sublists
+    for (let isLeft = true; !this.isEmpty; isLeft = !isLeft) {
+      (isLeft ? left : right).pushBackNode(this.popFrontNode());
+    }
+    // the list is empty now
+
+    // sort sublists
+    left.sort(lessFn);
+    right.sort(lessFn);
+
+    // merge sublists
+    while (!left.isEmpty && !right.isEmpty) {
+      this.pushBackNode((lessFn(left.front, right.front) ? left : right).popFrontNode());
+    }
+    if (!left.isEmpty) this.appendBack(left);
+    if (!right.isEmpty) this.appendBack(right);
+
+    return this;
+  }
+
+  releaseRawList() {
+    return this.isEmpty ? null : pop(this, this).rest;
+  }
+
+  releaseNTList() {
+    if (this.isEmpty) return null;
+    const head = this[this.nextName],
+      tail = this[this.prevName];
+    this.clear();
+    head[this.prevName] = tail[this.nextName] = null;
+    return {head, tail};
+  }
+
+  validateRange(range = {}) {
+    range = this.normalizeRange(range);
+    let current = range.from;
+    do {
+      if (current === this) return false;
+      current = current[this.nextName];
+    } while (current !== range.to);
+    return true;
+  }
+
+  // iterators
+
+  [Symbol.iterator]() {
+    let current = this[this.nextName],
+      readyToStop = this.isEmpty;
+    return normalizeIterator({
+      next: () => {
+        if (readyToStop && current === this) return {done: true};
+        readyToStop = true;
+        const value = current;
+        current = current[this.nextName];
+        return {value};
+      }
+    });
+  }
+
+  getNodeIterator(range = {}) {
+    range = this.normalizeRange(range);
+    const {from, to} = range;
+    return {
+      [Symbol.iterator]: () => {
+        let current = from || this[this.nextName],
+          readyToStop = this.isEmpty;
+        const stop = to ? to[this.nextName] : this;
+        return normalizeIterator({
+          next: () => {
+            if (readyToStop && current === stop) return {done: true};
+            readyToStop = true;
+            const value = current;
+            current = current[this.nextName];
+            return {value};
+          }
+        });
+      }
+    };
+  }
+
+  getPtrIterator(range) {
+    return mapIterator(this.getNodeIterator(range), node => new Ptr(this, node));
+  }
+
+  getReverseNodeIterator(range = {}) {
+    range = this.normalizeRange(range);
+    const {from, to} = range;
+    return {
+      [Symbol.iterator]: () => {
+        let current = to || this[this.prevName],
+          readyToStop = this.isEmpty;
+        const stop = from ? from[this.prevName] : this;
+        return normalizeIterator({
+          next: () => {
+            if (readyToStop && current === stop) return {done: true};
+            readyToStop = true;
+            const value = current;
+            current = current[this.prevName];
+            return {value};
+          }
+        });
+      }
+    };
+  }
+
+  getReversePtrIterator(range) {
+    return mapIterator(this.getReverseNodeIterator(range), node => new Ptr(this, node));
+  }
+
+  // meta helpers
+
+  make() {
+    return new List(this);
+  }
+
+  makeFrom(values) {
+    return List.from(values, this);
+  }
+
+  makeFromRange(range) {
+    return List.fromRange(range, this);
+  }
+
+  static from(values, options) {
+    const list = new List(options);
+    for (const value of values) list.pushBack(value);
+    return list;
+  }
+
+  static fromRange(range, options) {
+    const list = new List(options);
+    if (!range) return list;
+
+    range = list.normalizeRange(range);
+    if (!range.from || !range.to) throw new Error('"range" should be fully specified');
+
+    return append(list, list, range);
+  }
+
+  static fromExtList(extList) {
+    if (!(extList instanceof ExtListBase)) throw new Error('Not a circular list');
+
+    const list = new List(extList);
+    if (extList.isEmpty) return list;
+
+    splice(list, list, extList.head);
+    extList.clear();
+
+    return list;
+  }
+}
+
+List.Ptr = Ptr;
+
+addAliases(List.prototype, {
+  popFrontNode: 'popFront, pop',
+  popBackNode: 'popBack',
+  pushFront: 'push',
+  getNodeIterator: 'getIterator',
+  getReverseNodeIterator: 'getReverseIterator',
+  appendBack: 'append'
+});
+
+export {Ptr};
+export default List;

package/src/list/ext-value.js

@@ -0,0 +1,81 @@
+'use strict';
+
+import ExtList, {Ptr} from './ext.js';
+import {ValueNode} from './nodes.js';
+import {addAliases, mapIterator, normalizeIterator} from '../meta-utils.js';
+
+export class ExtValueList extends ExtList {
+  adoptValue(value) {
+    if (value instanceof Ptr) {
+      if (!this.isCompatiblePtr(value)) throw new Error('Incompatible pointer');
+      if (value.node instanceof ValueNode) {
+        value.list = this;
+        return super.adoptNode(value);
+      }
+      return new ValueNode(value.node, this);
+    }
+    if (value instanceof ValueNode) {
+      if (!this.isNodeLike(value)) throw new Error('Incompatible node');
+      return super.adoptNode(value);
+    }
+    return new ValueNode(value, this);
+  }
+
+  // iterators
+
+  [Symbol.iterator]() {
+    let current = this.head,
+      readyToStop = this.isEmpty;
+    return normalizeIterator({
+      next: () => {
+        if (readyToStop && current === this.head) return {done: true};
+        readyToStop = true;
+        const value = current.value;
+        current = current[this.nextName];
+        return {value};
+      }
+    });
+  }
+
+  getValueIterator(range) {
+    return mapIterator(this.getNodeIterator(range), node => node.value);
+  }
+
+  getReverseValueIterator(range) {
+    return mapIterator(this.getReverseNodeIterator(range), node => node.value);
+  }
+
+  // meta helpers
+
+  clone() {
+    return new ExtValueList(this);
+  }
+
+  make(head = null) {
+    return new ExtValueList(head, this);
+  }
+
+  makeFrom(values) {
+    return ExtValueList.from(values, this);
+  }
+
+  static from(values, options) {
+    const list = new ExtValueList(null, options);
+    for (const value of values) {
+      list.addAfter(value);
+      list.next();
+    }
+    return list.next();
+  }
+}
+
+ExtValueList.Ptr = Ptr;
+ExtValueList.ValueNode = ValueNode;
+
+addAliases(ExtValueList.prototype, {
+  getValueIterator: 'getIterator',
+  getReverseValueIterator: 'getReverseIterator'
+});
+
+export {ValueNode};
+export default ExtValueList;