list-toolkit 1.0.2 → 2.1.0

package/src/cache/cache-lru.js

@@ -0,0 +1,87 @@
+'use strict';
+
+import ValueList from '../value-list.js';
+import {addAliases} from '../meta-utils.js';
+
+// The base cache class. Evicts the least recently used items.
+// Based on doubly linked value lists.
+
+export class CacheLRU {
+  constructor(capacity = 10) {
+    this.capacity = capacity;
+    this.list = new ValueList();
+    this.dict = new Map();
+  }
+  get isEmpty() {
+    return !this.dict.size;
+  }
+  get size() {
+    return this.dict.size;
+  }
+  has(key) {
+    return this.dict.has(key);
+  }
+  find(key) {
+    const node = this.use(key);
+    return node ? node.value.value : undefined;
+  }
+  remove(key) {
+    const node = this.dict.get(key);
+    if (node) {
+      this.dict.delete(key);
+      this.list.removeNode(node);
+    }
+    return this;
+  }
+  register(key, value) {
+    const node = this.use(key);
+    if (node) {
+      this.update(node, value);
+      return this;
+    }
+    if (this.dict.size >= this.capacity) {
+      this.evictAndReplace(key, value);
+      return this;
+    }
+    this.addNew(key, value);
+    return this;
+  }
+  use(key) {
+    const node = this.dict.get(key);
+    if (node) this.list.moveToFront(node);
+    return node;
+  }
+  update(node, value) {
+    node.value.value = value;
+    return this;
+  }
+  addNew(key, value) {
+    this.list.pushFront({key, value});
+    const node = this.list.front;
+    this.dict.set(key, node);
+    return node;
+  }
+  evictAndReplace(key, value) {
+    const node = this.list.back;
+    this.list.moveToFront(node);
+    this.dict.delete(node.value.key);
+    this.dict.set(key, node);
+    node.value = {key, value};
+    return node;
+  }
+  clear() {
+    this.dict.clear();
+    this.list.clear();
+    return this;
+  }
+  [Symbol.iterator]() {
+    return this.list[Symbol.iterator]();
+  }
+  getReverseIterator() {
+    return this.list.getReverseIterator();
+  }
+}
+
+addAliases(CacheLRU.prototype, {register: 'add, set', remove: 'delete', find: 'get'});
+
+export default CacheLRU;

package/src/cache/cache-random.js

@@ -0,0 +1,73 @@
+'use strict';
+
+import {addAlias} from '../meta-utils.js';
+import MinHeap from '../heap/min-heap.js';
+import CacheLRU from './cache-lru.js';
+
+// Evicts items randomly.
+
+export class CacheRandom extends CacheLRU {
+  constructor(capacity = 10) {
+    super(capacity);
+    this.heap = new MinHeap({less: (a, b) => a.value.id > b.value.id});
+    this.nextId = 0;
+  }
+  use(key) {
+    return this.dict.get(key);
+  }
+  update(node, value) {
+    node.value.value = value;
+    return this;
+  }
+  addNew(key, value) {
+    this.list.pushFront({key, value, id: this.nextId++});
+    const node = this.list.front;
+    this.dict.set(key, node);
+    this.heap.push(node);
+    return node;
+  }
+  evictAndReplace(key, value) {
+    const index = Math.floor(this.heap.length * Math.random());
+
+    const node = this.heap.array[index],
+      isDecreased = value > node.value.value;
+
+    this.dict.delete(node.value.key);
+    this.dict.set(key, node);
+
+    node.value.key = key;
+    node.value.value = value;
+
+    this.heap.updateByIndex(index, isDecreased);
+
+    return node;
+  }
+  remove(key) {
+    const node = this.dict.get(key);
+    if (node) {
+      this.dict.delete(key);
+      this.list.removeNode(node);
+      this.heap.remove(node);
+    }
+    return this;
+  }
+  clear() {
+    super.clear();
+    this.heap.clear();
+    this.nextId = 0;
+    return this;
+  }
+  resetIds() {
+    this.nextId = 0;
+    for (const item of this.heap) {
+      item.id = this.nextId++;
+    }
+    const array = this.heap.array;
+    this.heap.clear().merge(array);
+    return this;
+  }
+}
+
+addAlias(CacheRandom.prototype, 'remove', 'delete');
+
+export default CacheRandom;

