list-toolkit 2.2.6 → 2.3.0

package/cjs/slist/ext.js

@@ -1,336 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.Ptr = exports.ExtSList = void 0;
-var _nodes = require("./nodes.js");
-var _basics = require("./basics.js");
-var _metaUtils = require("../meta-utils.js");
-class Ptr extends _nodes.PtrBase {
-  constructor(list, node, prev) {
-    super(list, node, prev, ExtSList);
-  }
-  clone() {
-    return new Ptr(this);
-  }
-}
-exports.Ptr = Ptr;
-class ExtSList extends _nodes.ExtListBase {
-  get ptrRange() {
-    return this.head ? {
-      from: this.makePtr(),
-      to: this.head,
-      list: this.head
-    } : null;
-  }
-  makePtr(node) {
-    if (node && !this.isNodeLike(node)) throw new Error('"node" is not a compatible node');
-    return new Ptr(this, node);
-  }
-  makePtrFromPrev(prev) {
-    if (prev && !this.isNodeLike(prev)) throw new Error('"prev" is not a compatible node');
-    return new Ptr(this, null, prev || this.head);
-  }
-
-  // Ptr API
-
-  removeNodeAfter() {
-    return this.head ? this.removeNode(this.makePtr()) : null;
-  }
-  addAfter(value) {
-    const node = this.adoptValue(value);
-    if (this.head) {
-      (0, _basics.splice)(this, this.head, {
-        prevFrom: node
-      });
-    } else {
-      this.head = node;
-    }
-    return this.makePtr();
-  }
-  addNodeAfter(node) {
-    node = this.adoptNode(node);
-    if (this.head) {
-      (0, _basics.splice)(this, this.head, {
-        prevFrom: node
-      });
-    } else {
-      this.head = node;
-    }
-    return this.makePtr();
-  }
-  insertAfter(extList) {
-    if (!this.isCompatible(extList)) throw new Error('Incompatible lists');
-    const head = extList.head;
-    if (head) {
-      (0, _basics.splice)(this, this.head, {
-        prevFrom: head,
-        to: head
-      });
-      extList.head = null;
-    }
-    return this.makePtr();
-  }
-  moveAfter(ptr) {
-    if (!this.isCompatiblePtr(ptr)) throw new Error('Incompatible pointer');
-    ptr.list = this;
-    if (!this.head) {
-      this.head = (0, _basics.pop)(this, ptr.prevNode).extracted.to;
-      return this;
-    }
-    if (this.head === ptr.prevNode) return this;
-    if (this.head === ptr.prevNode[this.nextName]) {
-      if (this.head === this.head[this.nextName]) return this;
-      this.head = this.head[this.nextName];
-    }
-    ptr.prevNode = (0, _basics.splice)(this, this.head, {
-      prevFrom: (0, _basics.pop)(this, ptr.prevNode).extracted.to
-    });
-    return ptr.clone();
-  }
-
-  // List API
-
-  clear(drop) {
-    if (drop) {
-      for (const current of this.getNodeIterator()) {
-        current[this.nextName] = current; // make stand-alone
-      }
-    }
-    this.head = null;
-    return this;
-  }
-  removeNode(ptr) {
-    if (!this.head) return null;
-    if (!this.isCompatiblePtr(ptr)) throw new Error('Incompatible pointer');
-    if (this.head === ptr.prevNode[this.nextName]) {
-      if (this.head === this.head[this.nextName]) {
-        this.head = null;
-        return ptr.prevNode[this.nextName];
-      }
-      this.head = this.head[this.nextName];
-    }
-    return (0, _basics.pop)(this, ptr.prevNode).extracted.to;
-  }
-  removeRange(ptrRange, drop) {
-    return this.extractRange(ptrRange).clear(drop);
-  }
-  extractRange(ptrRange = {}) {
-    ptrRange = this.normalizePtrRange(ptrRange.from ? ptrRange : {
-      ...ptrRange,
-      from: this.makePtr()
-    });
-    ptrRange.to ||= this.head;
-    const prevFrom = ptrRange.from.prevNode,
-      to = ptrRange.to,
-      extracted = this.make();
-    if (!this.head) return extracted;
-    if (this.head === prevFrom[this.nextName] || this.head === to) this.head = to[this.nextName];
-    if (this.head === prevFrom[this.nextName]) this.head = null;
-    extracted.head = (0, _basics.extract)(this, {
-      prevFrom,
-      to
-    }).extracted.prevFrom[this.nextName];
-    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; // make stand-alone
-      if (condition(current)) {
-        extracted.addAfter(current);
-        extracted.next();
-      } else {
-        rest.addAfter(current);
-        rest.next();
-      }
-    }
-    extracted.next();
-    rest.next();
-    this.head = rest.head;
-    return extracted;
-  }
-  reverse() {
-    if (this.isOneOrEmpty) return this;
-    let prev = this.head,
-      current = prev[this.nextName];
-    do {
-      const next = current[this.nextName];
-      current[this.nextName] = prev;
-      prev = current;
-      current = next;
-    } while (current !== this.head);
-    this.head[this.nextName] = prev;
-    this.head = this.head[this.nextName];
-    return this;
-  }
-  sort(lessFn) {
-    if (this.isOneOrEmpty) return this;
-    const leftHead = {},
-      rightHead = {};
-    leftHead[this.nextName] = leftHead;
-    rightHead[this.nextName] = rightHead;
-    const left = this.make(leftHead),
-      right = this.make(rightHead);
-
-    // split into two sublists
-    let isLeft = true;
-    for (const current of this.getNodeIterator()) {
-      current[this.nextName] = current; // make stand-alone
-      if (isLeft) {
-        left.addNodeAfter(current);
-        left.next();
-      } else {
-        right.addNodeAfter(current);
-        right.next();
-      }
-      isLeft = !isLeft;
-    }
-    left.removeNodeAfter(); // remove the head node
-    right.removeNodeAfter(); // remove the head node
-    this.clear();
-    // the list is empty now
-
-    // sort sublists
-    left.next().sort(lessFn);
-    right.next().sort(lessFn);
-
-    // merge sublists
-    const leftIterator = left.getNodeIterator()[Symbol.iterator](),
-      rightIterator = right.getNodeIterator()[Symbol.iterator]();
-    let leftItem = leftIterator.next(),
-      rightItem = rightIterator.next();
-    while (!leftItem.done && !rightItem.done) {
-      let node;
-      if (lessFn(leftItem.value, rightItem.value)) {
-        node = leftItem.value;
-        leftItem = leftIterator.next();
-      } else {
-        node = rightItem.value;
-        rightItem = rightIterator.next();
-      }
-      node[this.nextName] = node; // make stand-alone
-      this.addNodeAfter(node);
-      this.next();
-    }
-    for (; !leftItem.done; this.next(), leftItem = leftIterator.next()) {
-      const node = leftItem.value;
-      node[this.nextName] = node; // make stand-alone
-      this.addNodeAfter(node);
-    }
-    for (; !rightItem.done; this.next(), rightItem = rightIterator.next()) {
-      const node = rightItem.value;
-      node[this.nextName] = node; // make stand-alone
-      this.addNodeAfter(node);
-    }
-    return this.next();
-  }
-
-  // iterators
-
-  [Symbol.iterator]() {
-    let current = this.head,
-      readyToStop = this.isEmpty;
-    return (0, _metaUtils.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 (0, _metaUtils.normalizeIterator)({
-          next: () => {
-            if (readyToStop && current === stop) return {
-              done: true
-            };
-            readyToStop = true;
-            const value = current;
-            current = current[this.nextName];
-            return {
-              value
-            };
-          }
-        });
-      }
-    };
-  }
-  getPtrIterator(range) {
-    if (!ptrRange.from) ptrRange = Object.assign({
-      from: this.frontPtr
-    }, ptrRange);
-    ptrRange = this.normalizePtrRange(ptrRange);
-    const {
-      from: fromPtr,
-      to
-    } = ptrRange;
-    return {
-      [Symbol.iterator]: () => {
-        let current = fromPtr.clone(),
-          readyToStop = this.isEmpty;
-        const stop = to ? to[this.nextName] : this;
-        return (0, _metaUtils.normalizeIterator)({
-          next: () => {
-            if (readyToStop && current.node === stop) return {
-              done: true
-            };
-            readyToStop = true;
-            const value = current.clone();
-            current = current.next();
-            return {
-              value
-            };
-          }
-        });
-      }
-    };
-  }
-
-  // meta helpers
-
-  clone() {
-    return new ExtSList(this);
-  }
-  make(head = null) {
-    return new ExtSList(head, this);
-  }
-  makeFrom(values) {
-    return ExtSList.from(values, this);
-  }
-  static from(values, options) {
-    const list = new ExtSList(null, options);
-    for (const value of values) {
-      list.addNodeAfter(value);
-      list.next();
-    }
-    return list.next();
-  }
-}
-exports.ExtSList = ExtSList;
-ExtSList.Ptr = Ptr;
-(0, _metaUtils.addAliases)(ExtSList.prototype, {
-  addAfter: 'add',
-  removeNodeAfter: 'removeAfter',
-  getNodeIterator: 'getIterator'
-});
-var _default = exports.default = ExtSList;

