list-toolkit 2.2.5 → 2.3.0

package/cjs/list/ext.js

@@ -1,356 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.Ptr = exports.ExtList = 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) {
-    super(list, node, ExtList);
-    this.node ||= this.list.head;
-  }
-  clone() {
-    return new Ptr(this);
-  }
-}
-exports.Ptr = Ptr;
-class ExtList extends _nodes.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 = (0, _basics.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) {
-      (0, _basics.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) {
-      (0, _basics.splice)(this, this.head, node);
-    } else {
-      this.head = node;
-    }
-    return this.makePtr(node);
-  }
-  addNodeBefore(nodeOrPtr) {
-    const node = this.adoptNode(nodeOrPtr);
-    if (this.head) {
-      (0, _basics.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) {
-      (0, _basics.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) {
-      (0, _basics.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) {
-      (0, _basics.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) {
-      (0, _basics.append)(this, this.head[this.prevName], {
-        from: node
-      });
-    } else {
-      (0, _basics.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) {
-      (0, _basics.append)(this, this.head, {
-        from: node
-      });
-    } else {
-      (0, _basics.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 (0, _basics.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 = (0, _basics.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 (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) {
-    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 (0, _metaUtils.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();
-  }
-}
-exports.ExtList = ExtList;
-ExtList.Ptr = Ptr;
-(0, _metaUtils.addAliases)(ExtList.prototype, {
-  addAfter: 'add',
-  removeNodeBefore: 'removeBefore',
-  removeNodeAfter: 'removeAfter',
-  getNodeIterator: 'getIterator',
-  getReverseNodeIterator: 'getReverseIterator'
-});
-var _default = exports.default = ExtList;

package/cjs/list/nodes.js

@@ -1,240 +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,
-  prevName
-}, node) => node && node[prevName] && node[nextName];
-exports.isNodeLike = isNodeLike;
-const isStandAlone = ({
-  nextName,
-  prevName
-}, node) => node && node[prevName] === node && node[nextName] === node;
-exports.isStandAlone = isStandAlone;
-const isCompatible = (options1, options2) => options1.nextName === options2.nextName && options1.prevName === options2.prevName;
-exports.isCompatible = isCompatible;
-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;
-  }
-}
-exports.Node = Node;
-class HeadNode extends Node {
-  isNodeLike(node) {
-    if (!node) return false;
-    const next = node[this.nextName];
-    if (!next || _metaUtils.canHaveProps[typeof next] !== 1) return false;
-    const prev = node[this.prevName];
-    return prev && _metaUtils.canHaveProps[typeof prev] === 1;
-  }
-  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 (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[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 = (0, _listHelpers.normalizeNode)(this, nodeOrPtr, PtrBase);
-    if (nodeOrPtr instanceof PtrBase) nodeOrPtr.list = this;
-    return node;
-  }
-  normalizeRange(range) {
-    return (0, _listHelpers.normalizeRange)(this, range, PtrBase);
-  }
-}
-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, 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;
-  }
-}
-exports.PtrBase = PtrBase;
-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;
-  }
-}
-exports.ExtListBase = ExtListBase;
-(0, _metaUtils.copyDescriptors)(ExtListBase.prototype, HeadNode.prototype, ['isNodeLike', 'isCompatibleNames', 'isCompatibleRange', 'normalizeNode', 'normalizeRange', 'adoptNode', 'adoptValue']);

package/cjs/list/ptr.js

@@ -1,61 +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) {
-    super(list, node, _nodes.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 (0, _basics.pop)(this.list, node).extracted;
-  }
-  addBefore(value) {
-    const node = this.list.adoptValue(value);
-    (0, _basics.splice)(this.list, this.node[this.list.prevName], node);
-    return this.list.makePtr(node);
-  }
-  addNodeBefore(node) {
-    node = this.list.adoptNode(node);
-    (0, _basics.splice)(this.list, this.node[this.list.prevName], node);
-    return this.list.makePtr(node);
-  }
-  addAfter(value) {
-    const node = this.list.adoptValue(value);
-    (0, _basics.splice)(this.list, this.node, node);
-    return this.list.makePtr(node);
-  }
-  addNodeAfter(node) {
-    node = this.list.adoptNode(node);
-    (0, _basics.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 = (0, _basics.pop)(list, list).rest;
-    (0, _basics.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 = (0, _basics.pop)(list, list).rest;
-    (0, _basics.splice)(this.list, this.node, head);
-    return this.list.makePtr(head);
-  }
-}
-exports.Ptr = Ptr;
-var _default = exports.default = Ptr;