list-toolkit 1.0.2 → 2.1.0

package/src/list/ext.js

@@ -0,0 +1,370 @@
+'use strict';
+
+import {ExtListBase, PtrBase} from './nodes.js';
+import {pop, extract, splice, append} from './basics.js';
+import {addAliases, normalizeIterator} from '../meta-utils.js';
+
+export class Ptr extends PtrBase {
+  constructor(list, node) {
+    super(list, node, ExtList);
+    this.node ||= this.list.head;
+  }
+  clone() {
+    return new Ptr(this);
+  }
+}
+
+export class ExtList extends ExtListBase {
+  makePtr(node) {
+    if (node && !this.isNodeLike(node)) throw new Error('"node" is not a compatible node');
+    node ||= this.head;
+    return node ? new Ptr(this, node) : null;
+  }
+
+  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);
+  }
+
+  // Ptr API
+
+  removeCurrent() {
+    if (!this.head) return null;
+    if (this.head[this.nextName] === this.head) {
+      const node = this.head;
+      this.head = null;
+      return node;
+    }
+    const result = pop(this, this.head);
+    this.head = result.rest;
+    return result.extracted;
+  }
+
+  removeNodeBefore() {
+    return this.head ? this.removeNode(this.head[this.prevName]) : null;
+  }
+
+  removeNodeAfter() {
+    return this.head ? this.removeNode(this.head[this.nextName]) : null;
+  }
+
+  addBefore(value) {
+    const node = this.adoptValue(value);
+    if (this.head) {
+      splice(this, this.head[this.prevName], node);
+    } else {
+      this.head = node;
+    }
+    return this.makePtr(node);
+  }
+
+  addAfter(value) {
+    const node = this.adoptValue(value);
+    if (this.head) {
+      splice(this, this.head, node);
+    } else {
+      this.head = node;
+    }
+    return this.makePtr(node);
+  }
+
+  addNodeBefore(nodeOrPtr) {
+    const node = this.adoptNode(nodeOrPtr);
+    if (this.head) {
+      splice(this, this.head[this.prevName], node);
+    } else {
+      this.head = node;
+    }
+    return this.makePtr(node);
+  }
+
+  addNodeAfter(nodeOrPtr) {
+    const node = this.adoptNode(nodeOrPtr);
+    if (this.head) {
+      splice(this, this.head, node);
+    } else {
+      this.head = node;
+    }
+    return this.makePtr(node);
+  }
+
+  insertBefore(extList) {
+    if (!this.isCompatible(extList)) throw new Error('Incompatible lists');
+
+    const head = extList.head;
+    if (head) {
+      splice(this, this.head[this.prevName], head);
+      extList.head = null;
+    }
+
+    return this.makePtr(head);
+  }
+
+  insertAfter(extList) {
+    if (!this.isCompatible(extList)) throw new Error('Incompatible lists');
+
+    const head = extList.head;
+    if (head) {
+      splice(this, this.head, head);
+      extList.head = null;
+    }
+
+    return this.makePtr(head);
+  }
+
+  moveBefore(nodeOrPtr) {
+    const node = this.normalizeNode(nodeOrPtr);
+
+    if (this.head === node) {
+      this.head = this.head[this.nextName];
+      return this;
+    }
+
+    if (this.head) {
+      append(this, this.head[this.prevName], {from: node});
+    } else {
+      pop(this, node);
+      this.head = node;
+    }
+
+    return this.makePtr(node);
+  }
+
+  moveAfter(nodeOrPtr) {
+    const node = this.normalizeNode(nodeOrPtr);
+
+    if (this.head === node) {
+      this.head = this.head[this.prevName];
+      return this;
+    }
+
+    if (this.head) {
+      append(this, this.head, {from: node});
+    } else {
+      pop(this, node);
+      this.head = node;
+    }
+
+    return this.makePtr(node);
+  }
+
+  // List API
+
+  clear(drop) {
+    if (drop) {
+      for (const current of this.getNodeIterator()) {
+        current[this.nextName] = current[this.prevName] = current; // make stand-alone
+      }
+    }
+    this.head = null;
+    return this;
+  }
+
+  removeNode(nodeOrPtr) {
+    if (!this.head) return null;
+
+    const node = this.normalizeNode(nodeOrPtr);
+
+    if (this.head === node) {
+      // remove head
+      if (this.head[this.nextName] === this.head) {
+        // single node
+        this.head = null;
+        return node;
+      }
+      this.head = this.head[this.nextName];
+    }
+
+    return pop(this, node).extracted;
+  }
+
+  removeRange(range, drop) {
+    return this.extractRange(range).clear(drop);
+  }
+
+  extractRange(range = {}) {
+    range = this.normalizeRange(range);
+    const {from = this.head, to = from} = range;
+
+    const extracted = this.make();
+    if (!this.head) return extracted;
+    if (this.head === from || this.head === to) this.head = to[this.nextName];
+    if (this.head === from) this.head = null;
+    extracted.head = extract(this, {from, to}).extracted;
+
+    return extracted;
+  }
+
+  extractBy(condition) {
+    const extracted = this.make();
+    if (this.isEmpty) return extracted;
+
+    const rest = this.make();
+    for (const current of this.getNodeIterator()) {
+      current[this.nextName] = current[this.prevName] = current; // make stand-alone
+      (condition(current) ? extracted : rest).addBefore(current);
+    }
+    this.head = rest.head;
+
+    return extracted;
+  }
+
+  reverse() {
+    if (this.isOneOrEmpty) return this;
+    let current = this.head;
+    do {
+      const next = current[this.nextName];
+      current[this.nextName] = current[this.prevName];
+      current[this.prevName] = next;
+      current = next;
+    } while (current !== this.head);
+    this.head = this.head[this.nextName];
+    return this;
+  }
+
+  sort(lessFn) {
+    if (this.isOneOrEmpty) return this;
+
+    const left = this.make(),
+      right = this.make();
+
+    // split into two sublists
+    let isLeft = true;
+    for (const current of this.getNodeIterator()) {
+      current[this.nextName] = current[this.prevName] = current; // make stand-alone
+      if (isLeft) {
+        left.addNodeAfter(current);
+        left.next();
+      } else {
+        right.addNodeAfter(current);
+        right.next();
+      }
+      isLeft = !isLeft;
+    }
+    this.clear();
+    // the list is empty now
+
+    // sort sublists
+    left.next().sort(lessFn);
+    right.next().sort(lessFn);
+
+    // merge sublists
+    while (!left.isEmpty && !right.isEmpty) {
+      this.addNodeAfter((lessFn(left.head, right.head) ? left : right).removeCurrent());
+      this.next();
+    }
+    if (!left.isEmpty) {
+      const last = left.head[left.prevName];
+      this.insertAfter(left);
+      this.head = last;
+    }
+    if (!right.isEmpty) {
+      const last = right.head[right.prevName];
+      this.insertAfter(right);
+      this.head = last;
+    }
+
+    return this.next();
+  }
+
+  // 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;
+        current = current[this.nextName];
+        return {value};
+      }
+    });
+  }
+
+  getNodeIterator(range = {}) {
+    range = this.normalizeRange(range);
+    const {from, to} = range;
+    return {
+      [Symbol.iterator]: () => {
+        let readyToStop = this.isEmpty,
+          current = readyToStop ? null : from || this.head;
+        const stop = readyToStop ? null : to ? to[this.nextName] : this.head;
+        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 readyToStop = this.isEmpty,
+          current = readyToStop ? null : to || this.head[this.prevName];
+        const stop = readyToStop ? null : from ? from[this.prevName] : this.head[this.prevName];
+        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
+
+  clone() {
+    return new ExtList(this);
+  }
+
+  make(head = null) {
+    return new ExtList(head, this);
+  }
+
+  makeFrom(values) {
+    return ExtList.from(values, this);
+  }
+
+  static from(values, options) {
+    const list = new ExtList(null, options);
+    for (const value of values) {
+      list.addNodeAfter(value);
+      list.next();
+    }
+    return list.next();
+  }
+}
+
+ExtList.Ptr = Ptr;
+
+addAliases(ExtList.prototype, {
+  addAfter: 'add',
+  removeNodeBefore: 'removeBefore',
+  removeNodeAfter: 'removeAfter',
+  getNodeIterator: 'getIterator',
+  getReverseNodeIterator: 'getReverseIterator'
+});
+
+export default ExtList;

package/src/list/nodes.js

@@ -0,0 +1,262 @@
+'use strict';
+
+import {isRangeLike, normalizeNode, normalizeRange} from '../list-helpers.js';
+import {addAlias, copyDescriptors} from '../meta-utils.js';
+
+export const isNodeLike = ({nextName, prevName}, node) => node && node[prevName] && node[nextName];
+export const isStandAlone = ({nextName, prevName}, node) => node && node[prevName] === node && node[nextName] === node;
+export const isCompatible = (options1, options2) => options1.nextName === options2.nextName && options1.prevName === options2.prevName;
+
+export class Node {
+  constructor({nextName = 'next', prevName = 'prev'} = {}) {
+    this.nextName = nextName;
+    this.prevName = prevName;
+    this[nextName] = this[prevName] = this;
+  }
+  get isStandAlone() {
+    return this[this.nextName] === this;
+  }
+}
+
+export class HeadNode extends Node {
+  isNodeLike(node) {
+    if (!node) return false;
+    const next = node[this.nextName];
+    if (!next || typeof next != 'object') return false;
+    const prev = node[this.prevName];
+    return prev && typeof prev == 'object';
+  }
+
+  isCompatibleNames({nextName, prevName}) {
+    return this.nextName === nextName && this.prevName === prevName;
+  }
+
+  isCompatible(list) {
+    return list === this || (list instanceof HeadNode && this.nextName === list.nextName && this.prevName === list.prevName);
+  }
+
+  isCompatiblePtr(ptr) {
+    return (
+      ptr instanceof PtrBase &&
+      (ptr.list === this || (ptr.list instanceof HeadNode && this.nextName === ptr.list.nextName && this.prevName === ptr.list.prevName))
+    );
+  }
+
+  isCompatibleRange(range) {
+    return isRangeLike(this, range);
+  }
+
+  get isEmpty() {
+    return this[this.nextName] === this;
+  }
+
+  get isOne() {
+    return this[this.nextName] !== this && this[this.nextName][this.nextName] === this;
+  }
+
+  get isOneOrEmpty() {
+    return this[this.nextName][this.nextName] === this;
+  }
+
+  get head() {
+    return this;
+  }
+
+  get front() {
+    return this[this.nextName];
+  }
+
+  get back() {
+    return this[this.prevName];
+  }
+
+  get range() {
+    return this[this.nextName] === this ? null : {from: this[this.nextName], to: this[this.prevName], list: this};
+  }
+
+  getLength() {
+    let n = 0;
+    const nextName = this.nextName;
+    for (let p = this[nextName]; p !== this; ++n, p = p[nextName]);
+    return n;
+  }
+
+  adoptNode(nodeOrPtr) {
+    const node = nodeOrPtr instanceof PtrBase ? nodeOrPtr.node : nodeOrPtr;
+    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;
+    if (nodeOrPtr instanceof PtrBase) nodeOrPtr.list = this;
+    return node;
+  }
+
+  normalizeNode(nodeOrPtr) {
+    const node = normalizeNode(this, nodeOrPtr, PtrBase);
+    if (nodeOrPtr instanceof PtrBase) nodeOrPtr.list = this;
+    return node;
+  }
+
+  normalizeRange(range) {
+    return normalizeRange(this, range, PtrBase);
+  }
+}
+
+addAlias(HeadNode.prototype, 'adoptNode', 'adoptValue');
+
+export class ValueNode extends Node {
+  constructor(value, options) {
+    super(options);
+    this.value = value;
+  }
+}
+
+export class PtrBase {
+  constructor(list, node, ListClass) {
+    if (list instanceof PtrBase) {
+      this.list = list.list;
+      this.node = list.node;
+      return;
+    }
+    if (!(list instanceof ListClass)) throw new Error('"list" is not a compatible list');
+    if (node instanceof PtrBase) {
+      if (list !== node.list) throw new Error('Node specified by a pointer must belong to the same list');
+      this.list = list;
+      this.node = node.node;
+    } else {
+      this.list = list;
+      this.node = node;
+    }
+    if (this.node && !isNodeLike(this.list, this.node)) throw new Error('"node" is not a compatible node');
+    if (!this.node) this.node = this.list.front;
+  }
+
+  get nextNode() {
+    return this.node[this.list.nextName];
+  }
+
+  get prevNode() {
+    return this.node[this.list.prevName];
+  }
+
+  isPrevNodeValid() {
+    return true;
+  }
+
+  next() {
+    this.node = this.node[this.list.nextName];
+    return this;
+  }
+
+  prev() {
+    this.node = this.node[this.list.prevName];
+    return this;
+  }
+}
+
+export class ExtListBase {
+  constructor(head = null, {nextName = 'next', prevName = 'prev'} = {}) {
+    if (head instanceof ExtListBase) {
+      this.nextName = head.nextName;
+      this.prevName = head.prevName;
+      this.attach(head.head);
+      return;
+    }
+    if (head instanceof PtrBase) {
+      this.nextName = head.list.nextName;
+      this.prevName = head.list.prevName;
+      this.attach(head.node);
+      return;
+    }
+    this.nextName = nextName;
+    this.prevName = prevName;
+    this.attach(head);
+  }
+
+  isCompatible(list) {
+    return list === this || (list instanceof ExtListBase && this.nextName === list.nextName && this.prevName === list.prevName);
+  }
+
+  isCompatiblePtr(ptr) {
+    return (
+      ptr instanceof PtrBase &&
+      (ptr.list === this || (ptr.list instanceof ExtListBase && this.nextName === ptr.list.nextName && this.prevName === ptr.list.prevName))
+    );
+  }
+
+  get isEmpty() {
+    return !this.head;
+  }
+
+  get isOne() {
+    return this.head && this.head[this.nextName] === this.head;
+  }
+
+  get isOneOrEmpty() {
+    return !this.head || this.head[this.nextName] === this.head;
+  }
+
+  get front() {
+    return this.head;
+  }
+
+  get back() {
+    return this.head?.[this.prevName];
+  }
+
+  get range() {
+    return this.head ? {from: this.head, to: this.head[this.prevName], list: this.head} : null;
+  }
+
+  getLength() {
+    if (!this.head) return 0;
+
+    let n = 0,
+      current = this.head;
+    do {
+      current = current[this.nextName];
+      ++n;
+    } while (current !== this.head);
+
+    return n;
+  }
+
+  attach(head = null) {
+    const oldHead = this.head;
+    if (head instanceof PtrBase) {
+      if (!this.isCompatible(head.list)) throw new Error('Incompatible lists');
+      this.head = head.node;
+    } else {
+      if (head && !this.isNodeLike(head)) throw new Error('"head" is not a compatible node');
+      this.head = head;
+    }
+    return oldHead;
+  }
+
+  detach() {
+    const oldHead = this.head;
+    this.head = null;
+    return oldHead;
+  }
+
+  next() {
+    if (this.head) this.head = this.head[this.nextName];
+    return this;
+  }
+
+  prev() {
+    if (this.head) this.head = this.head[this.prevName];
+    return this;
+  }
+}
+
+copyDescriptors(ExtListBase.prototype, HeadNode.prototype, [
+  'isNodeLike',
+  'isCompatibleNames',
+  'isCompatibleRange',
+  'normalizeNode',
+  'normalizeRange',
+  'adoptNode',
+  'adoptValue'
+]);

package/src/list/ptr.js

@@ -0,0 +1,58 @@
+'use strict';
+
+import {HeadNode, PtrBase} from './nodes.js';
+import {pop, splice} from './basics.js';
+
+export class Ptr extends PtrBase {
+  constructor(list, node) {
+    super(list, node, HeadNode);
+  }
+  get isHead() {
+    return this.node === this.list;
+  }
+  clone() {
+    return new Ptr(this);
+  }
+  removeCurrent() {
+    if (this.node === this.list) return null;
+    const node = this.node;
+    this.node = node[this.list.nextName];
+    return pop(this.list, node).extracted;
+  }
+  addBefore(value) {
+    const node = this.list.adoptValue(value);
+    splice(this.list, this.node[this.list.prevName], node);
+    return this.list.makePtr(node);
+  }
+  addNodeBefore(node) {
+    node = this.list.adoptNode(node);
+    splice(this.list, this.node[this.list.prevName], node);
+    return this.list.makePtr(node);
+  }
+  addAfter(value) {
+    const node = this.list.adoptValue(value);
+    splice(this.list, this.node, node);
+    return this.list.makePtr(node);
+  }
+  addNodeAfter(node) {
+    node = this.list.adoptNode(node);
+    splice(this.list, this.node, node);
+    return this.list.makePtr(node);
+  }
+  insertBefore(list) {
+    if (!this.list.isCompatible(list)) throw new Error('Incompatible lists');
+    if (list.isEmpty) return null;
+    const head = pop(list, list).rest;
+    splice(this.list, this.node[this.list.prevName], head);
+    return this.list.makePtr(head);
+  }
+  insertAfter(list) {
+    if (!this.list.isCompatible(list)) throw new Error('Incompatible lists');
+    if (list.isEmpty) return null;
+    const head = pop(list, list).rest;
+    splice(this.list, this.node, head);
+    return this.list.makePtr(head);
+  }
+}
+
+export default Ptr;