package/cjs/slist/nodes.js

@@ -1,276 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isStandAlone = exports.isNodeLike = exports.isCompatible = exports.ValueNode = exports.PtrBase = exports.Node = exports.HeadNode = exports.ExtListBase = void 0;
-var _listHelpers = require("../list-helpers.js");
-var _metaUtils = require("../meta-utils.js");
-const isNodeLike = ({
-  nextName
-}, node) => node && node[nextName];
-exports.isNodeLike = isNodeLike;
-const isStandAlone = ({
-  nextName
-}, node) => node && node[nextName] === node;
-exports.isStandAlone = isStandAlone;
-const isCompatible = (options1, options2) => options1.nextName === options2.nextName;
-exports.isCompatible = isCompatible;
-class Node {
-  constructor({
-    nextName = 'next'
-  } = {}) {
-    this.nextName = nextName;
-    this[nextName] = this;
-  }
-  get isStandAlone() {
-    return this[this.nextName] === this;
-  }
-}
-exports.Node = Node;
-class HeadNode extends Node {
-  constructor(options) {
-    super(options);
-    this.last = this;
-  }
-  isNodeLike(node) {
-    if (!node) return false;
-    const next = node[this.nextName];
-    return next && _metaUtils.canHaveProps[typeof next] === 1;
-  }
-  isCompatibleNames({
-    nextName
-  }) {
-    return this.nextName === nextName;
-  }
-  isCompatible(list) {
-    return list === this || list instanceof HeadNode && this.nextName === list.nextName;
-  }
-  isCompatiblePtr(ptr) {
-    return ptr instanceof PtrBase && (ptr.list === this || ptr.list instanceof HeadNode && this.nextName === ptr.list.nextName);
-  }
-  isCompatibleRange(range) {
-    return (0, _listHelpers.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.last;
-  }
-  get range() {
-    return this[this.nextName] === this ? null : {
-      from: this[this.nextName],
-      to: this.last,
-      list: this
-    };
-  }
-  getLength() {
-    let n = 0;
-    for (let p = this[this.nextName]; p !== this; ++n, p = p[this.nextName]);
-    return n;
-  }
-  adoptNode(nodeOrPtr) {
-    const isPtr = nodeOrPtr instanceof PtrBase;
-    if (isPtr && !this.isCompatiblePtr(nodeOrPtr)) throw new Error('Incompatible pointer');
-    const node = isPtr ? nodeOrPtr.node : nodeOrPtr;
-    if (node[this.nextName]) {
-      if (node[this.nextName] === node) return node;
-      throw new Error('node is already a part of a list, or there is a name clash');
-    }
-    node[this.nextName] = node;
-    if (isPtr) {
-      nodeOrPtr.list = this;
-      nodeOrPtr.prevNode = node;
-    }
-    return node;
-  }
-  normalizeNode(nodeOrPtr) {
-    const node = (0, _listHelpers.normalizeNode)(this, nodeOrPtr, PtrBase);
-    if (nodeOrPtr instanceof PtrBase) nodeOrPtr.list = this;
-    return node;
-  }
-  normalizeRange(range) {
-    return (0, _listHelpers.normalizeRange)(this, range, PtrBase);
-  }
-  normalizePtrRange(range) {
-    return (0, _listHelpers.normalizePtrRange)(this, range, PtrBase);
-  }
-  syncLast() {
-    this.last = this;
-    while (this.last[this.nextName] !== this) this.last = this.last[this.nextName];
-    return this;
-  }
-}
-exports.HeadNode = HeadNode;
-(0, _metaUtils.addAlias)(HeadNode.prototype, 'adoptNode', 'adoptValue');
-class ValueNode extends Node {
-  constructor(value, options) {
-    super(options);
-    this.value = value;
-  }
-}
-exports.ValueNode = ValueNode;
-class PtrBase {
-  constructor(list, node, prev, ListClass) {
-    if (list instanceof PtrBase) {
-      this.list = list.list;
-      this.node = list.node;
-      this.prevNode = list.prevNode;
-      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;
-      this.prevNode = node.prevNode;
-    } else {
-      this.list = list;
-      this.node = node;
-      this.prevNode = prev;
-    }
-    // check nodes
-    if (this.node && !isNodeLike(this.list, this.node)) throw new Error('"node" is not a compatible node');
-    if (this.prevNode && !isNodeLike(this.list, this.prevNode)) throw new Error('"prev" is not a compatible node');
-    // initialize missing nodes
-    if (this.node) {
-      if (!this.prevNode) this.prevNode = this.node;
-    } else {
-      if (!this.prevNode) this.prevNode = this.list.head;
-      if (this.prevNode) this.node = this.prevNode[this.list.nextName];
-    }
-  }
-  get nextNode() {
-    return this.node[this.list.nextName];
-  }
-  isPrevNodeValid() {
-    if (!this.prevNode) this.prevNode = this.node;
-    if (this.prevNode[this.list.nextName] === this.node) return true;
-    this.prevNode = this.node;
-    if (this.prevNode[this.list.nextName] === this.node) return true;
-    this.prevNode = this.prevNode[this.list.nextName];
-    if (this.prevNode[this.list.nextName] === this.node) return true;
-    this.prevNode = this.list.head;
-    if (this.prevNode[this.list.nextName] === this.node) return true;
-    this.prevNode = this.node;
-    return false;
-  }
-  next() {
-    this.prevNode = this.node;
-    this.node = this.node[this.list.nextName];
-    return this;
-  }
-  prev() {
-    if (!this.isPrevNodeValid()) throw new Error('Cannot get previous node: "prevNode" is invalid');
-    this.node = this.prevNode;
-    return this;
-  }
-  syncPrev() {
-    if (this.isPrevNodeValid()) return this;
-    this.prevNode = this.node;
-    do {
-      const next = this.prevNode[this.list.nextName];
-      if (next === this.node) break;
-      this.prevNode = next;
-    } while (this.prevNode !== this.node);
-    return this;
-  }
-}
-exports.PtrBase = PtrBase;
-class ExtListBase {
-  constructor(head = null, {
-    nextName = 'next'
-  } = {}) {
-    if (head instanceof ExtListBase) {
-      this.nextName = head.nextName;
-      this.attach(head.head);
-      return;
-    }
-    if (head instanceof PtrBase) {
-      this.nextName = head.list.nextName;
-      this.attach(head.node);
-      return;
-    }
-    this.nextName = nextName;
-    this.attach(head);
-  }
-  isCompatible(list) {
-    return list === this || list instanceof ExtListBase && this.nextName === list.nextName;
-  }
-  isCompatiblePtr(ptr) {
-    return ptr instanceof PtrBase && (ptr.list === this || ptr.list instanceof ExtListBase && this.nextName === ptr.list.nextName);
-  }
-  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 range() {
-    return this.head ? {
-      from: this.head[this.nextName],
-      to: this.head,
-      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;
-  }
-  getBack() {
-    if (!this.head) return null;
-    for (let current = this.head;;) {
-      const next = current[this.nextName];
-      if (next === this.head) return current;
-      current = next;
-    }
-    // unreachable
-  }
-  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;
-  }
-}
-exports.ExtListBase = ExtListBase;
-(0, _metaUtils.copyDescriptors)(ExtListBase.prototype, HeadNode.prototype, ['isNodeLike', 'isCompatibleNames', 'isCompatibleRange', 'normalizeNode', 'normalizeRange', 'normalizePtrRange', 'adoptNode', 'adoptValue']);

package/cjs/slist/ptr.js

@@ -1,87 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.Ptr = void 0;
-var _nodes = require("./nodes.js");
-var _basics = require("./basics.js");
-class Ptr extends _nodes.PtrBase {
-  constructor(list, node, prev) {
-    super(list, node, prev, _nodes.HeadNode);
-  }
-  get isHead() {
-    return this.node === this.list;
-  }
-  clone() {
-    return new Ptr(this);
-  }
-  removeCurrent() {
-    if (!this.isPrevNodeValid()) throw new Error('Current node cannot be removed: "prevNode" is invalid');
-    if (this.node === this.list || this.node === this.prevNode) return null;
-    if (this.list.last === this.node) this.list.last = this.prevNode;
-    const node = (0, _basics.pop)(this.list, this.prevNode).extracted.to;
-    this.node = this.prevNode[this.list.nextName];
-    return node;
-  }
-  addBefore(value) {
-    if (!this.isPrevNodeValid()) throw new Error('Cannot be added before: "prevNode" is invalid');
-    const node = this.list.adoptValue(value),
-      prev = (0, _basics.splice)(this.list, this.prevNode, {
-        prevFrom: node
-      });
-    this.prevNode = node;
-    if (this.list.last === this.list) this.list.last = node;
-    return this.list.makePtr(prev);
-  }
-  addNodeBefore(node) {
-    if (!this.isPrevNodeValid()) throw new Error('Cannot be added before: "prevNode" is invalid');
-    node = this.list.adoptNode(node);
-    const prev = (0, _basics.splice)(this.list, this.prevNode, {
-      prevFrom: node
-    });
-    this.prevNode = node;
-    if (this.list.last === this.list) this.list.last = node;
-    return this.list.makePtr(prev);
-  }
-  addAfter(value) {
-    const node = this.list.adoptValue(value),
-      prev = (0, _basics.splice)(this.list, this.node, {
-        prevFrom: node
-      });
-    return this.list.makePtr(prev);
-  }
-  addNodeAfter(node) {
-    node = this.list.adoptNode(node);
-    const prev = (0, _basics.splice)(this.list, this.node, {
-      prevFrom: node
-    });
-    return this.list.makePtr(prev);
-  }
-  insertBefore(list) {
-    if (!this.isPrevNodeValid()) throw new Error('Cannot be inserted before: "prevNode" is invalid');
-    if (!this.list.isCompatible(list)) throw new Error('Incompatible lists');
-    if (list.isEmpty) return this;
-    const prev = (0, _basics.splice)(this.list, this.prevNode, {
-      prevFrom: list,
-      to: list.last
-    });
-    if (this.list.last === this.list) this.list.last = list.last;
-    this.prevNode = list.last;
-    list.last = list;
-    return this.list.makePtr(prev);
-  }
-  insertAfter(list) {
-    if (!this.list.isCompatible(list)) throw new Error('Incompatible lists');
-    if (list.isEmpty) return this;
-    const prev = (0, _basics.splice)(this.list, this.prevNode[this.list.nextName], {
-      prevFrom: list,
-      to: list.last
-    });
-    if (this.list.last === this.prevNode) this.list.last = list.last;
-    list.last = list;
-    return this.list.makePtr(prev);
-  }
-}
-exports.Ptr = Ptr;
-var _default = exports.default = Ptr;