collect-your-stuff 1.2.9 → 1.3.2

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

@@ -14,10 +14,14 @@ var _Arrayable = require('../arrayable/Arrayable')
 class LinkedList {
   /**
    * Create the new LinkedList instance.
+   * @param {Linker} [linkerClass=Linker] The class used to wrap given data as linkers.
    */
   constructor (linkerClass = _Linker.Linker) {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     this.classType = LinkedList
+    /** The first linker of the list (null when the list is empty), from which the whole list is reached. */
     this.innerList = null
+    /** Whether the inner list has been initialized (it can only be initialized once). */
     this.initialized = false
     this.linkerClass = linkerClass
   }
@@ -28,11 +32,12 @@ class LinkedList {
    * @return {LinkedList}
    */
   initialize (initialList) {
+    // Borrowed from Arrayable, which types its return as an Arrayable although it returns whatever list called it
     return _Arrayable.Arrayable.prototype.initialize.call(this, initialList)
   }
 
   /**
-   * Retrieve a copy of the innerList used.
+   * Retrieve the innerList used (the list itself, not a copy).
    * @returns {Linker}
    */
   get list () {
@@ -80,45 +85,55 @@ class LinkedList {
 
   /**
    * Insert a new node (or data) after a node.
-   * @param {Linker|*} node The existing node as reference
+   * @param {Linker|*} node The existing node as reference, or null to insert at the start of the list
    * @param {Linker|*} newNode The new node to go after the existing node
    * @returns {LinkedList}
    */
   insertAfter (node, newNode) {
-    newNode = this.linkerClass.make(newNode)
-    if (node !== null) {
-      // Ensure the next reference of this node is assigned to the new node
-      newNode.next = node.next
-      // Then set this node's next reference to the new node
-      node.next = newNode
-    }
-    if (!this.length) {
+    newNode = this.linkerClass.make(newNode, this.linkerClass)
+    if (node === null || typeof node === 'undefined') {
+      // After nothing means at the start of the list
+      newNode.next = this.innerList
       this.innerList = newNode
+      return this
     }
+    newNode.next = node.next
+    node.next = newNode
     return this
   }
 
   /**
    * Insert a new node (or data) before a node.
-   * @param {Linker|*} node The existing node as reference
+   * @param {Linker|*} node The existing node as reference, or null to insert at the end of the list
    * @param {Linker|*} newNode The new node to go before the existing node
    * @returns {LinkedList}
+   * @throws {Error} When the reference node is not in this list
    */
   insertBefore (node, newNode) {
-    newNode = this.linkerClass.make(newNode)
+    newNode = this.linkerClass.make(newNode, this.linkerClass)
+    if (node === null || typeof node === 'undefined') {
+      // Before nothing means at the end of the list
+      const tail = this.last
+      if (tail === null) {
+        this.innerList = newNode
+      } else {
+        tail.next = newNode
+      }
+      return this
+    }
     let prevNode = null
     let currentNode = this.first
-    while (currentNode !== node) {
+    while (currentNode !== null && currentNode !== node) {
       prevNode = currentNode
       currentNode = currentNode.next
     }
-    // The new node will reference this node as next
+    if (currentNode === null) {
+      throw new Error('The reference node is not in this list.')
+    }
     newNode.next = node
     if (prevNode) {
-      // Ensure the next reference of the previous node is assigned to the new node
       prevNode.next = newNode
-    }
-    if (node === this.first || node === null) {
+    } else {
       this.innerList = newNode
     }
     return this
@@ -147,21 +162,25 @@ class LinkedList {
   /**
    * Remove a linker from this linked list.
    * @param {Linker} node The node we wish to remove (and it will be returned after removal)
-   * @return {Linker}
+   * @return {Linker|null} The removed node, or null when it was not in this list (nothing is removed)
    */
   remove (node) {
+    if (node === null || typeof node === 'undefined') {
+      return null
+    }
     let prevNode = null
     let currentNode = this.first
-    while (currentNode !== node) {
+    while (currentNode !== null && currentNode !== node) {
       prevNode = currentNode
       currentNode = currentNode.next
     }
+    if (currentNode === null) {
+      // The node is not in this list, so there is nothing to remove
+      return null
+    }
     if (prevNode) {
-      // Ensure the next reference of the previous node skips over the removed node
       prevNode.next = node.next
-    }
-    if (node === this.first && node !== null) {
-      // Update list head to point to next if it was this node
+    } else {
       this.innerList = node.next
     }
     return node

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LinkedList=void 0;var _Linker=require("./Linker"),_LinkerIterator=require("../../recipes/LinkerIterator"),_Arrayable=require("../arrayable/Arrayable");class LinkedList{constructor(t=_Linker.Linker){this.classType=LinkedList,this.innerList=null,this.initialized=!1,this.linkerClass=t}initialize(t){return _Arrayable.Arrayable.prototype.initialize.call(this,t)}get list(){return this.innerList}get first(){return this.innerList}get last(){let t=this.innerList;if(null===t)return null;let e=t.next;for(;null!==e;)t=e,e=t.next;return t}get length(){let t=this.first,e=0;for(;null!==t;)++e,t=t.next;return e}insertAfter(t,e){return e=this.linkerClass.make(e),null!==t&&(e.next=t.next,t.next=e),this.length||(this.innerList=e),this}insertBefore(t,e){e=this.linkerClass.make(e);let r=null,i=this.first;for(;i!==t;)r=i,i=i.next;return e.next=t,r&&(r.next=e),t!==this.first&&null!==t||(this.innerList=e),this}append(t,e=this.last){return this.insertAfter(e,t)}prepend(t,e=this.first){return this.insertBefore(e,t)}remove(t){let e=null,r=this.first;for(;r!==t;)e=r,r=r.next;return e&&(e.next=t.next),t===this.first&&null!==t&&(this.innerList=t.next),t}item(t){if(t>=0){let e=this.first,r=-1;for(;++r<t&&null!==e;)e=e.next;return r===t?e:null}let e=this.first,r=0;const i=this.length+t;if(i<0)return null;for(;r<i&&null!==e;)e=e.next,++r;return r===i?e:null}forEach(t,e=this){let r=0,i=e.first;for(;null!==i;)t(i,r,e),i=i.next,++r;return e}[Symbol.iterator](){return new _LinkerIterator.LinkerIterator(this.first)}}exports.LinkedList=LinkedList,LinkedList.fromArray=(t=[],e=_Linker.Linker,r=LinkedList)=>new r(e).initialize(e.fromArray(t).head);
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LinkedList=void 0;var _Linker=require("./Linker"),_LinkerIterator=require("../../recipes/LinkerIterator"),_Arrayable=require("../arrayable/Arrayable");class LinkedList{constructor(t=_Linker.Linker){this.classType=LinkedList,this.innerList=null,this.initialized=!1,this.linkerClass=t}initialize(t){return _Arrayable.Arrayable.prototype.initialize.call(this,t)}get list(){return this.innerList}get first(){return this.innerList}get last(){let t=this.innerList;if(null===t)return null;let e=t.next;for(;null!==e;)t=e,e=t.next;return t}get length(){let t=this.first,e=0;for(;null!==t;)++e,t=t.next;return e}insertAfter(t,e){return e=this.linkerClass.make(e,this.linkerClass),null==t?(e.next=this.innerList,this.innerList=e,this):(e.next=t.next,t.next=e,this)}insertBefore(t,e){if(e=this.linkerClass.make(e,this.linkerClass),null==t){const t=this.last;return null===t?this.innerList=e:t.next=e,this}let r=null,i=this.first;for(;null!==i&&i!==t;)r=i,i=i.next;if(null===i)throw new Error("The reference node is not in this list.");return e.next=t,r?r.next=e:this.innerList=e,this}append(t,e=this.last){return this.insertAfter(e,t)}prepend(t,e=this.first){return this.insertBefore(e,t)}remove(t){if(null==t)return null;let e=null,r=this.first;for(;null!==r&&r!==t;)e=r,r=r.next;return null===r?null:(e?e.next=t.next:this.innerList=t.next,t)}item(t){if(t>=0){let e=this.first,r=-1;for(;++r<t&&null!==e;)e=e.next;return r===t?e:null}let e=this.first,r=0;const i=this.length+t;if(i<0)return null;for(;r<i&&null!==e;)e=e.next,++r;return r===i?e:null}forEach(t,e=this){let r=0,i=e.first;for(;null!==i;)t(i,r,e),i=i.next,++r;return e}[Symbol.iterator](){return new _LinkerIterator.LinkerIterator(this.first)}}exports.LinkedList=LinkedList,LinkedList.fromArray=(t=[],e=_Linker.Linker,r=LinkedList)=>new r(e).initialize(e.fromArray(t).head);

package/dist/collections/linked-list/Linker.d.ts

@@ -10,12 +10,15 @@ import { IsLinker } from '../../recipes/IsLinker';
  * @extends ArrayElement
  */
 export declare class Linker implements IsLinker {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
     readonly classType: typeof Linker;
+    /** The data stored in this linker. */
     data: any;
+    /** The linker after this one, or null when this is the last. */
     next: Linker | null;
     /**
      * 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
      */
@@ -36,7 +39,7 @@ export declare class Linker implements IsLinker {
      * @param {IsLinker} [classType=Linker] Provide the type of IsLinker to use.
      * @returns {{head: Linker, tail: Linker}}
      */
-    static fromArray: (values: Array<any>, classType?: any) => {
+    static fromArray: (values?: Array<any>, classType?: any) => {
         head: IsLinker;
         tail: IsLinker;
     };

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,17 @@ 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;
     /**
      * 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 +33,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;
@@ -117,6 +122,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

@@ -21,10 +21,14 @@ 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
     this.linkerClass = linkerClass
   }
@@ -45,7 +49,7 @@ class LinkedTreeList {
   }
 
   /**
-   * Retrieve a copy of the innerList used.
+   * Retrieve the innerList used (the list itself, not a copy).
    * @returns {TreeLinker}
    */
   get list () {
@@ -217,6 +221,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/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