list-toolkit 1.0.2 → 2.0.0

package/src/slist/value.js

@@ -0,0 +1,75 @@
+'use strict';
+
+import List, {Ptr} from './core.js';
+import {ValueNode} from './nodes.js';
+import {addAliases, mapIterator, normalizeIterator} from '../meta-utils.js';
+
+export class ValueSList extends List {
+  popFront() {
+    return this.popFrontNode()?.value;
+  }
+
+  adoptValue(value) {
+    if (value instanceof Ptr) {
+      if (!this.isCompatiblePtr(value)) throw new Error('Incompatible pointer');
+      if (value.node instanceof ValueNode) {
+        value.list = this;
+        return super.adoptNode(value);
+      }
+      return new ValueNode(value.node, this);
+    }
+    if (value instanceof ValueNode) {
+      if (!this.isNodeLike(value)) throw new Error('Incompatible node');
+      return super.adoptNode(value);
+    }
+    return new ValueNode(value, this);
+  }
+
+  // iterators
+
+  [Symbol.iterator]() {
+    let current = this[this.nextName],
+      readyToStop = this.isEmpty;
+    return normalizeIterator({
+      next: () => {
+        if (readyToStop && current === this) return {done: true};
+        readyToStop = true;
+        const value = current.value;
+        current = current[this.nextName];
+        return {value};
+      }
+    });
+  }
+
+  getValueIterator(range) {
+    return mapIterator(this.getNodeIterator(range), node => node.value);
+  }
+
+  // meta helpers
+
+  clone() {
+    return ValueSList.from(this, this);
+  }
+
+  make() {
+    return new ValueSList(this);
+  }
+
+  makeFrom(values) {
+    return ValueSList.from(values, this);
+  }
+
+  static from(values, options) {
+    const list = new ValueSList(options);
+    for (const value of values) list.pushBack(value);
+    return list;
+  }
+}
+
+ValueSList.Ptr = Ptr;
+ValueSList.ValueNode = ValueNode;
+
+addAliases(ValueSList.prototype, {popFront: 'pop', getValueIterator: 'getIterator'}, true);
+
+export {ValueNode, Ptr};
+export default ValueSList;

package/src/slist.js

@@ -0,0 +1,6 @@
+'use strict';
+
+export * from './slist/core.js';
+import SList from './slist/core.js';
+
+export default SList;

package/src/stack.js

@@ -0,0 +1,52 @@
+'use strict';
+
+import ValueList from './value-list.js';
+import {addAlias} from './meta-utils.js';
+import {pushValuesFront} from './list-utils.js';
+
+export class Stack {
+  constructor(UnderlyingList = ValueList) {
+    this.size = 0;
+    this.list = new UnderlyingList();
+  }
+  get isEmpty() {
+    return this.list.isEmpty;
+  }
+  get top() {
+    return this.list.isEmpty ? undefined : this.list.front.value;
+  }
+  peek() {
+    return this.list.isEmpty ? undefined : this.list.front.value;
+  }
+  push(value) {
+    this.list.pushFront(value);
+    ++this.size;
+    return this;
+  }
+  pop() {
+    if (!this.list.isEmpty) {
+      --this.size;
+      return this.list.popFront().value;
+    }
+    // return undefined;
+  }
+  pushValues(values) {
+    pushValuesFront(this, values);
+    return this;
+  }
+  clear() {
+    this.list.clear();
+    this.size = 0;
+    return this;
+  }
+  [Symbol.iterator]() {
+    return this.list[Symbol.iterator]();
+  }
+  getReverseIterator() {
+    return this.list.getReverseIterator?.();
+  }
+}
+
+addAlias(Stack.prototype, 'push', 'pushFront');
+
+export default Stack;

package/src/value-list.js

@@ -0,0 +1,6 @@
+'use strict';
+
+export * from './list/value.js';
+import ValueList from './list/value.js';
+
+export default ValueList;

package/src/value-slist.js

@@ -0,0 +1,6 @@
+'use strict';
+
+export * from './slist/value.js';
+import ValueSList from './slist/value.js';
+
+export default ValueSList;

package/cjs/Cache.js

@@ -1,71 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.Cache = void 0;
-var _List = _interopRequireDefault(require("./List.js"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-class Cache {
-  constructor(capacity = 10) {
-    this.capacity = capacity;
-    this.size = 0;
-    this.list = new _List.default();
-    this.dict = {};
-  }
-  find(key) {
-    const node = this.dict[key];
-    if (typeof node == 'object') {
-      return node.value.value;
-    }
-  }
-  remove(key) {
-    const node = this.dict[key];
-    if (typeof node == 'object') {
-      delete this.dict[key];
-      node.pop();
-      --this.size;
-    }
-    return this;
-  }
-  register(key, value) {
-    const node = this.dict[key];
-    if (typeof node == 'object') {
-      this.list.moveToFront(node);
-      node.value.value = value;
-      return this;
-    }
-    if (this.size >= this.capacity) {
-      const node = this.list.back;
-      this.list.moveToFront(node);
-      delete this.dict[node.value.key];
-      this.dict[key] = node;
-      node.value = {
-        key,
-        value
-      };
-      return this;
-    }
-    this.list.pushFront({
-      key,
-      value
-    });
-    ++this.size;
-    this.dict[key] = this.list.front;
-    return this;
-  }
-  clear() {
-    this.dict = {};
-    this.list.clear();
-    this.size = 0;
-    return this;
-  }
-  [Symbol.iterator]() {
-    return this.list[Symbol.iterator]();
-  }
-  getReverseIterable() {
-    return this.list.getReverseIterable();
-  }
-}
-exports.Cache = Cache;
-var _default = exports.default = Cache;

package/cjs/List.js

@@ -1,294 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.ListValueNode = exports.ListNode = exports.List = void 0;
-class ListNode {
-  constructor() {
-    this.prev = this.next = this;
-  }
-}
-exports.ListNode = ListNode;
-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;
-  }
-}
-exports.ListValueNode = ListValueNode;
-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;
-  }
-}
-exports.List = 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;