list-toolkit 1.0.1

package/cjs/List.js

@@ -0,0 +1,291 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class ListNode {
+  constructor() {
+    this.prev = this.next = this;
+  }
+}
+const pop = head => {
+  const rest = head.next;
+  head.prev.next = head.next;
+  head.next.prev = head.prev;
+  head.prev = head.next = head;
+  return {
+    node: head,
+    list: rest
+  };
+};
+const extract = (from, to) => {
+  const prev = from.prev,
+    next = to.next;
+  prev.next = next;
+  next.prev = prev;
+  from.prev = to;
+  to.next = from;
+  return from;
+};
+const splice = (head1, head2) => {
+  const tail1 = head1.prev,
+    tail2 = head2.prev;
+  tail1.next = head2;
+  head2.prev = tail1;
+  tail2.next = head1;
+  head1.prev = tail2;
+  return head1;
+};
+class ListValueNode extends ListNode {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  pop() {
+    return pop(this).node.value;
+  }
+  addBefore(value) {
+    splice(this, new ListValueNode(value));
+    return this;
+  }
+  addAfter(value) {
+    splice(this.next, new ListValueNode(value));
+    return this;
+  }
+  insertBefore(list) {
+    splice(this, pop(list).list);
+    return this;
+  }
+  insertAfter(list) {
+    splice(this.next, pop(list).list);
+    return this;
+  }
+}
+class List extends ListNode {
+  get isEmpty() {
+    return this.next === this;
+  }
+  get front() {
+    return this.next;
+  }
+  get back() {
+    return this.prev;
+  }
+  getLength() {
+    let n = 0;
+    for (let p = this.next; p !== this; ++n, p = p.next);
+    return n;
+  }
+  popFront() {
+    if (this.next !== this) {
+      return this.next.pop();
+    }
+  }
+  popBack() {
+    if (this.next !== this) {
+      return this.prev.pop();
+    }
+  }
+  pushFront(value) {
+    splice(this.next, new ListValueNode(value));
+    return this;
+  }
+  pushBack(value) {
+    splice(this, new ListValueNode(value));
+    return this;
+  }
+  appendFront(list) {
+    if (list.next !== list) {
+      splice(this.next, extract(list.next, list.prev));
+    }
+    return this;
+  }
+  appendBack(list) {
+    if (list.next !== list) {
+      splice(this, extract(list.next, list.prev));
+    }
+    return this;
+  }
+  moveToFront(node) {
+    if (this.next !== node) {
+      splice(this.next, extract(node, node));
+    }
+    return this;
+  }
+  moveToBack(node) {
+    if (this.prev !== node) {
+      splice(this, extract(node, node));
+    }
+    return this;
+  }
+  clear() {
+    this.prev = this.next = this;
+    return this;
+  }
+  remove(from, to = from) {
+    extract(from, to);
+    return this;
+  }
+  extract(from, to) {
+    return splice(new List(), extract(from, to));
+  }
+  reverse() {
+    let next = this.next;
+    this.next = this.prev;
+    this.prev = next;
+    while (next !== this) {
+      const node = next;
+      next = node.next;
+      node.next = node.prev;
+      node.prev = next;
+    }
+    return this;
+  }
+  sort(compareFn) {
+    let current = this.next;
+    for (const value of Array.from(this).sort(compareFn)) {
+      current.value = value;
+      current = current.next;
+    }
+    return this;
+  }
+
+  // iterators
+
+  [Symbol.iterator]() {
+    let current = this.next;
+    return {
+      next: () => {
+        if (current === this) return {
+          done: true
+        };
+        const value = current.value;
+        current = current.next;
+        return {
+          value
+        };
+      }
+    };
+  }
+  getIterable(from, to) {
+    return {
+      [Symbol.iterator]: () => {
+        let current = from || this.next;
+        const stop = to ? to.next : this;
+        return {
+          next: () => {
+            if (current === stop) return {
+              done: true
+            };
+            const value = current.value;
+            current = current.next;
+            return {
+              value
+            };
+          }
+        };
+      }
+    };
+  }
+  getNodeIterable(from, to) {
+    return {
+      [Symbol.iterator]: () => {
+        let current = from || this.next;
+        const stop = to ? to.next : this;
+        return {
+          next: () => {
+            if (current === stop) return {
+              done: true
+            };
+            const value = current;
+            current = current.next;
+            return {
+              value
+            };
+          }
+        };
+      }
+    };
+  }
+  getReverseIterable(from, to) {
+    return {
+      [Symbol.iterator]: () => {
+        let current = to || this.prev;
+        const stop = from ? from.prev : this;
+        return {
+          next: () => {
+            if (current === stop) return {
+              done: true
+            };
+            const value = current.value;
+            current = current.prev;
+            return {
+              value
+            };
+          }
+        };
+      }
+    };
+  }
+  getReverseNodeIterable(from, to) {
+    return {
+      [Symbol.iterator]: () => {
+        let current = to || this.prev;
+        const stop = from ? from.prev : this;
+        return {
+          next: () => {
+            if (current === stop) return {
+              done: true
+            };
+            const value = current;
+            current = current.prev;
+            return {
+              value
+            };
+          }
+        };
+      }
+    };
+  }
+
+  // helpers
+
+  makeFrom(values) {
+    return List.from(values);
+  }
+  pushValuesFront(values) {
+    for (const value of values) {
+      this.pushFront(value);
+    }
+    return this;
+  }
+  pushValuesBack(values) {
+    for (const value of values) {
+      this.pushBack(value);
+    }
+    return this;
+  }
+  appendValuesFront(values) {
+    return this.appendFront(List.from(values));
+  }
+  appendValuesBack(values) {
+    return this.appendBack(List.from(values));
+  }
+  static from(values) {
+    const list = new List();
+    for (const value of values) {
+      list.pushBack(value);
+    }
+    return list;
+  }
+}
+List.pop = pop;
+List.extract = extract;
+List.splice = splice;
+List.Node = ListNode;
+List.ValueNode = ListValueNode;
+List.prototype.pop = List.prototype.popFront;
+List.prototype.push = List.prototype.pushFront;
+List.prototype.append = List.prototype.appendBack;
+var _default = exports.default = List;

