list-toolkit 1.0.1 → 1.0.2

package/README.md

@@ -1,4 +1,7 @@
-# List toolkit
+# List toolkit [![NPM version][npm-img]][npm-url]
+
+[npm-img]: https://img.shields.io/npm/v/list-toolkit.svg
+[npm-url]: https://npmjs.org/package/list-toolkit
 
 List-based **efficient** data structures to organize your objects.
 This is a pure JavaScript module with no dependencies
@@ -10,6 +13,7 @@ The toolkit provides the following data structures with a full set of efficientl
 * **ListHead**: a doubly linked list that uses custom properties on external objects to link them around.
   * Using different custom properties the same object can be linked in different ways.
 * **SList**: a singly linked list implemented as a container.
+* **SListHead**: a singly linked list that uses custom properties on external objects to link them around.
   * Using different custom properties the same object can be linked in different ways.
 * **Cache**: a List-based container with a limited capacity and an LRU policy of evicting old entries.
 * **MinHeap**: a classic heap data structure (a priority queue).
@@ -431,7 +435,10 @@ The main operations are:
 
 | Method | Description | Complexity |
 |------|-----------|-----|
-| `new MinHeap({less = (a, b) => a < b, equal: (a, b) => a === b}, ...args)` | create a new heap optionally from iterables or other heaps | *O(k)* |
+| `new MinHeap({less = (a, b) => a < b, equal: (a, b) => a === b}, ...args)` | create a new heap and optionally populate it from iterables or other heaps | *O(k)* |
+| `array` | get the underlying array organized as min heap | *O(1)* |
+| `less` | get the comparison function | *O(1)* |
+| `equal` | get the equality function | *O(1)* |
 | `length` | get the number of elements in the heap | *O(1)* |
 | `isEmpty` | check if the heap is empty | *O(1)* |
 | `top` | get the top element | *O(1)* |
@@ -440,6 +447,9 @@ The main operations are:
 | `push(value)` | add new element | *O(log(n))* |
 | `pushPop(value)` | add new element and then return the top element | *O(log(n))* |
 | `replaceTop(value)` | return the top element and then add new element | *O(log(n))* |
+| `has(value)` | check if the heap contains an element | *O(n)* |
+| `remove(value)` | remove an element | *O(n)* |
+| `replace(value, newValue)` | replace an element | *O(n)* |
 | `releaseSorted()` | remove all elements and return them as an array in the reverse sorted order (the heap will be cleared) | *O(n)* |
 | `merge(...args)` | add elements from iterables or other heaps | *O(k)* |
 | `make(...args)` | return a new heap with the same options | *O(1)* |
@@ -454,6 +464,12 @@ The main operations are:
 | `MinHeap.push(heapArray, value, less = (a, b) => a < b)` | add new element | *O(log(n))* |
 | `MinHeap.pushPop(heapArray, value, less = (a, b) => a < b)` | add new element and then return the top element | *O(log(n))* |
 | `MinHeap.replaceTop(heapArray, value, less = (a, b) => a < b)` | return the top element and then add new element | *O(log(n))* |
+| `MinHeap.findIndex(heapArray, item, equal = (a, b) => a === b)` | return the index of an element or -1| *O(n)* |
+| `MinHead.removeByIndex(heapArray, index, less = (a, b) => a < b, equal = (a, b) => a === b)` | remove an element by index | *O(log(n))* |
+| `MinHeap.replaceByIndex(heapArray, index, value, less = (a, b) => a < b, equal = (a, b) => a === b)` | replace an element by index | *O(log(n))* |
+| `MinHead.has(heapArray, item, equal = (a, b) => a === b)` | check if the heap contains an element | *O(n)* |
+| `MinHeap.remove(heapArray, item, less = (a, b) => a < b, equal = (a, b) => a === b)` | remove an element | *O(n)* |
+| `MinHeap.replace(heapArray, item, newItem, less = (a, b) => a < b, equal = (a, b) => a === b)` | replace an element | *O(n)* |
 | `MinHeap.sort(heapArray, less = (a, b) => a < b)` | sort an array in place | *O(n * log(n))* |
 
 ## License
@@ -462,4 +478,5 @@ BSD 3-Clause "New" or "Revised" License. See the LICENSE file for details.
 
 ## Release History
 
+* 1.0.1 *Fixed exports. Added more methods to `MinHeap`.*
 * 1.0.1 *Initial release.*

