collect-your-stuff 1.3.0 → 1.4.0

package/dist/collections/linked-list/Linker.js

@@ -14,7 +14,7 @@ var _ArrayElement = require('../arrayable/ArrayElement')
 class Linker {
   /**
    * Create the new Linker instance, provide the data and optionally give the next Linker.
-   * @param {Object} [nodeData={}]
+   * @param {Object} [nodeData={}] The settings for the new linker.
    * @param {*} [nodeData.data=null] The data to be stored in this linker
    * @param {Linker|null} [nodeData.next=null] The reference to the next linker if any
    */
@@ -22,8 +22,11 @@ class Linker {
     data = null,
     next = null
   } = {}) {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     this.classType = Linker
+    /** The data stored in this linker. */
     this.data = null
+    /** The linker after this one, or null when this is the last. */
     this.next = null
     this.data = data
     this.next = next
@@ -37,8 +40,8 @@ class Linker {
  */
 exports.Linker = Linker
 Linker.make = (linker, classType = Linker) => {
-  if (typeof linker !== 'object') {
-    // It is not an object, so instantiate the Linker with element as the data
+  if (linker === null || typeof linker !== 'object') {
+    // It is not an object (or it is null), so instantiate the Linker with element as the data
     return new classType({
       data: linker
     })
@@ -47,7 +50,8 @@ Linker.make = (linker, classType = Linker) => {
     // Already valid Linker, return as-is
     return linker
   }
-  if (!linker.data) {
+  if (!('data' in linker)) {
+    // Not the settings for a linker (which would have data, even if it is falsy), so it is the data itself
     linker = {
       data: linker
     }
@@ -61,7 +65,7 @@ Linker.make = (linker, classType = Linker) => {
  * @param {IsLinker} [classType=Linker] Provide the type of IsLinker to use.
  * @returns {{head: Linker, tail: Linker}}
  */
-Linker.fromArray = (values, classType = Linker) => values.reduce((references, linker) => {
+Linker.fromArray = (values = [], classType = Linker) => values.reduce((references, linker) => {
   const newLinker = classType.make(linker, classType)
   if (references.head === null) {
     // Initialize the head and tail with the new node

package/dist/collections/linked-list/Linker.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Linker=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.reduce.js");var _ArrayElement=require("../arrayable/ArrayElement");class Linker{constructor({data:e=null,next:r=null}={}){this.classType=Linker,this.data=null,this.next=null,this.data=e,this.next=r}}exports.Linker=Linker,Linker.make=(e,r=Linker)=>"object"!=typeof e?new r({data:e}):e.classType?e:(e.data||(e={data:e}),_ArrayElement.ArrayElement.make(e,r)),Linker.fromArray=(e,r=Linker)=>e.reduce(((e,t)=>{const a=r.make(t,r);return null===e.head?{head:a,tail:a}:(e.tail.next=a,e.tail=a,e)}),{head:null,tail:null});
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Linker=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.reduce.js");var _ArrayElement=require("../arrayable/ArrayElement");class Linker{constructor({data:e=null,next:r=null}={}){this.classType=Linker,this.data=null,this.next=null,this.data=e,this.next=r}}exports.Linker=Linker,Linker.make=(e,r=Linker)=>null===e||"object"!=typeof e?new r({data:e}):e.classType?e:("data"in e||(e={data:e}),_ArrayElement.ArrayElement.make(e,r)),Linker.fromArray=(e=[],r=Linker)=>e.reduce(((e,t)=>{const a=r.make(t,r);return null===e.head?{head:a,tail:a}:(e.tail.next=a,e.tail=a,e)}),{head:null,tail:null});

package/dist/collections/linked-tree-list/LinkedTreeList.d.ts

@@ -13,12 +13,21 @@ import { IsTreeNode } from '../../recipes/IsTreeNode';
  * @extends DoublyLinkedList
  */
 export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     readonly classType: typeof LinkedTreeList;
+    /** A linker of the list (null when the list is empty); the head is found by walking back from it. */
     innerList: IsTreeNode | any;
+    /** Whether the inner list has been initialized (it can only be initialized once). */
     initialized: boolean;
+    /** The class used to wrap the data given to this list as tree linkers. */
     linkerClass: typeof TreeLinker;
+    /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
+    private tailCache;
+    /** The number of linkers, kept up to date by the list's own methods so that the length does not need to walk the whole list (null when not known yet). */
+    private countCache;
     /**
      * Create the new LinkedTreeList instance, configure the list class.
+     * @param {TreeLinker} [linkerClass=TreeLinker] The class used to wrap given data as tree linkers.
      */
     constructor(linkerClass?: typeof TreeLinker);
     /**
@@ -28,7 +37,7 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
      */
     initialize(initialList: TreeLinker): LinkedTreeList;
     /**
-     * Retrieve a copy of the innerList used.
+     * Retrieve the innerList used (the list itself, not a copy).
      * @returns {TreeLinker}
      */
     get list(): TreeLinker;
@@ -38,12 +47,13 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
      */
     get first(): TreeLinker;
     /**
-     * Retrieve the last TreeLinker in the list.
+     * Retrieve the last TreeLinker in the list. The end is remembered, so this does not walk the list.
      * @returns {TreeLinker}
      */
     get last(): TreeLinker;
     /**
-     * Return the length of the list.
+     * Return the length of the list. It is kept up to date by the list's own methods, so this does not walk the list
+     * (call reset() after linkers were changed directly).
      * @returns {number}
      */
     get length(): number;
@@ -103,7 +113,8 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
      */
     remove(node: TreeLinker): TreeLinker;
     /**
-     * Refresh all references and return head reference.
+     * Refresh all references (the head, the end and the length) by walking the list once, and return the head. The
+     * list's own methods keep these up to date, so this is only needed after linkers were changed directly.
      * @return {TreeLinker}
      */
     reset(): TreeLinker;
@@ -117,6 +128,7 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
      * Be able to run forEach on this LinkedTreeList to iterate over the TreeLinker Items.
      * @param {forEachCallback} callback The function to call for-each tree node
      * @param {LinkedTreeList} thisArg Optional, 'this' reference
+     * @return {LinkedTreeList} The list which was iterated.
      */
     forEach(callback: forEachCallback, thisArg?: LinkedTreeList): LinkedTreeList;
     /**

package/dist/collections/linked-tree-list/LinkedTreeList.js

@@ -14,6 +14,13 @@ var _DoublyLinkedList = require('../doubly-linked-list/DoublyLinkedList')
  * @memberOf module:collect-your-stuff
  */
 
+/**
+ * Use one of the accessors of DoublyLinkedList (which keeps track of the head, tail and length) for a LinkedTreeList.
+ * @param {string} name The accessor to use
+ * @param {LinkedTreeList} list The list to use it on
+ * @returns {*}
+ */
+const borrowedGetter = (name, list) => Object.getOwnPropertyDescriptor(_DoublyLinkedList.DoublyLinkedList.prototype, name).get.call(list)
 /**
  * LinkedTreeList represents a collection stored with a root and spreading in branching (tree) formation.
  * @extends DoublyLinkedList
@@ -21,11 +28,19 @@ var _DoublyLinkedList = require('../doubly-linked-list/DoublyLinkedList')
 class LinkedTreeList {
   /**
    * Create the new LinkedTreeList instance, configure the list class.
+   * @param {TreeLinker} [linkerClass=TreeLinker] The class used to wrap given data as tree linkers.
    */
   constructor (linkerClass = _TreeLinker.TreeLinker) {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     this.classType = LinkedTreeList
+    /** A linker of the list (null when the list is empty); the head is found by walking back from it. */
     this.innerList = null
+    /** Whether the inner list has been initialized (it can only be initialized once). */
     this.initialized = false
+    /** The last linker, remembered so that adding to the end does not need to walk the whole list (null when not known yet). */
+    this.tailCache = null
+    /** The number of linkers, kept up to date by the list's own methods so that the length does not need to walk the whole list (null when not known yet). */
+    this.countCache = null
     this.linkerClass = linkerClass
   }
 
@@ -45,7 +60,7 @@ class LinkedTreeList {
   }
 
   /**
-   * Retrieve a copy of the innerList used.
+   * Retrieve the innerList used (the list itself, not a copy).
    * @returns {TreeLinker}
    */
   get list () {
@@ -57,38 +72,24 @@ class LinkedTreeList {
    * @returns {TreeLinker}
    */
   get first () {
-    return this.reset()
+    return borrowedGetter('first', this)
   }
 
   /**
-   * Retrieve the last TreeLinker in the list.
+   * Retrieve the last TreeLinker in the list. The end is remembered, so this does not walk the list.
    * @returns {TreeLinker}
    */
   get last () {
-    let tail = this.innerList
-    if (tail === null) {
-      return null
-    }
-    let next = tail.next
-    while (next !== null) {
-      tail = next
-      next = tail.next
-    }
-    return tail
+    return borrowedGetter('last', this)
   }
 
   /**
-   * Return the length of the list.
+   * Return the length of the list. It is kept up to date by the list's own methods, so this does not walk the list
+   * (call reset() after linkers were changed directly).
    * @returns {number}
    */
   get length () {
-    let current = this.first
-    let length = 0
-    while (current !== null) {
-      ++length
-      current = current.next
-    }
-    return length
+    return borrowedGetter('length', this)
   }
 
   /**
@@ -197,7 +198,8 @@ class LinkedTreeList {
   }
 
   /**
-   * Refresh all references and return head reference.
+   * Refresh all references (the head, the end and the length) by walking the list once, and return the head. The
+   * list's own methods keep these up to date, so this is only needed after linkers were changed directly.
    * @return {TreeLinker}
    */
   reset () {
@@ -217,6 +219,7 @@ class LinkedTreeList {
    * Be able to run forEach on this LinkedTreeList to iterate over the TreeLinker Items.
    * @param {forEachCallback} callback The function to call for-each tree node
    * @param {LinkedTreeList} thisArg Optional, 'this' reference
+   * @return {LinkedTreeList} The list which was iterated.
    */
   forEach (callback, thisArg = this) {
     let index = 0

package/dist/collections/linked-tree-list/LinkedTreeList.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LinkedTreeList=void 0;var _TreeLinker=require("./TreeLinker"),_TreeLinkerIterator=require("../../recipes/TreeLinkerIterator"),_DoublyLinkedList=require("../doubly-linked-list/DoublyLinkedList");class LinkedTreeList{constructor(e=_TreeLinker.TreeLinker){this.classType=LinkedTreeList,this.innerList=null,this.initialized=!1,this.linkerClass=e}initialize(e){return this.initialized?(console.warn("Attempt to initialize LinkedTreeList which is not empty."),this):(this.initialized=!0,this.innerList=e,this)}get list(){return this.innerList}get first(){return this.reset()}get last(){let e=this.innerList;if(null===e)return null;let t=e.next;for(;null!==t;)e=t,t=e.next;return e}get length(){let e=this.first,t=0;for(;null!==e;)++t,e=e.next;return t}get parent(){return null===this.first?null:this.first.parent}set parent(e){let t=this.first;for(;null!==t;)t.parent=e,t=t.next;e&&(e.children=this)}get rootParent(){let e=this.first;if(!e)return null;let t=this.first.parent;for(;null!==t;)e=t,t=e.parent;return e}setChildren(e,t=null){Array.from(this).indexOf(e)<0&&console.error("item is not a child of this"),t.parent=e}insertAfter(e,t){return _DoublyLinkedList.DoublyLinkedList.prototype.insertAfter.call(this,e,t)}insertBefore(e,t){return _DoublyLinkedList.DoublyLinkedList.prototype.insertBefore.call(this,e,t)}append(e,t=this.last){return _DoublyLinkedList.DoublyLinkedList.prototype.append.call(this,e,t)}prepend(e,t=this.first){return _DoublyLinkedList.DoublyLinkedList.prototype.prepend.call(this,e,t)}remove(e){return _DoublyLinkedList.DoublyLinkedList.prototype.remove.call(this,e)}reset(){return _DoublyLinkedList.DoublyLinkedList.prototype.reset.call(this)}item(e){return _DoublyLinkedList.DoublyLinkedList.prototype.item.call(this,e)}forEach(e,t=this){let i=0,r=t.first;for(;null!==r;)e(r,i,t),r=r.next,++i;return t}[Symbol.iterator](){let e=this.rootParent;return new _TreeLinkerIterator.TreeLinkerIterator(e)}}exports.LinkedTreeList=LinkedTreeList,LinkedTreeList.fromArray=(e=[],t=_TreeLinker.TreeLinker,i=LinkedTreeList)=>new i(t).initialize(t.fromArray(e).head);
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LinkedTreeList=void 0;var _TreeLinker=require("./TreeLinker"),_TreeLinkerIterator=require("../../recipes/TreeLinkerIterator"),_DoublyLinkedList=require("../doubly-linked-list/DoublyLinkedList");const borrowedGetter=(e,t)=>Object.getOwnPropertyDescriptor(_DoublyLinkedList.DoublyLinkedList.prototype,e).get.call(t);class LinkedTreeList{constructor(e=_TreeLinker.TreeLinker){this.classType=LinkedTreeList,this.innerList=null,this.initialized=!1,this.tailCache=null,this.countCache=null,this.linkerClass=e}initialize(e){return this.initialized?(console.warn("Attempt to initialize LinkedTreeList which is not empty."),this):(this.initialized=!0,this.innerList=e,this)}get list(){return this.innerList}get first(){return borrowedGetter("first",this)}get last(){return borrowedGetter("last",this)}get length(){return borrowedGetter("length",this)}get parent(){return null===this.first?null:this.first.parent}set parent(e){let t=this.first;for(;null!==t;)t.parent=e,t=t.next;e&&(e.children=this)}get rootParent(){let e=this.first;if(!e)return null;let t=this.first.parent;for(;null!==t;)e=t,t=e.parent;return e}setChildren(e,t=null){Array.from(this).indexOf(e)<0&&console.error("item is not a child of this"),t.parent=e}insertAfter(e,t){return _DoublyLinkedList.DoublyLinkedList.prototype.insertAfter.call(this,e,t)}insertBefore(e,t){return _DoublyLinkedList.DoublyLinkedList.prototype.insertBefore.call(this,e,t)}append(e,t=this.last){return _DoublyLinkedList.DoublyLinkedList.prototype.append.call(this,e,t)}prepend(e,t=this.first){return _DoublyLinkedList.DoublyLinkedList.prototype.prepend.call(this,e,t)}remove(e){return _DoublyLinkedList.DoublyLinkedList.prototype.remove.call(this,e)}reset(){return _DoublyLinkedList.DoublyLinkedList.prototype.reset.call(this)}item(e){return _DoublyLinkedList.DoublyLinkedList.prototype.item.call(this,e)}forEach(e,t=this){let r=0,i=t.first;for(;null!==i;)e(i,r,t),i=i.next,++r;return t}[Symbol.iterator](){let e=this.rootParent;return new _TreeLinkerIterator.TreeLinkerIterator(e)}}exports.LinkedTreeList=LinkedTreeList,LinkedTreeList.fromArray=(e=[],t=_TreeLinker.TreeLinker,r=LinkedTreeList)=>new r(t).initialize(t.fromArray(e).head);

package/dist/collections/linked-tree-list/TreeLinker.d.ts

@@ -12,15 +12,21 @@ import { IsTree } from '../../recipes/IsTree';
  * @extends DoubleLinker
  */
 export declare class TreeLinker implements IsTreeNode {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     readonly classType: typeof TreeLinker;
+    /** The data stored in this tree node. */
     data: any;
+    /** The sibling after this node, or null when this is the last child. */
     next: IsTreeNode | null;
+    /** The sibling before this node, or null when this is the first child. */
     prev: IsTreeNode | null;
+    /** The node this node is a child of, or null for a root node. */
     parent: IsTreeNode;
+    /** The list of the children of this node, or null when it has none. */
     children: IsArrayable<IsTreeNode>;
     /**
      * Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
-     * @param {Object} [settings={}]
+     * @param {Object} [settings={}] The settings for the new tree node.
      * @param {*} [settings.data=null] The data to be stored in this tree node
      * @param {TreeLinker} [settings.next=null] The reference to the next linker if any
      * @param {TreeLinker} [settings.prev=null] The reference to the previous linker if any

package/dist/collections/linked-tree-list/TreeLinker.js

@@ -15,7 +15,7 @@ var _LinkedTreeList = require('./LinkedTreeList')
 class TreeLinker {
   /**
    * Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
-   * @param {Object} [settings={}]
+   * @param {Object} [settings={}] The settings for the new tree node.
    * @param {*} [settings.data=null] The data to be stored in this tree node
    * @param {TreeLinker} [settings.next=null] The reference to the next linker if any
    * @param {TreeLinker} [settings.prev=null] The reference to the previous linker if any
@@ -31,11 +31,17 @@ class TreeLinker {
     parent = null,
     listClass = _LinkedTreeList.LinkedTreeList
   } = {}) {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     this.classType = TreeLinker
+    /** The data stored in this tree node. */
     this.data = null
+    /** The sibling after this node, or null when this is the last child. */
     this.next = null
+    /** The sibling before this node, or null when this is the first child. */
     this.prev = null
+    /** The node this node is a child of, or null for a root node. */
     this.parent = null
+    /** The list of the children of this node, or null when it has none. */
     this.children = null
     this.data = data
     this.next = next

package/dist/collections/queue/Queue.d.ts

@@ -12,18 +12,21 @@ import { completeResponse } from '../../recipes/Runnable';
  * Maintain a series of queued items.
  */
 export declare class Queue {
+    /** The list which stores the queueables, the first is next to be dequeued. */
     queuedList: IsArrayable<any>;
     private listClass;
     private queueableClass;
     /**
      * Instantiate the queue with the given queue list.
      * @param {Iterable|LinkedList} queuedList Give the list of queueables to start in this queue.
-     * @param {IsArrayable} listClass
-     * @param {Queueable} queueableClass
+     * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no queued list is given.
+     * @param {Queueable} [queueableClass=Queueable] The class used to wrap queued items.
      */
     constructor(queuedList?: IsArrayable<any>, listClass?: any, queueableClass?: typeof Queueable);
     /**
-     * Take a queued task from the front of the queue and run it if ready.
+     * Take a queued task from the front of the queue and run it if ready. A task which is not ready yet is kept in the
+     * queue (never dropped), a task which is still running is reported as blocking and left to finish on its own, and
+     * completed tasks are discarded.
      * @return {completeResponse|*}
      */
     dequeue(): completeResponse | any;

package/dist/collections/queue/Queue.js

@@ -20,8 +20,8 @@ class Queue {
   /**
    * Instantiate the queue with the given queue list.
    * @param {Iterable|LinkedList} queuedList Give the list of queueables to start in this queue.
-   * @param {IsArrayable} listClass
-   * @param {Queueable} queueableClass
+   * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no queued list is given.
+   * @param {Queueable} [queueableClass=Queueable] The class used to wrap queued items.
    */
   constructor (queuedList = null, listClass = _LinkedList.LinkedList, queueableClass = _Queueable.Queueable) {
     this.listClass = listClass
@@ -33,11 +33,17 @@ class Queue {
   }
 
   /**
-   * Take a queued task from the front of the queue and run it if ready.
+   * Take a queued task from the front of the queue and run it if ready. A task which is not ready yet is kept in the
+   * queue (never dropped), a task which is still running is reported as blocking and left to finish on its own, and
+   * completed tasks are discarded.
    * @return {completeResponse|*}
    */
   dequeue () {
-    const next = this.remove()
+    let next = this.remove()
+    // Tasks which already completed are discarded when they reach the front of the queue
+    while (next && next.complete) {
+      next = this.remove()
+    }
     if (!next) {
       return {
         success: 'No more queueable tasks in the queue',
@@ -45,31 +51,30 @@ class Queue {
         context: this.queuedList
       }
     }
-    if (next.complete) {
-      // Previously ran queued, run next
-      return this.dequeue()
-    }
     if (next.running) {
+      // The unfinished task reports back through its own complete callback, so it is not kept in the queue
       return {
         success: false,
         error: 'The queue has been blocked by an unfinished task.',
         context: next
       }
     }
+    if (!next.isReady) {
+      // Keep the task (at the back, so the next dequeue can try the other tasks) rather than losing it
+      this.enqueue(next)
+      // We could go check the next in queue here but if we end up in a state where nothing is ready it would infinite loop
+      // Also, we want the loop handled externally
+      return {
+        success: false,
+        error: 'Unable to find ready task.',
+        context: next
+      }
+    }
     if (!this.empty()) {
       // Place back in queue to be checked once again next time, only if the queue will not be empty
       this.enqueue(next)
     }
-    if (next.isReady) {
-      return next.run.call(next)
-    }
-    // We could go check the next in queue here but if we end up in a state where nothing is ready it would infinite loop
-    // Also, we want the loop handled externally
-    return {
-      success: false,
-      error: 'Unable to find ready task.',
-      context: next
-    }
+    return next.run.call(next)
   }
 
   /**

package/dist/collections/queue/Queue.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Queue=void 0;var _Queueable=require("./Queueable"),_LinkedList=require("../linked-list/LinkedList");class Queue{constructor(e=null,u=_LinkedList.LinkedList,t=_Queueable.Queueable){this.listClass=u,this.queueableClass=t,null===e&&(e=new u(t)),this.queuedList=e}dequeue(){const e=this.remove();return e?e.complete?this.dequeue():e.running?{success:!1,error:"The queue has been blocked by an unfinished task.",context:e}:(this.empty()||this.enqueue(e),e.isReady?e.run.call(e):{success:!1,error:"Unable to find ready task.",context:e}):{success:"No more queueable tasks in the queue",error:!1,context:this.queuedList}}empty(){return this.size()<=0}enqueue(e){this.queuedList.append(e)}peek(){return this.queuedList.first}remove(){return this.empty()?null:this.queuedList.remove(this.queuedList.first)}size(){return this.queuedList.length}}exports.Queue=Queue,Queue.fromArray=(e=[],u=_Queueable.Queueable,t=_LinkedList.LinkedList)=>{const s=new t(u);return s.initialize(u.fromArray(e,u).head),new Queue(s,t,u)};
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Queue=void 0;var _Queueable=require("./Queueable"),_LinkedList=require("../linked-list/LinkedList");class Queue{constructor(e=null,u=_LinkedList.LinkedList,t=_Queueable.Queueable){this.listClass=u,this.queueableClass=t,null===e&&(e=new u(t)),this.queuedList=e}dequeue(){let e=this.remove();for(;e&&e.complete;)e=this.remove();return e?e.running?{success:!1,error:"The queue has been blocked by an unfinished task.",context:e}:e.isReady?(this.empty()||this.enqueue(e),e.run.call(e)):(this.enqueue(e),{success:!1,error:"Unable to find ready task.",context:e}):{success:"No more queueable tasks in the queue",error:!1,context:this.queuedList}}empty(){return this.size()<=0}enqueue(e){this.queuedList.append(e)}peek(){return this.queuedList.first}remove(){return this.empty()?null:this.queuedList.remove(this.queuedList.first)}size(){return this.queuedList.length}}exports.Queue=Queue,Queue.fromArray=(e=[],u=_Queueable.Queueable,t=_LinkedList.LinkedList)=>{const s=new t(u);return s.initialize(u.fromArray(e,u).head),new Queue(s,t,u)};

package/dist/collections/queue/Queueable.d.ts

@@ -11,15 +11,21 @@ import { IsLinker } from '../../recipes/IsLinker';
  * @extends Linker
  */
 export declare class Queueable implements IsLinker, IsRunnable {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     readonly classType: typeof Queueable;
+    /** The task (or data) this queueable holds. */
     data: any;
+    /** The queueable after this one, or null when this is the last. */
     next: Queueable | null;
+    /** Whether this queueable has been run to completion. */
     complete: boolean;
+    /** Whether this queueable may run, or a function which answers that when asked. */
     ready: Function | boolean;
+    /** Whether this queueable is running right now. */
     running: boolean;
     /**
      * Create a queueable item that can be used in a queue.
-     * @param {Object} [queueableData={}]
+     * @param {Object} [queueableData={}] The settings for the new queueable.
      * @param {*} [queueableData.task=null] The data to be stored in this queueable
      * @param {Queueable|null} [queueableData.next=null] The reference to the next queueable if any
      * @param {boolean|Function} [queueableData.ready=false] Indicate if the queueable is ready to run
@@ -27,7 +33,7 @@ export declare class Queueable implements IsLinker, IsRunnable {
     constructor({ task, next, ready }?: {
         task?: any;
         next?: Queueable | null;
-        ready?: boolean;
+        ready?: boolean | Function;
     });
     /**
      * Check ready state.
@@ -41,7 +47,7 @@ export declare class Queueable implements IsLinker, IsRunnable {
     get task(): any;
     /**
      * Set this queueable as completed.
-     * @param {Object} completeResponse
+     * @param {Object} [completeResponse={}] The result to report for the task.
      * @param {*} [completeResponse.success=true] Indicate when the task failed (use false) or give a success message
      * @param {*} [completeResponse.error=false] Indicate a task was error-free (use false) or give an error message
      * @param {*} [completeResponse.context=null] Provide additional data in the response
@@ -70,7 +76,7 @@ export declare class Queueable implements IsLinker, IsRunnable {
      * @param {IsLinker} [classType=Queueable] Provide the type of IsLinker to use.
      * @returns {{head: Queueable, tail: Queueable}}
      */
-    static fromArray: (values: Array<any>, classType?: any) => {
+    static fromArray: (values?: Array<any>, classType?: any) => {
         head: IsLinker;
         tail: IsLinker;
     };

package/dist/collections/queue/Queueable.js

@@ -12,7 +12,7 @@ var _Linker = require('../linked-list/Linker')
 class Queueable {
   /**
    * Create a queueable item that can be used in a queue.
-   * @param {Object} [queueableData={}]
+   * @param {Object} [queueableData={}] The settings for the new queueable.
    * @param {*} [queueableData.task=null] The data to be stored in this queueable
    * @param {Queueable|null} [queueableData.next=null] The reference to the next queueable if any
    * @param {boolean|Function} [queueableData.ready=false] Indicate if the queueable is ready to run
@@ -22,10 +22,15 @@ class Queueable {
     next = null,
     ready = false
   } = {}) {
+    /** The task (or data) this queueable holds. */
     this.data = null
+    /** The queueable after this one, or null when this is the last. */
     this.next = null
+    /** Whether this queueable has been run to completion. */
     this.complete = false
+    /** Whether this queueable may run, or a function which answers that when asked. */
     this.ready = false
+    /** Whether this queueable is running right now. */
     this.running = false
     this.classType = Queueable
     this.data = task
@@ -58,7 +63,7 @@ class Queueable {
 
   /**
    * Set this queueable as completed.
-   * @param {Object} completeResponse
+   * @param {Object} [completeResponse={}] The result to report for the task.
    * @param {*} [completeResponse.success=true] Indicate when the task failed (use false) or give a success message
    * @param {*} [completeResponse.error=false] Indicate a task was error-free (use false) or give an error message
    * @param {*} [completeResponse.context=null] Provide additional data in the response
@@ -112,8 +117,8 @@ class Queueable {
  */
 exports.Queueable = Queueable
 Queueable.make = (queueable, classType = Queueable) => {
-  if (typeof queueable !== 'object') {
-    // It is not an object, so instantiate the Queueable with an element as the data
+  if (queueable === null || typeof queueable !== 'object') {
+    // It is not an object (or it is null), so instantiate the Queueable with an element as the data
     return new classType({
       task: queueable,
       ready: true
@@ -123,7 +128,7 @@ Queueable.make = (queueable, classType = Queueable) => {
     // Already valid Queueable, return as-is
     return queueable
   }
-  if (!queueable.task) {
+  if (!('task' in queueable)) {
     queueable = {
       task: queueable,
       ready: true
@@ -138,4 +143,4 @@ Queueable.make = (queueable, classType = Queueable) => {
  * @param {IsLinker} [classType=Queueable] Provide the type of IsLinker to use.
  * @returns {{head: Queueable, tail: Queueable}}
  */
-Queueable.fromArray = (values, classType = Queueable) => _Linker.Linker.fromArray(values, classType)
+Queueable.fromArray = (values = [], classType = Queueable) => _Linker.Linker.fromArray(values, classType)

package/dist/collections/queue/Queueable.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Queueable=void 0;var _Linker=require("../linked-list/Linker");class Queueable{constructor({task:e=null,next:t=null,ready:s=!1}={}){this.data=null,this.next=null,this.complete=!1,this.ready=!1,this.running=!1,this.classType=Queueable,this.data=e,this.next=t,this.complete=!1,this.ready=s,this.running=!1}get isReady(){return"function"==typeof this.ready?this.ready():this.ready}get task(){return"function"==typeof this.data?this.data:e=>"function"==typeof e?e({context:this.data}).context:this.data}markCompleted({success:e=!0,error:t=!1,context:s=null}={}){return this.complete=!0,this.running=!1,{success:e,error:t,context:s}}run(){return this.isReady?this.running?{success:!1,error:"Queued task is already running, possible missing 'complete' callback",context:this.data}:(this.running=!0,this.task(this.markCompleted.bind(this))):{success:!1,error:"Task is not ready",context:this.data}}}exports.Queueable=Queueable,Queueable.make=(e,t=Queueable)=>"object"!=typeof e?new t({task:e,ready:!0}):e.classType?e:(e.task||(e={task:e,ready:!0}),new t(e)),Queueable.fromArray=(e,t=Queueable)=>_Linker.Linker.fromArray(e,t);
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Queueable=void 0;var _Linker=require("../linked-list/Linker");class Queueable{constructor({task:e=null,next:t=null,ready:s=!1}={}){this.data=null,this.next=null,this.complete=!1,this.ready=!1,this.running=!1,this.classType=Queueable,this.data=e,this.next=t,this.complete=!1,this.ready=s,this.running=!1}get isReady(){return"function"==typeof this.ready?this.ready():this.ready}get task(){return"function"==typeof this.data?this.data:e=>"function"==typeof e?e({context:this.data}).context:this.data}markCompleted({success:e=!0,error:t=!1,context:s=null}={}){return this.complete=!0,this.running=!1,{success:e,error:t,context:s}}run(){return this.isReady?this.running?{success:!1,error:"Queued task is already running, possible missing 'complete' callback",context:this.data}:(this.running=!0,this.task(this.markCompleted.bind(this))):{success:!1,error:"Task is not ready",context:this.data}}}exports.Queueable=Queueable,Queueable.make=(e,t=Queueable)=>null===e||"object"!=typeof e?new t({task:e,ready:!0}):e.classType?e:("task"in e||(e={task:e,ready:!0}),new t(e)),Queueable.fromArray=(e=[],t=Queueable)=>_Linker.Linker.fromArray(e,t);

package/dist/collections/stack/Stack.d.ts

@@ -12,14 +12,15 @@ import { completeResponse } from '../../recipes/Runnable';
  * Store a collection of items which can only be inserted and removed from the top.
  */
 export declare class Stack {
+    /** The list which stores the stackables, the first is the top of the stack. */
     stackedList: IsArrayable<any>;
     private listClass;
     private stackableClass;
     /**
      * Instantiate the state with the starter stacked list.
-     * @param {Iterable|LinkedList} stackedList
-     * @param {IsArrayable} listClass
-     * @param {Stackable} stackableClass
+     * @param {Iterable|LinkedList} [stackedList=null] The list of stackables to start in this stack.
+     * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no stacked list is given.
+     * @param {Stackable} [stackableClass=Stackable] The class used to wrap stacked items.
      */
     constructor(stackedList?: IsArrayable<any>, listClass?: any, stackableClass?: typeof Stackable);
     /**

package/dist/collections/stack/Stack.js

@@ -19,9 +19,9 @@ var _LinkedList = require('../linked-list/LinkedList')
 class Stack {
   /**
    * Instantiate the state with the starter stacked list.
-   * @param {Iterable|LinkedList} stackedList
-   * @param {IsArrayable} listClass
-   * @param {Stackable} stackableClass
+   * @param {Iterable|LinkedList} [stackedList=null] The list of stackables to start in this stack.
+   * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no stacked list is given.
+   * @param {Stackable} [stackableClass=Stackable] The class used to wrap stacked items.
    */
   constructor (stackedList = null, listClass = _LinkedList.LinkedList, stackableClass = _Stackable.Stackable) {
     this.listClass = listClass
@@ -102,5 +102,5 @@ exports.Stack = Stack
 Stack.fromArray = (values = [], stackableClass = _Stackable.Stackable, listClass = _LinkedList.LinkedList) => {
   const list = new listClass(stackableClass)
   list.initialize(stackableClass.fromArray(values, stackableClass).head)
-  return new Stack(list)
+  return new Stack(list, listClass, stackableClass)
 }

package/dist/collections/stack/Stack.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Stack=void 0;var _Stackable=require("./Stackable"),_LinkedList=require("../linked-list/LinkedList");class Stack{constructor(t=null,e=_LinkedList.LinkedList,s=_Stackable.Stackable){this.listClass=e,this.stackableClass=s,null===t&&(t=new e(s)),this.stackedList=t}empty(){return this.size()<=0}top(){return this.stackedList.first}pop(){const t=this.remove();return t?t.run():{success:"No more stackable tasks in the stack",error:!1,context:this.stackedList}}push(t){this.stackedList.prepend(t)}remove(){return this.empty()?null:this.stackedList.remove(this.stackedList.first)}size(){return this.stackedList.length}}exports.Stack=Stack,Stack.fromArray=(t=[],e=_Stackable.Stackable,s=_LinkedList.LinkedList)=>{const i=new s(e);return i.initialize(e.fromArray(t,e).head),new Stack(i)};
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Stack=void 0;var _Stackable=require("./Stackable"),_LinkedList=require("../linked-list/LinkedList");class Stack{constructor(t=null,e=_LinkedList.LinkedList,s=_Stackable.Stackable){this.listClass=e,this.stackableClass=s,null===t&&(t=new e(s)),this.stackedList=t}empty(){return this.size()<=0}top(){return this.stackedList.first}pop(){const t=this.remove();return t?t.run():{success:"No more stackable tasks in the stack",error:!1,context:this.stackedList}}push(t){this.stackedList.prepend(t)}remove(){return this.empty()?null:this.stackedList.remove(this.stackedList.first)}size(){return this.stackedList.length}}exports.Stack=Stack,Stack.fromArray=(t=[],e=_Stackable.Stackable,s=_LinkedList.LinkedList)=>{const i=new s(e);return i.initialize(e.fromArray(t,e).head),new Stack(i,s,e)};

package/dist/collections/stack/Stackable.d.ts

@@ -11,12 +11,15 @@ import { IsLinker } from '../../recipes/IsLinker';
  * @extends Linker
  */
 export declare class Stackable implements IsLinker, IsRunnable {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     readonly classType: typeof Stackable;
+    /** The task (or data) this stackable holds. */
     data: any;
+    /** The stackable below this one, or null when this is the bottom. */
     next: Stackable | null;
     /**
      * Create a stackable item that can be used in a stack.
-     * @param {Object} [stackData={}]
+     * @param {Object} [stackData={}] The settings for the new stackable.
      * @param {*} [stackData.task=null] The data to be stored in this stackable
      * @param {Stackable|null} [stackData.next=null] The reference to the next stackable if any
      * @param {boolean|Function} [stackData.ready=false] Indicate if the stackable is ready to run

package/dist/collections/stack/Stackable.js

@@ -12,7 +12,7 @@ var _Linker = require('../linked-list/Linker')
 class Stackable {
   /**
    * Create a stackable item that can be used in a stack.
-   * @param {Object} [stackData={}]
+   * @param {Object} [stackData={}] The settings for the new stackable.
    * @param {*} [stackData.task=null] The data to be stored in this stackable
    * @param {Stackable|null} [stackData.next=null] The reference to the next stackable if any
    * @param {boolean|Function} [stackData.ready=false] Indicate if the stackable is ready to run
@@ -22,7 +22,9 @@ class Stackable {
     next = null,
     ready = false
   } = {}) {
+    /** The task (or data) this stackable holds. */
     this.data = null
+    /** The stackable below this one, or null when this is the bottom. */
     this.next = null
     this.classType = Stackable
     this.data = task
@@ -56,8 +58,8 @@ class Stackable {
  */
 exports.Stackable = Stackable
 Stackable.make = (stackable, classType = Stackable) => {
-  if (typeof stackable !== 'object') {
-    // It is not an object, so instantiate the Stackable with stackable as the data
+  if (stackable === null || typeof stackable !== 'object') {
+    // It is not an object (or it is null), so instantiate the Stackable with stackable as the data
     return new classType({
       task: stackable
     })
@@ -66,13 +68,13 @@ Stackable.make = (stackable, classType = Stackable) => {
     // Already valid Stackable, return as-is
     return stackable
   }
-  if (!stackable.task) {
+  if (!('task' in stackable)) {
     stackable = {
       task: stackable
     }
   }
   // Create the new node as the configured stackableClass
-  return new Stackable(stackable)
+  return new classType(stackable)
 }
 /**
  * Convert an array into Stackable instances, return the head and tail Stackables.

package/dist/collections/stack/Stackable.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Stackable=void 0;var _Linker=require("../linked-list/Linker");class Stackable{constructor({task:t=null,next:a=null,ready:e=!1}={}){this.data=null,this.next=null,this.classType=Stackable,this.data=t,this.next=a}get task(){return"function"==typeof this.data?this.data:()=>this.data}run(){return this.task()}}exports.Stackable=Stackable,Stackable.make=(t,a=Stackable)=>"object"!=typeof t?new a({task:t}):t.classType?t:(t.task||(t={task:t}),new Stackable(t)),Stackable.fromArray=(t=[],a=Stackable)=>_Linker.Linker.fromArray(t,a);
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Stackable=void 0;var _Linker=require("../linked-list/Linker");class Stackable{constructor({task:t=null,next:a=null,ready:e=!1}={}){this.data=null,this.next=null,this.classType=Stackable,this.data=t,this.next=a}get task(){return"function"==typeof this.data?this.data:()=>this.data}run(){return this.task()}}exports.Stackable=Stackable,Stackable.make=(t,a=Stackable)=>null===t||"object"!=typeof t?new a({task:t}):t.classType?t:("task"in t||(t={task:t}),new a(t)),Stackable.fromArray=(t=[],a=Stackable)=>_Linker.Linker.fromArray(t,a);