package/src/cache/decorator.js

@@ -0,0 +1,45 @@
+'use strict';
+
+export const decorateFn = (fn, cache) => {
+  if (typeof fn !== 'function') throw new TypeError('Not a function');
+  const wrapped = function (...args) {
+    const key = args[0],
+      cache = wrapped.cache;
+    if (cache.has(key)) return cache.get(key);
+    const result = wrapped.fn.apply(this, args);
+    cache.set(key, result);
+    return result;
+  };
+  wrapped.fn = fn;
+  wrapped.cache = cache;
+  return wrapped;
+};
+
+export const decorate = (object, key, cache) => {
+  const descriptor = Object.getOwnPropertyDescriptor(object, key);
+  if (!descriptor) throw new Error('Missing property: ' + key);
+
+  const newDescriptor = {...descriptor},
+    wrapped = decorateFn(descriptor.value, cache);
+
+  newDescriptor.value = wrapped;
+
+  Object.defineProperty(object, key, newDescriptor);
+
+  return wrapped;
+};
+
+export const decorateMethod = (object, key, cache) => {
+  const fn = object[key],
+    wrapped = decorateFn(fn, cache);
+  object[key] = wrapped;
+  return wrapped;
+};
+
+export const getCache = (object, key) => {
+  const descriptor = Object.getOwnPropertyDescriptor(object, key);
+  if (!descriptor) throw new Error('Missing property: ' + key);
+  return descriptor.value.cache;
+};
+
+export default decorate;

package/src/cache.js

@@ -0,0 +1,9 @@
+'use strict';
+
+export * from './cache/cache-lru.js';
+import Cache from './cache/cache-lru.js';
+import decorator from './cache/decorator.js';
+
+export const cacheDecorator = (object, key, cache = new Cache()) => decorator(object, key, cache);
+
+export default Cache;

package/src/ext-list.js

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

package/src/ext-slist.js

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

package/src/ext-value-list.js

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

package/src/ext-value-slist.js

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

