list-toolkit 1.0.1

package/cjs/SListHead.js

@@ -0,0 +1,363 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils.js");
+class SListHead {
+  constructor(head = null, options) {
+    if (head instanceof SListHead) {
+      ({
+        nextName: this.nextName,
+        head: this.head
+      } = head);
+      return;
+    }
+    (0, _utils.copyOptions)(this, SListHead.defaults, options);
+    if (head instanceof SListHead.Unsafe) {
+      this.head = head.head;
+      return;
+    }
+    if (head) {
+      if (!head[this.nextName]) {
+        this.adopt(head);
+      }
+    } else {
+      head = this.makeNode();
+    }
+    this.head = head;
+  }
+  get isEmpty() {
+    return this.head[this.nextName] === this.head;
+  }
+  get front() {
+    return this.head[this.nextName];
+  }
+  getBack() {
+    return SListHead.getPrev(this, this.head);
+  }
+  getLength() {
+    let n = 0;
+    for (let p = this.head[this.nextName]; p !== this.head; ++n, p = p[this.nextName]);
+    return n;
+  }
+  getPtr() {
+    return new SListHead.SListPtr(this);
+  }
+  popFront() {
+    if (this.head[this.nextName] !== this.head) {
+      return SListHead.pop(this, this.head).node;
+    }
+  }
+  popBack() {
+    if (this.head[this.nextName] !== this.head) {
+      const prevLast = SListHead.getPrevPrev(this, this.head);
+      return SListHead.pop(this, prevLast).node;
+    }
+  }
+  pushFront(node) {
+    this.adopt(node);
+    SListHead.splice(this, this.head, {
+      prev: node,
+      node
+    });
+    return this;
+  }
+  pushBack(node) {
+    this.adopt(node);
+    const last = SListHead.getPrev(this, this.head);
+    SListHead.splice(this, last, {
+      prev: node,
+      node
+    });
+    return this;
+  }
+  appendFront(list) {
+    let prevFrom, nodeTo;
+    if (list instanceof SListHead) {
+      if (list.head[this.nextName] === list.head) return this;
+      prevFrom = list.head;
+      nodeTo = SListHead.getPrev(this, list.head);
+    } else {
+      if (list[this.nextName] === list) return this;
+      prevFrom = nodeTo = SListHead.getPrev(this, list);
+    }
+    SListHead.splice(this, this.head, SListHead.extract(this, prevFrom, nodeTo));
+    return this;
+  }
+  appendBack(list) {
+    let prevFrom, nodeTo;
+    if (list instanceof SListHead) {
+      if (list.head[this.nextName] === list.head) return this;
+      prevFrom = list.head;
+      nodeTo = SListHead.getPrev(this, list.head);
+    } else {
+      if (list[this.nextName] === list) return this;
+      prevFrom = nodeTo = SListHead.getPrev(this, list);
+    }
+    const last = SListHead.getPrev(this, this.head);
+    SListHead.splice(this, last, SListHead.extract(this, prevFrom, nodeTo));
+    return this;
+  }
+  moveToFront(node) {
+    let prev;
+    if (node instanceof SListHead.SListPtr) {
+      prev = node.prev;
+      node = node.node;
+      if (this.head[this.nextName] === node) return this;
+    } else {
+      if (this.head[this.nextName] === node) return this;
+      prev = SListHead.getPrev(this, this.head, node);
+    }
+    SListHead.splice(this, this.head, SListHead.extract(this, prev, node));
+    return this;
+  }
+  moveToBack(node) {
+    let prev;
+    if (node instanceof SListHead.SListPtr) {
+      prev = node.prev;
+      node = node.node;
+    } else {
+      prev = SListHead.getPrev(this, this.head, node);
+    }
+    const last = SListHead.getPrev(this, this.head);
+    SListHead.splice(this, last, SListHead.extract(this, prev, node));
+    return this;
+  }
+  clear(drop) {
+    if (drop) {
+      while (!this.isEmpty) this.popFront();
+    } else {
+      this.head[this.nextName] = this.head;
+    }
+    return this;
+  }
+  remove(from, to = from) {
+    const prevFrom = from instanceof SListHead.SListPtr ? from.prev : SListHead.getPrev(this, this.head, from),
+      nodeTo = to instanceof SListHead.SListPtr ? to.node : to;
+    SListHead.extract(this, prevFrom, nodeTo);
+    return this;
+  }
+  extract(from, to) {
+    const prevFrom = from instanceof SListHead.SListPtr ? from.prev : SListHead.getPrev(this, this.head, from),
+      nodeTo = to instanceof SListHead.SListPtr ? to.node : to;
+    return this.make(SListHead.splice(this, this.makeNode(), SListHead.extract(this, prevFrom, nodeTo)));
+  }
+  reverse() {
+    let prev = this.head,
+      current = prev[this.nextName];
+    while (current !== this.head) {
+      const next = current[this.nextName];
+      current[this.nextName] = prev;
+      prev = current;
+      current = next;
+    }
+    this.head[this.nextName] = prev;
+    return this;
+  }
+  sort(compareFn) {
+    let prev = this.head;
+    for (const node of Array.from(this).sort(compareFn)) {
+      prev = prev[this.nextName] = node;
+    }
+    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 instanceof SListHead.SListPtr && from.node || from || this.head[this.nextName];
+        const stop = to ? (to instanceof SListHead.SListPtr && to.node || to)[this.nextName] : this.head;
+        return {
+          next: () => {
+            if (current === stop) return {
+              done: true
+            };
+            const value = current;
+            current = current[this.nextName];
+            return {
+              value
+            };
+          }
+        };
+      }
+    };
+  }
+  getPtrIterable(from, to) {
+    return {
+      [Symbol.iterator]: () => {
+        let current = from instanceof SListHead.SListPtr ? from.clone() : from ? new SListHead.SListPtr(this, SListHead.getPrev(this, this.head, from)) : this.getPtr();
+        const stop = to ? (to instanceof SListHead.SListPtr && to.node || to)[this.nextName] : this.head;
+        return {
+          next: () => {
+            if (current.node === stop) return {
+              done: true
+            };
+            const value = current.clone();
+            current.next();
+            return {
+              value
+            };
+          }
+        };
+      }
+    };
+  }
+
+  // static utilities
+
+  static pop({
+    nextName
+  }, prev) {
+    const node = prev[nextName];
+    prev[nextName] = node[nextName];
+    node[nextName] = node;
+    return {
+      node,
+      list: prev
+    };
+  }
+  static extract({
+    nextName
+  }, prevFrom, nodeTo) {
+    const node = prevFrom[nextName];
+    if (prevFrom === nodeTo) return {
+      prev: prevFrom,
+      node
+    };
+    prevFrom[nextName] = nodeTo[nextName];
+    nodeTo[nextName] = node;
+    return {
+      prev: nodeTo,
+      node
+    };
+  }
+  static splice({
+    nextName
+  }, prev1, {
+    prev,
+    node
+  }) {
+    prev[nextName] = prev1[nextName];
+    prev1[nextName] = node;
+    return prev1;
+  }
+  static getPrevPrev({
+    nextName
+  }, list, node) {
+    let prev = list,
+      current = prev[nextName];
+    while (current[nextName] !== list) {
+      if (node && current[nextName] === node) return prev;
+      prev = current;
+      current = prev[nextName];
+    }
+    if (node) {
+      if (list[nextName] === node) return current;
+      throw new Error('node does not belong to the list');
+    }
+    return prev;
+  }
+  static getPrev(names, list, node) {
+    return SListHead.getPrevPrev(names, list, node)[names.nextName];
+  }
+
+  // node helpers
+
+  makeNode() {
+    const node = {};
+    node[this.nextName] = node;
+    return node;
+  }
+  adopt(node) {
+    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;
+    return node;
+  }
+
+  // helpers
+
+  clone() {
+    return new SListHead(this);
+  }
+  make(newHead = null) {
+    return new SListHead(newHead, this);
+  }
+  makeFrom(values) {
+    return SListHead.from(values, this);
+  }
+  pushValuesFront(values) {
+    for (const value of values) {
+      this.pushFront(value);
+    }
+    return this;
+  }
+  appendValuesFront(values) {
+    return this.appendFront(SListHead.from(values, this));
+  }
+  static from(values, options) {
+    const list = new SListHead(null, options),
+      nextName = list.nextName;
+    let prev = list.head;
+    for (const value of values) {
+      list.adopt(value);
+      prev[nextName] = value;
+      prev = value;
+    }
+    prev[nextName] = list.head;
+    return list;
+  }
+}
+SListHead.defaults = {
+  nextName: 'next'
+};
+SListHead.prototype.pop = SListHead.prototype.popFront;
+SListHead.prototype.push = SListHead.prototype.pushFront;
+SListHead.prototype.append = SListHead.prototype.appendBack;
+SListHead.Unsafe = class Unsafe {
+  constructor(head) {
+    this.head = head;
+  }
+};
+SListHead.SListPtr = class SListPtr {
+  constructor(list, prev) {
+    this.list = list;
+    this.prev = prev || list.head;
+  }
+  get node() {
+    return this.prev[this.list.nextName];
+  }
+  get isHead() {
+    return this.prev[this.list.nextName] === this.list.head;
+  }
+  next() {
+    this.prev = this.prev[this.list.nextName];
+    return this;
+  }
+  clone() {
+    return new SListHead.SListPtr(this.list, this.prev);
+  }
+};
+var _default = exports.default = SListHead;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/utils.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lessFromCompare = exports.greaterFromLess = exports.equalFromLess = exports.copyOptions = exports.compareFromLess = exports.binarySearch = void 0;
+const compareFromLess = lessFn => (a, b) => lessFn(a, b) ? -1 : lessFn(b, a) ? 1 : 0;
+exports.compareFromLess = compareFromLess;
+const lessFromCompare = compareFn => (a, b) => compareFn(a, b) < 0;
+exports.lessFromCompare = lessFromCompare;
+const equalFromLess = lessFn => (a, b) => !lessFn(a, b) && !lessFn(b, a);
+exports.equalFromLess = equalFromLess;
+const greaterFromLess = lessFn => (a, b) => lessFn(b, a);
+exports.greaterFromLess = greaterFromLess;
+const binarySearch = (sortedArray, lessValueFn, from = 0, to = sortedArray.length) => {
+  let left = from,
+    right = to;
+  while (left < right) {
+    const mid = left + right >> 1;
+    if (lessValueFn(sortedArray[mid])) {
+      left = mid + 1;
+    } else {
+      right = mid;
+    }
+  }
+  return right;
+};
+exports.binarySearch = binarySearch;
+const copyOptions = (target, pattern, ...sources) => {
+  target = target || {};
+  const keys = Object.keys(pattern);
+  for (const key of keys) {
+    target[key] = pattern[key];
+  }
+  for (const source of sources) {
+    if (!source || typeof source !== 'object') continue;
+    for (const key of keys) {
+      if (key in source) target[key] = source[key];
+    }
+  }
+  return target;
+};
+exports.copyOptions = copyOptions;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "list-toolkit",
+  "version": "1.0.1",
+  "description": "List-based data structures to organize your objects.",
+  "type": "module",
+  "exports": {
+    "import": "./src/*",
+    "default": "./cjs/*"
+  },
+  "scripts": {
+    "test": "tape6 --flags FO",
+    "prepareDist": "node scripts/prepareDist.js",
+    "build": "babel src --out-dir cjs",
+    "prepublishOnly": "npm run prepareDist && npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uhop/list-toolkit.git"
+  },
+  "keywords": [
+    "list",
+    "lists",
+    "cache",
+    "heap",
+    "data structures"
+  ],
+  "author": "Eugene Lazutkin <eugene.lazutkin@gmail.com> (http://www.lazutkin.com/)",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/uhop/list-toolkit/issues"
+  },
+  "homepage": "https://github.com/uhop/list-toolkit#readme",
+  "devDependencies": {
+    "@babel/cli": "^7.24.5",
+    "@babel/core": "^7.24.5",
+    "@babel/preset-env": "^7.24.5",
+    "tape-six": "^0.9.5"
+  },
+  "files": [
+    "/src",
+    "/cjs"
+  ],
+  "babel": {
+    "presets": [
+      [
+        "@babel/preset-env",
+        {
+          "targets": {
+            "node": "current"
+          }
+        }
+      ]
+    ]
+  },
+  "tape6": {
+    "tests": [
+      "/tests/test-*.*js"
+    ]
+  }
+}

package/src/Cache.js

@@ -0,0 +1,61 @@
+'use strict';
+
+import List from './List.js';
+
+class Cache {
+  constructor(capacity = 10) {
+    this.capacity = capacity;
+    this.size = 0;
+    this.list = new List();
+    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();
+  }
+}
+
+export default Cache;