package/cjs/Cache.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.Cache = void 0;
 var _List = _interopRequireDefault(require("./List.js"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class Cache {
@@ -67,4 +67,5 @@ class Cache {
     return this.list.getReverseIterable();
   }
 }
+exports.Cache = Cache;
 var _default = exports.default = Cache;

package/cjs/List.js

@@ -3,12 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+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;
@@ -62,6 +63,7 @@ class ListValueNode extends ListNode {
     return this;
   }
 }
+exports.ListValueNode = ListValueNode;
 class List extends ListNode {
   get isEmpty() {
     return this.next === this;
@@ -280,6 +282,7 @@ class List extends ListNode {
     return list;
   }
 }
+exports.List = List;
 List.pop = pop;
 List.extract = extract;
 List.splice = splice;

package/cjs/ListHead.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.ListHead = void 0;
 var _utils = require("./utils.js");
 class ListHead {
   constructor(head = null, options) {
@@ -293,6 +293,7 @@ class ListHead {
     return list;
   }
 }
+exports.ListHead = ListHead;
 ListHead.defaults = {
   nextName: 'next',
   prevName: 'prev'

package/cjs/MinHeap.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.MinHeap = void 0;
 var _utils = require("./utils.js");
 // the following functions are inlined:
 
@@ -166,6 +166,16 @@ class MinHeap {
     }
     return top;
   }
+  has(value) {
+    // return MinHeap.has(this.array, value, this.equal); // inlined
+    return this.array.findIndex(element => this.equal(element, value)) >= 0;
+  }
+  remove(value) {
+    return MinHeap.remove(this.array, value, this.less, this.equal);
+  }
+  replace(value, newValue) {
+    return MinHeap.replace(this.array, value, newValue, this.less, this.equal);
+  }
   releaseSorted() {
     MinHeap.sort(this.array, this.less);
     const array = this.array;
@@ -245,6 +255,46 @@ class MinHeap {
     down(heapArray, 0, less);
     return top;
   }
+  static has(heapArray, item, equal = MinHeap.defaults.equal) {
+    return heapArray.findIndex(element => equal(element, item)) >= 0;
+  }
+  static findIndex(heapArray, item, equal = MinHeap.defaults.equal) {
+    return heapArray.findIndex(element => equal(element, item));
+  }
+  static removeByIndex(heapArray, index, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
+    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;
+  }
+  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;
+  }
+  static replaceByIndex(heapArray, index, newItem, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
+    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;
+  }
+  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;
+  }
   static sort(heapArray, less = MinHeap.defaults.less) {
     if (heapArray.length <= 1) return heapArray;
     for (let n = heapArray.length - 1; n; --n) {
@@ -254,6 +304,7 @@ class MinHeap {
     return heapArray;
   }
 }
+exports.MinHeap = MinHeap;
 MinHeap.defaults = {
   less: defaultLess,
   equal: defaultEqual

package/cjs/SList.js

@@ -3,12 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.SListValueNode = exports.SListPtr = exports.SListNode = exports.SList = void 0;
 class SListNode {
   constructor() {
     this.next = this;
   }
 }
+exports.SListNode = SListNode;
 const pop = prev => {
   const node = prev.next;
   prev.next = node.next;
@@ -78,6 +79,7 @@ class SListValueNode extends SListNode {
     return this;
   }
 }
+exports.SListValueNode = SListValueNode;
 class SList extends SListNode {
   get isEmpty() {
     return this.next === this;
@@ -304,6 +306,7 @@ class SList extends SListNode {
     return list;
   }
 }
+exports.SList = SList;
 SList.pop = pop;
 SList.extract = extract;
 SList.splice = splice;
@@ -314,7 +317,7 @@ SList.ValueNode = SListValueNode;
 SList.prototype.pop = SList.prototype.popFront;
 SList.prototype.push = SList.prototype.pushFront;
 SList.prototype.append = SList.prototype.appendBack;
-SList.SListPtr = class SListPtr {
+class SListPtr {
   constructor(list, prev) {
     this.list = list;
     this.prev = prev || list;
@@ -332,5 +335,8 @@ SList.SListPtr = class SListPtr {
   clone() {
     return new SList.SListPtr(this.list, this.prev);
   }
-};
+}
+exports.SListPtr = SListPtr;
+;
+SList.SListPtr = SListPtr;
 var _default = exports.default = SList;

package/cjs/SListHead.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.SListPtr = exports.SListHead = void 0;
 var _utils = require("./utils.js");
 class SListHead {
   constructor(head = null, options) {
@@ -330,6 +330,7 @@ class SListHead {
     return list;
   }
 }
+exports.SListHead = SListHead;
 SListHead.defaults = {
   nextName: 'next'
 };
@@ -341,7 +342,7 @@ SListHead.Unsafe = class Unsafe {
     this.head = head;
   }
 };
-SListHead.SListPtr = class SListPtr {
+class SListPtr {
   constructor(list, prev) {
     this.list = list;
     this.prev = prev || list.head;
@@ -359,5 +360,8 @@ SListHead.SListPtr = class SListPtr {
   clone() {
     return new SListHead.SListPtr(this.list, this.prev);
   }
-};
+}
+exports.SListPtr = SListPtr;
+;
+SListHead.SListPtr = SListPtr;
 var _default = exports.default = SListHead;

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "list-toolkit",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "List-based data structures to organize your objects.",
   "type": "module",
   "exports": {
-    "import": "./src/*",
-    "default": "./cjs/*"
+    "./*": {
+      "require": "./cjs/*",
+      "default": "./src/*"
+    }
   },
   "scripts": {
     "test": "tape6 --flags FO",

package/src/Cache.js

@@ -2,7 +2,7 @@
 
 import List from './List.js';
 
-class Cache {
+export class Cache {
   constructor(capacity = 10) {
     this.capacity = capacity;
     this.size = 0;

package/src/List.js

@@ -1,6 +1,6 @@
 'use strict';
 
-class ListNode {
+export class ListNode {
   constructor() {
     this.prev = this.next = this;
   }
@@ -34,7 +34,7 @@ const splice = (head1, head2) => {
   return head1;
 };
 
-class ListValueNode extends ListNode {
+export class ListValueNode extends ListNode {
   constructor(value) {
     super();
     this.value = value;
@@ -65,7 +65,7 @@ class ListValueNode extends ListNode {
   }
 }
 
-class List extends ListNode {
+export class List extends ListNode {
   get isEmpty() {
     return this.next === this;
   }

package/src/ListHead.js

@@ -2,7 +2,7 @@
 
 import {copyOptions} from './utils.js';
 
-class ListHead {
+export class ListHead {
   constructor(head = null, options) {
     if (head instanceof ListHead) {
       ({nextName: this.nextName, prevName: this.prevName, head: this.head} = head);

package/src/MinHeap.js

@@ -45,7 +45,7 @@ const down = (array, i, less = defaultLess, n = array.length) => {
   return array;
 };
 
-class MinHeap {
+export class MinHeap {
   constructor(options, ...args) {
     copyOptions(this, MinHeap.defaults, options);
     this.array = [];
@@ -175,6 +175,19 @@ class MinHeap {
     return top;
   }
 
+  has(value) {
+    // return MinHeap.has(this.array, value, this.equal); // inlined
+    return this.array.findIndex(element => this.equal(element, value)) >= 0;
+  }
+
+  remove(value) {
+    return MinHeap.remove(this.array, value, this.less, this.equal);
+  }
+
+  replace(value, newValue) {
+    return MinHeap.replace(this.array, value, newValue, this.less, this.equal);
+  }
+
   releaseSorted() {
     MinHeap.sort(this.array, this.less);
     const array = this.array;
@@ -268,6 +281,56 @@ class MinHeap {
     return top;
   }
 
+  static has(heapArray, item, equal = MinHeap.defaults.equal) {
+    return heapArray.findIndex(element => equal(element, item)) >= 0;
+  }
+
+  static findIndex(heapArray, item, equal = MinHeap.defaults.equal) {
+    return heapArray.findIndex(element => equal(element, item));
+  }
+
+  static removeByIndex(heapArray, index, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
+    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;
+  }
+
+  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;
+  }
+
+  static replaceByIndex(heapArray, index, newItem, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
+    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;
+  }
+
+  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;
+  }
+
   static sort(heapArray, less = MinHeap.defaults.less) {
     if (heapArray.length <= 1) return heapArray;
     for (let n = heapArray.length - 1; n; --n) {

package/src/SList.js

@@ -1,6 +1,6 @@
 'use strict';
 
-class SListNode {
+export class SListNode {
   constructor() {
     this.next = this;
   }
@@ -46,7 +46,7 @@ const getPrev = (list, node) => {
   return getPrevPrev(list, node).next;
 };
 
-class SListValueNode extends SListNode {
+export class SListValueNode extends SListNode {
   constructor(value) {
     super();
     this.value = value;
@@ -65,7 +65,7 @@ class SListValueNode extends SListNode {
   }
 }
 
-class SList extends SListNode {
+export class SList extends SListNode {
   get isEmpty() {
     return this.next === this;
   }
@@ -306,7 +306,7 @@ SList.prototype.pop = SList.prototype.popFront;
 SList.prototype.push = SList.prototype.pushFront;
 SList.prototype.append = SList.prototype.appendBack;
 
-SList.SListPtr = class SListPtr {
+export class SListPtr {
   constructor(list, prev) {
     this.list = list;
     this.prev = prev || list;
@@ -325,5 +325,6 @@ SList.SListPtr = class SListPtr {
     return new SList.SListPtr(this.list, this.prev);
   }
 };
+SList.SListPtr = SListPtr;
 
 export default SList;

package/src/SListHead.js

@@ -2,7 +2,7 @@
 
 import {copyOptions} from './utils.js';
 
-class SListHead {
+export class SListHead {
   constructor(head = null, options) {
     if (head instanceof SListHead) {
       ({nextName: this.nextName, head: this.head} = head);
@@ -330,7 +330,7 @@ SListHead.Unsafe = class Unsafe {
   }
 };
 
-SListHead.SListPtr = class SListPtr {
+export class SListPtr {
   constructor(list, prev) {
     this.list = list;
     this.prev = prev || list.head;
@@ -349,5 +349,6 @@ SListHead.SListPtr = class SListPtr {
     return new SListHead.SListPtr(this.list, this.prev);
   }
 };
+SListHead.SListPtr = SListPtr;
 
 export default SListHead;