list-toolkit 1.0.1 → 2.0.0

package/cjs/ListHead.js

@@ -1,308 +0,0 @@
-'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;

package/cjs/SList.js

@@ -1,336 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-class SListNode {
-  constructor() {
-    this.next = this;
-  }
-}
-const pop = prev => {
-  const node = prev.next;
-  prev.next = node.next;
-  node.next = node;
-  return {
-    node,
-    list: prev
-  };
-};
-const extract = (prevFrom, nodeTo) => {
-  const node = prevFrom.next;
-  if (prevFrom === nodeTo) return {
-    prev: prevFrom,
-    node
-  };
-  prevFrom.next = nodeTo.next;
-  nodeTo.next = node;
-  return {
-    prev: nodeTo,
-    node
-  };
-};
-const splice = (prev1, {
-  prev,
-  node
-}) => {
-  prev.next = prev1.next;
-  prev1.next = node;
-  return prev1;
-};
-const getPrevPrev = (list, node) => {
-  let prev = list,
-    current = prev.next;
-  while (current.next !== list) {
-    if (node && current.next === node) return prev;
-    prev = current;
-    current = prev.next;
-  }
-  if (node) {
-    if (list.next === node) return current;
-    throw new Error('node does not belong to the list');
-  }
-  return prev;
-};
-const getPrev = (list, node) => {
-  return getPrevPrev(list, node).next;
-};
-class SListValueNode extends SListNode {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  addAfter(value) {
-    const node = new SListValueNode(value);
-    splice(this, {
-      prev: node,
-      node
-    });
-    return this;
-  }
-  insertAfter(list) {
-    const node = getPrev(pop(list).list);
-    splice(this, {
-      prev: node,
-      node
-    });
-    return this;
-  }
-}
-class SList extends SListNode {
-  get isEmpty() {
-    return this.next === this;
-  }
-  get front() {
-    return this.next;
-  }
-  getBack() {
-    return getPrev(this);
-  }
-  getLength() {
-    let n = 0;
-    for (let p = this.next; p !== this; ++n, p = p.next);
-    return n;
-  }
-  getPtr() {
-    return new SList.SListPtr(this);
-  }
-  popFront() {
-    if (this.next !== this) {
-      return pop(this).node.value;
-    }
-  }
-  popBack() {
-    if (this.next !== this) {
-      const prevLast = getPrevPrev(this);
-      return pop(prevLast).node.value;
-    }
-  }
-  pushFront(value) {
-    const node = new SListValueNode(value);
-    splice(this, {
-      prev: node,
-      node
-    });
-    return this;
-  }
-  pushBack(value) {
-    const node = new SListValueNode(value),
-      last = getPrev(this);
-    splice(last, {
-      prev: node,
-      node
-    });
-    return this;
-  }
-  appendFront(list) {
-    if (list.next === list) return this;
-    let prevFrom = list,
-      nodeTo = getPrev(list);
-    splice(this, extract(prevFrom, nodeTo));
-    return this;
-  }
-  appendBack(list) {
-    if (list.next === list) return this;
-    let prevFrom = list,
-      nodeTo = getPrev(list),
-      last = getPrev(this);
-    splice(last, extract(prevFrom, nodeTo));
-    return this;
-  }
-  moveToFront(node) {
-    let prev;
-    if (node instanceof SList.SListPtr) {
-      prev = node.prev;
-      node = node.node;
-      if (this.next === node) return this;
-    } else {
-      if (this.next === node) return this;
-      prev = getPrev(this, node);
-    }
-    splice(this, extract(prev, node));
-    return this;
-  }
-  moveToBack(node) {
-    let prev;
-    if (node instanceof SList.SListPtr) {
-      prev = node.prev;
-      node = node.node;
-    } else {
-      prev = getPrev(this, node);
-    }
-    const last = getPrev(this);
-    splice(last, extract(prev, node));
-    return this;
-  }
-  clear() {
-    this.next = this;
-    return this;
-  }
-  remove(from, to = from) {
-    const prevFrom = from instanceof SList.SListPtr ? from.prev : getPrev(this, from),
-      nodeTo = to instanceof SList.SListPtr ? to.node : to;
-    extract(prevFrom, nodeTo);
-    return this;
-  }
-  extract(from, to) {
-    const prevFrom = from instanceof SList.SListPtr ? from.prev : getPrev(this, from),
-      nodeTo = to instanceof SList.SListPtr ? to.node : to;
-    return splice(new SList(), extract(prevFrom, nodeTo));
-  }
-  reverse() {
-    let prev = this,
-      current = prev.next;
-    while (current !== this) {
-      const next = current.next;
-      current.next = prev;
-      prev = current;
-      current = next;
-    }
-    this.next = prev;
-    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 node = current;
-        current = current.next;
-        return {
-          value: node.value
-        };
-      }
-    };
-  }
-  getIterable(from, to) {
-    return {
-      [Symbol.iterator]: () => {
-        let current = from instanceof SList.SListPtr && from.node || from || this.next;
-        const stop = to ? (to instanceof SList.SListPtr && to.node || to).next : this;
-        return {
-          next: () => {
-            if (current === stop) return {
-              done: true
-            };
-            const node = current;
-            current = current.next;
-            return {
-              value: node.value
-            };
-          }
-        };
-      }
-    };
-  }
-  getNodeIterable(from, to) {
-    return {
-      [Symbol.iterator]: () => {
-        let current = from instanceof SList.SListPtr && from.node || from || this.next;
-        const stop = to ? (to instanceof SList.SListPtr && to.node || to).next : this;
-        return {
-          next: () => {
-            if (current === stop) return {
-              done: true
-            };
-            const node = current;
-            current = current.next;
-            return {
-              value: node
-            };
-          }
-        };
-      }
-    };
-  }
-  getPtrIterable(from, to) {
-    return {
-      [Symbol.iterator]: () => {
-        let current = from instanceof SList.SListPtr ? from.clone() : from ? new SList.SListPtr(this, getPrev(this.head, from)) : this.getPtr();
-        const stop = to ? (to instanceof SList.SListPtr && to.node || to).next : this;
-        return {
-          next: () => {
-            if (current.node === stop) return {
-              done: true
-            };
-            const value = current.clone();
-            current.next();
-            return {
-              value
-            };
-          }
-        };
-      }
-    };
-  }
-
-  // helpers
-
-  makeFrom(values) {
-    return SList.from(values);
-  }
-  pushValuesFront(values) {
-    for (const value of values) {
-      this.pushFront(value);
-    }
-    return this;
-  }
-  appendValuesFront(values) {
-    return this.appendFront(SList.from(values));
-  }
-  static from(values) {
-    const list = new SList();
-    let prev = list;
-    for (const value of values) {
-      const node = new SListValueNode(value);
-      prev.next = node;
-      prev = node;
-    }
-    prev.next = list;
-    return list;
-  }
-}
-SList.pop = pop;
-SList.extract = extract;
-SList.splice = splice;
-SList.getPrev = getPrev;
-SList.getPrevPrev = getPrevPrev;
-SList.Node = SListNode;
-SList.ValueNode = SListValueNode;
-SList.prototype.pop = SList.prototype.popFront;
-SList.prototype.push = SList.prototype.pushFront;
-SList.prototype.append = SList.prototype.appendBack;
-SList.SListPtr = class SListPtr {
-  constructor(list, prev) {
-    this.list = list;
-    this.prev = prev || list;
-  }
-  get node() {
-    return this.prev.next;
-  }
-  get isHead() {
-    return this.prev.next === this.list;
-  }
-  next() {
-    this.prev = this.prev.next;
-    return this;
-  }
-  clone() {
-    return new SList.SListPtr(this.list, this.prev);
-  }
-};
-var _default = exports.default = SList;