package/src/{MinHeap.js → heap/min-heap.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-import {copyOptions} from './utils.js';
+import {copyOptions} from '../meta-utils.js';
 
 // the following functions are inlined:
 
@@ -26,17 +26,10 @@ const down = (array, i, less = defaultLess, n = array.length) => {
   for (;;) {
     const l = (i << 1) + 1;
     if (l >= n) break;
-    let c = l,
+    const r = l + 1,
+      c = r < n && less(array[r], array[l]) ? r : l,
+      iValue = array[i],
       cValue = array[c];
-    const r = c + 1;
-    if (r < n) {
-      const rValue = array[r];
-      if (less(rValue, cValue)) {
-        c = r;
-        cValue = rValue;
-      }
-    }
-    const iValue = array[i];
     if (!less(cValue, iValue)) break;
     array[i] = cValue;
     array[c] = iValue;
@@ -48,6 +41,10 @@ const down = (array, i, less = defaultLess, n = array.length) => {
 export class MinHeap {
   constructor(options, ...args) {
     copyOptions(this, MinHeap.defaults, options);
+    if (typeof this.compare == 'function') {
+      this.less = (a, b) => this.compare(a, b) < 0;
+      this.equal = (a, b) => !this.compare(a, b);
+    }
     this.array = [];
     this.merge(...args);
   }
@@ -64,9 +61,8 @@ export class MinHeap {
     return this.array[0];
   }
 
-  clear() {
-    this.array = [];
-    return this;
+  peek() {
+    return this.array[0];
   }
 
   pop() {
@@ -84,17 +80,10 @@ export class MinHeap {
     for (let i = 0; ; ) {
       const l = (i << 1) + 1;
       if (l >= n) break;
-      let c = l,
+      const r = l + 1,
+        c = r < n && this.less(this.array[r], this.array[l]) ? r : l,
+        iValue = this.array[i],
         cValue = this.array[c];
-      const r = c + 1;
-      if (r < n) {
-        const rValue = this.array[r];
-        if (this.less(rValue, cValue)) {
-          c = r;
-          cValue = rValue;
-        }
-      }
-      const iValue = this.array[i];
       if (!this.less(cValue, iValue)) break;
       this.array[i] = cValue;
       this.array[c] = iValue;
@@ -128,17 +117,10 @@ export class MinHeap {
     for (let i = 0; ; ) {
       const l = (i << 1) + 1;
       if (l >= n) break;
-      let c = l,
+      const r = l + 1,
+        c = r < n && this.less(this.array[r], this.array[l]) ? r : l,
+        iValue = this.array[i],
         cValue = this.array[c];
-      const r = c + 1;
-      if (r < n) {
-        const rValue = this.array[r];
-        if (this.less(rValue, cValue)) {
-          c = r;
-          cValue = rValue;
-        }
-      }
-      const iValue = this.array[i];
       if (!this.less(cValue, iValue)) break;
       this.array[i] = cValue;
       this.array[c] = iValue;
@@ -156,17 +138,10 @@ export class MinHeap {
     for (let i = 0; ; ) {
       const l = (i << 1) + 1;
       if (l >= n) break;
-      let c = l,
+      const r = l + 1,
+        c = r < n && this.less(this.array[r], this.array[l]) ? r : l,
+        iValue = this.array[i],
         cValue = this.array[c];
-      const r = c + 1;
-      if (r < n) {
-        const rValue = this.array[r];
-        if (this.less(rValue, cValue)) {
-          c = r;
-          cValue = rValue;
-        }
-      }
-      const iValue = this.array[i];
       if (!this.less(cValue, iValue)) break;
       this.array[i] = cValue;
       this.array[c] = iValue;
@@ -180,12 +155,43 @@ export class MinHeap {
     return this.array.findIndex(element => this.equal(element, value)) >= 0;
   }
 
+  findIndex(value) {
+    return this.array.findIndex(element => this.equal(element, value));
+  }
+
   remove(value) {
-    return MinHeap.remove(this.array, value, this.less, this.equal);
+    MinHeap.remove(this.array, value, this.less, this.equal);
+    return this;
+  }
+
+  removeByIndex(index) {
+    MinHeap.removeByIndex(this.array, index, this.less);
+    return this;
   }
 
   replace(value, newValue) {
-    return MinHeap.replace(this.array, value, newValue, this.less, this.equal);
+    MinHeap.replace(this.array, value, newValue, this.less, this.equal);
+    return this;
+  }
+
+  replaceByIndex(index, newValue) {
+    MinHeap.replaceByIndex(this.array, index, newValue, this.less);
+    return this;
+  }
+
+  updateTop() {
+    down(this.array, 0, this.less);
+    return this;
+  }
+
+  updateByIndex(index, isDecreased) {
+    MinHeap.updateByIndex(this.array, index, isDecreased, this.less);
+    return this;
+  }
+
+  clear() {
+    this.array = [];
+    return this;
   }
 
   releaseSorted() {
@@ -227,17 +233,10 @@ export class MinHeap {
       for (let i = j; ; ) {
         const l = (i << 1) + 1;
         if (l >= n) break;
-        let c = l,
+        const r = l + 1,
+          c = r < n && less(array[r], array[l]) ? r : l,
+          iValue = array[i],
           cValue = array[c];
-        const r = c + 1;
-        if (r < n) {
-          const rValue = array[r];
-          if (less(rValue, cValue)) {
-            c = r;
-            cValue = rValue;
-          }
-        }
-        const iValue = array[i];
         if (!less(cValue, iValue)) break;
         array[i] = cValue;
         array[c] = iValue;
@@ -268,10 +267,7 @@ export class MinHeap {
 
   static pushPop(heapArray, item, less = MinHeap.defaults.less) {
     if (!heapArray.length || less(item, heapArray[0])) return item;
-    const top = heapArray[0];
-    heapArray[0] = item;
-    down(heapArray, 0, less);
-    return top;
+    return MinHeap.replaceTop(heapArray, item, less);
   }
 
   static replaceTop(heapArray, item, less = MinHeap.defaults.less) {
@@ -289,46 +285,38 @@ export class MinHeap {
     return heapArray.findIndex(element => equal(element, item));
   }
 
-  static removeByIndex(heapArray, index, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
+  static removeByIndex(heapArray, index, less = MinHeap.defaults.less) {
     if (index < 0 || index >= heapArray.length) return this;
     const last = heapArray.length - 1;
     if (index !== last) {
-      const item = heapArray[index];
-      heapArray[index] = heapArray.pop();
-      if (less(heapArray[index], item)) up(heapArray, index, less);
-      else down(heapArray, index, less);
-    } else heapArray.pop();
-    return this;
+      const item = heapArray[index],
+        newItem = (heapArray[index] = heapArray.pop());
+      return MinHeap.updateByIndex(heapArray, index, less(newItem, item), less);
+    }
+    heapArray.pop();
+    return heapArray;
   }
 
   static remove(heapArray, item, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
     const index = heapArray.findIndex(element => equal(element, item));
-    if (index < 0) return this;
-    const last = heapArray.length - 1;
-    if (index !== last) {
-      heapArray[index] = heapArray.pop();
-      if (less(heapArray[index], item)) up(heapArray, index, less);
-      else down(heapArray, index, less);
-    } else heapArray.pop();
-    return this;
+    return MinHeap.removeByIndex(heapArray, index, less);
   }
 
-  static replaceByIndex(heapArray, index, newItem, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
+  static replaceByIndex(heapArray, index, newItem, less = MinHeap.defaults.less) {
     if (index < 0 || index >= heapArray.length) return this;
     const item = heapArray[index];
     heapArray[index] = newItem;
-    if (less(newItem, item)) up(heapArray, index, less);
-    else down(heapArray, index, less);
-    return this;
+    return MinHeap.updateByIndex(heapArray, index, less(newItem, item), less);
   }
 
   static replace(heapArray, item, newItem, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
     const index = heapArray.findIndex(element => equal(element, item));
-    if (index < 0) return this;
-    heapArray[index] = newItem;
-    if (less(newItem, item)) up(heapArray, index, less);
-    else down(heapArray, index, less);
-    return this;
+    return MinHeap.replaceByIndex(heapArray, index, newItem, less);
+  }
+
+  static updateByIndex(heapArray, index, isDecreased, less = MinHeap.defaults.less) {
+    if (index < 0 || index >= heapArray.length) return this;
+    return (isDecreased ? up : down)(heapArray, index, less);
   }
 
   static sort(heapArray, less = MinHeap.defaults.less) {
@@ -341,6 +329,6 @@ export class MinHeap {
   }
 }
 
-MinHeap.defaults = {less: defaultLess, equal: defaultEqual};
+MinHeap.defaults = {less: defaultLess, equal: defaultEqual, compare: null};
 
 export default MinHeap;

package/src/heap.js

@@ -0,0 +1,6 @@
+'use strict';
+
+export * from './heap/min-heap.js';
+import Heap from './heap/min-heap.js';
+
+export default Heap;

package/src/list/basics.js

@@ -0,0 +1,64 @@
+'use strict';
+
+// useful low-level operations on doubly linked lists
+
+export const extract = ({nextName, prevName}, {from, to = from}) => {
+  const next = to[nextName],
+    prev = from[prevName];
+
+  // extract
+  prev[nextName] = next;
+  next[prevName] = prev;
+
+  // clear
+  from[prevName] = to;
+  to[nextName] = from;
+
+  return {extracted: from, rest: next === from ? null : next};
+};
+
+// pop(options, head).node === extract(options, {from: node})
+
+export const pop = ({nextName, prevName}, node) => {
+  const next = node[nextName],
+    prev = node[prevName];
+
+  // extract
+  prev[nextName] = next;
+  next[prevName] = prev;
+
+  // clear
+  node[prevName] = node[nextName] = node;
+
+  return {extracted: node, rest: next === node ? null : next};
+};
+
+export const splice = ({nextName, prevName}, target, circularList) => {
+  const next = target[nextName],
+    from = circularList,
+    to = from[prevName];
+
+  // splice
+  target[nextName] = from;
+  from[prevName] = target;
+  to[nextName] = next;
+  next[prevName] = to;
+
+  return target;
+};
+
+// append(options, target, range) === splice(options, target, extract(options, range))
+
+export const append = ({nextName, prevName}, target, {from, to = from}) => {
+  // extract
+  from[prevName][nextName] = to[nextName];
+  to[nextName][prevName] = from[prevName];
+
+  // splice
+  to[nextName] = target[nextName];
+  to[nextName][prevName] = to;
+  target[nextName] = from;
+  from[prevName] = target;
+
+  return target;
+};