package/cjs/ListHead.js

@@ -0,0 +1,308 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils.js");
+class ListHead {
+  constructor(head = null, options) {
+    if (head instanceof ListHead) {
+      ({
+        nextName: this.nextName,
+        prevName: this.prevName,
+        head: this.head
+      } = head);
+      return;
+    }
+    (0, _utils.copyOptions)(this, ListHead.defaults, options);
+    if (head instanceof ListHead.Unsafe) {
+      this.head = head.head;
+      return;
+    }
+    if (head) {
+      switch ((head[this.nextName] ? 2 : 0) + (head[this.prevName] ? 1 : 0)) {
+        case 0:
+          this.adopt(head);
+          break;
+        case 3:
+          // do nothing
+          break;
+        default:
+          throw new Error(`head is not an empty object nor a list with required properties (${this.nextName}, ${this.prevName})`);
+      }
+    } else {
+      head = this.makeNode();
+    }
+    this.head = head;
+  }
+  get isEmpty() {
+    return this.head[this.nextName] === this.head;
+  }
+  get front() {
+    return this.head[this.nextName];
+  }
+  get back() {
+    return this.head[this.prevName];
+  }
+  getLength() {
+    let n = 0;
+    for (let p = this.head[this.nextName]; p !== this.head; ++n, p = p[this.nextName]);
+    return n;
+  }
+  popFront() {
+    if (this.head[this.prevName] !== this.head) {
+      return ListHead.pop(this, this.head[this.nextName]).node;
+    }
+  }
+  popBack() {
+    if (this.head[this.prevName] !== this.head) {
+      return ListHead.pop(this, this.head[this.prevName]).node;
+    }
+  }
+  pushFront(node) {
+    this.adopt(node);
+    ListHead.splice(this, this.head[this.nextName], node);
+    return this;
+  }
+  pushBack(node) {
+    this.adopt(node);
+    ListHead.splice(this, this.head, node);
+    return this;
+  }
+  appendFront(list) {
+    if (list instanceof ListHead) {
+      list = list.head;
+    }
+    if (list[this.prevName] !== list) {
+      ListHead.splice(this, this.head[this.nextName], ListHead.extract(this, list[this.nextName], list[this.prevName]));
+    }
+    return this;
+  }
+  appendBack(list) {
+    if (list instanceof ListHead) {
+      list = list.head;
+    }
+    if (list[this.prevName] !== list) {
+      ListHead.splice(this, this.head, ListHead.extract(this, list[this.nextName], list[this.prevName]));
+    }
+    return this;
+  }
+  moveToFront(node) {
+    if (this.head[this.nextName] !== node) {
+      ListHead.splice(this, this.head[this.nextName], ListHead.extract(this, node, node));
+    }
+    return this;
+  }
+  moveToBack(node) {
+    if (this.head[this.prevName] !== node) {
+      ListHead.splice(this, this.head, ListHead.extract(this, node, node));
+    }
+    return this;
+  }
+  clear(drop) {
+    if (drop) {
+      while (!this.isEmpty) this.popFront();
+    } else {
+      this.head[this.prevName] = this.head[this.nextName] = this.head;
+    }
+    return this;
+  }
+  remove(from, to = from) {
+    ListHead.extract(this, from, to);
+    return this;
+  }
+  extract(from, to) {
+    return this.make(ListHead.splice(this, this.makeNode(), ListHead.extract(this, from, to)));
+  }
+  reverse() {
+    const list = this.head;
+    let next = list[this.nextName];
+    list[this.nextName] = list[this.prevName];
+    list[this.prevName] = next;
+    while (next !== list) {
+      const node = next;
+      next = node[this.nextName];
+      node[this.nextName] = node[this.prevName];
+      node[this.prevName] = next;
+    }
+    return this;
+  }
+  sort(compareFn) {
+    let prev = this.head;
+    for (const node of Array.from(this).sort(compareFn)) {
+      prev[this.nextName] = node;
+      node[this.prevName] = prev;
+      prev = node;
+    }
+    this.head[this.prevName] = prev;
+    prev[this.nextName] = this.head;
+    return this;
+  }
+
+  // iterators
+
+  [Symbol.iterator]() {
+    let current = this.head[this.nextName];
+    return {
+      next: () => {
+        if (current === this.head) return {
+          done: true
+        };
+        const value = current;
+        current = current[this.nextName];
+        return {
+          value
+        };
+      }
+    };
+  }
+  getIterable(from, to) {
+    return {
+      [Symbol.iterator]: () => {
+        let current = from || this.head[this.nextName];
+        const stop = to ? to[this.nextName] : this.head;
+        return {
+          next: () => {
+            if (current === stop) return {
+              done: true
+            };
+            const value = current;
+            current = current[this.nextName];
+            return {
+              value
+            };
+          }
+        };
+      }
+    };
+  }
+  getReverseIterable(from, to) {
+    return {
+      [Symbol.iterator]: () => {
+        let current = to || this.head[this.prevName];
+        const stop = from ? from[this.prevName] : this.head;
+        return {
+          next: () => {
+            if (current === stop) return {
+              done: true
+            };
+            const value = current;
+            current = current[this.prevName];
+            return {
+              value
+            };
+          }
+        };
+      }
+    };
+  }
+
+  // static utilities
+
+  static pop({
+    nextName,
+    prevName
+  }, node) {
+    const list = node[nextName];
+    // the next line stitches the rest of the list excluding the node, and collapse the node into a one-node list
+    node[prevName] = node[nextName] = ({
+      [nextName]: node[prevName][nextName],
+      [prevName]: node[nextName][prevName]
+    } = node);
+    return {
+      node,
+      list
+    };
+  }
+  static extract({
+    nextName,
+    prevName
+  }, from, to) {
+    const prev = from[prevName],
+      next = to[nextName];
+    prev[nextName] = next;
+    next[prevName] = prev;
+    from[prevName] = to;
+    to[nextName] = from;
+    return from;
+  }
+  static splice({
+    nextName,
+    prevName
+  }, list1, list2) {
+    const tail1 = list1[prevName],
+      tail2 = list2[prevName];
+    tail1[nextName] = list2;
+    list2[prevName] = tail1;
+    tail2[nextName] = list1;
+    list1[prevName] = tail2;
+    return list1;
+  }
+
+  // node helpers
+
+  makeNode() {
+    const node = {};
+    node[this.nextName] = node[this.prevName] = node;
+    return node;
+  }
+  adopt(node) {
+    if (node[this.nextName] || node[this.prevName]) {
+      if (node[this.nextName] === node && node[this.prevName] === node) return node;
+      throw new Error('node is already a part of a list, or there is a name clash');
+    }
+    node[this.nextName] = node[this.prevName] = node;
+    return node;
+  }
+
+  // helpers
+
+  clone() {
+    return new ListHead(this);
+  }
+  make(newHead = null) {
+    return new ListHead(newHead, this);
+  }
+  makeFrom(values) {
+    return ListHead.from(values, this);
+  }
+  pushValuesFront(values) {
+    for (const value of values) {
+      this.pushFront(value);
+    }
+    return this;
+  }
+  pushValuesBack(values) {
+    for (const value of values) {
+      this.pushBack(value);
+    }
+    return this;
+  }
+  appendValuesFront(values) {
+    return this.appendFront(ListHead.from(values, this));
+  }
+  appendValuesBack(values) {
+    return this.appendBack(ListHead.from(values, this));
+  }
+  static from(values, options) {
+    const list = new ListHead(null, options);
+    for (const value of values) {
+      list.pushBack(value);
+    }
+    return list;
+  }
+}
+ListHead.defaults = {
+  nextName: 'next',
+  prevName: 'prev'
+};
+ListHead.prototype.pop = ListHead.prototype.popFront;
+ListHead.prototype.push = ListHead.prototype.pushFront;
+ListHead.prototype.append = ListHead.prototype.appendBack;
+ListHead.Unsafe = class {
+  constructor(head) {
+    this.head = head;
+  }
+};
+var _default = exports.default = ListHead;