collect-your-stuff 1.2.7 → 1.2.8

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

@@ -1,79 +1,79 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.TreeLinker = void 0
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.map.js')
-var _DoubleLinker = require('../doubly-linked-list/DoubleLinker')
-var _LinkedTreeList = require('./LinkedTreeList')
-/**
- * TreeLinker represents a node in a LinkedTreeList having a parent (or root) and child nodes.
- * @extends DoubleLinker
- */
-class TreeLinker {
-  /**
-   * Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
-   * @param {Object} [settings={}]
-   * @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
-   * @param {LinkedTreeList} [settings.children=null] The references to child linkers if any
-   * @param {TreeLinker} [settings.parent=null] The reference to a parent linker if any
-   * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
-   */
-  constructor ({
-    data = null,
-    next = null,
-    prev = null,
-    children = null,
-    parent = null,
-    listClass = _LinkedTreeList.LinkedTreeList
-  } = {}) {
-    this.classType = TreeLinker
-    this.data = null
-    this.next = null
-    this.prev = null
-    this.parent = null
-    this.children = null
-    this.data = data
-    this.next = next
-    this.prev = prev
-    this.parent = parent
-    this.children = this.childrenFromArray(children, listClass)
-  }
-
-  /**
-   * Create the children for this tree from an array.
-   * @param {Array|null} children Provide an array of data / linker references to be children of this tree node.
-   * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
-   * @return {LinkedTreeList|null}
-   */
-  childrenFromArray (children = null, listClass = _LinkedTreeList.LinkedTreeList) {
-    if (children === null) {
-      return null
-    }
-    // Creates a linked-tree-list to store the children.
-    return listClass.fromArray(children.map(child => Object.assign({}, child, {
-      parent: this
-    })), this.classType)
-  }
-}
-/**
- * Make a new DoubleLinker from the data given if it is not already a valid Linker.
- * @param {TreeLinker|*} linker Return a valid TreeLinker instance from given data, or even an already valid one.
- * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
- * @return {TreeLinker}
- */
-exports.TreeLinker = TreeLinker
-TreeLinker.make = (linker, classType = TreeLinker) => {
-  return _DoubleLinker.DoubleLinker.make(linker, classType)
-}
-/**
- * Convert an array into DoubleLinker instances, return the head and tail DoubleLinkers.
- * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of tree-linkers.
- * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
- * @returns {{head: TreeLinker, tail: TreeLinker}}
- */
-TreeLinker.fromArray = (values = [], classType = TreeLinker) => _DoubleLinker.DoubleLinker.fromArray(values, classType)
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.TreeLinker = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.map.js')
+var _DoubleLinker = require('../doubly-linked-list/DoubleLinker')
+var _LinkedTreeList = require('./LinkedTreeList')
+/**
+ * TreeLinker represents a node in a LinkedTreeList having a parent (or root) and child nodes.
+ * @extends DoubleLinker
+ */
+class TreeLinker {
+  /**
+   * Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
+   * @param {Object} [settings={}]
+   * @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
+   * @param {LinkedTreeList} [settings.children=null] The references to child linkers if any
+   * @param {TreeLinker} [settings.parent=null] The reference to a parent linker if any
+   * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
+   */
+  constructor ({
+    data = null,
+    next = null,
+    prev = null,
+    children = null,
+    parent = null,
+    listClass = _LinkedTreeList.LinkedTreeList
+  } = {}) {
+    this.classType = TreeLinker
+    this.data = null
+    this.next = null
+    this.prev = null
+    this.parent = null
+    this.children = null
+    this.data = data
+    this.next = next
+    this.prev = prev
+    this.parent = parent
+    this.children = this.childrenFromArray(children, listClass)
+  }
+
+  /**
+   * Create the children for this tree from an array.
+   * @param {Array|null} children Provide an array of data / linker references to be children of this tree node.
+   * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
+   * @return {LinkedTreeList|null}
+   */
+  childrenFromArray (children = null, listClass = _LinkedTreeList.LinkedTreeList) {
+    if (children === null) {
+      return null
+    }
+    // Creates a linked-tree-list to store the children.
+    return listClass.fromArray(children.map(child => Object.assign({}, child, {
+      parent: this
+    })), this.classType)
+  }
+}
+/**
+ * Make a new DoubleLinker from the data given if it is not already a valid Linker.
+ * @param {TreeLinker|*} linker Return a valid TreeLinker instance from given data, or even an already valid one.
+ * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
+ * @return {TreeLinker}
+ */
+exports.TreeLinker = TreeLinker
+TreeLinker.make = (linker, classType = TreeLinker) => {
+  return _DoubleLinker.DoubleLinker.make(linker, classType)
+}
+/**
+ * Convert an array into DoubleLinker instances, return the head and tail DoubleLinkers.
+ * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of tree-linkers.
+ * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
+ * @returns {{head: TreeLinker, tail: TreeLinker}}
+ */
+TreeLinker.fromArray = (values = [], classType = TreeLinker) => _DoubleLinker.DoubleLinker.fromArray(values, classType)

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

@@ -1,63 +1,63 @@
-/**
- * @file queue
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { Queueable } from './Queueable';
-import { IsArrayable } from '../../recipes/IsArrayable';
-import { IsLinker } from '../../recipes/IsLinker';
-import { completeResponse } from '../../recipes/Runnable';
-/**
- * Maintain a series of queued items.
- */
-export declare class Queue {
-    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
-     */
-    constructor(queuedList?: IsArrayable<any>, listClass?: any, queueableClass?: typeof Queueable);
-    /**
-     * Take a queued task from the front of the queue and run it if ready.
-     * @return {completeResponse|*}
-     */
-    dequeue(): completeResponse | any;
-    /**
-     * Return true if the queue is empty (there are no tasks in the queue list)
-     * @return {boolean}
-     */
-    empty(): boolean;
-    /**
-     * Add a queued task to the end of the queue
-     * @param {Queueable} queueable Add a new queueable to the end of the queue
-     */
-    enqueue(queueable: Queueable): void;
-    /**
-     * Take a look at the next queued task
-     * @return {Queueable}
-     */
-    peek(): IsLinker;
-    /**
-     * Remove the next queued item and return it.
-     * @return {Queueable|null}
-     */
-    remove(): Queueable | null;
-    /**
-     * Get the length of the current queue.
-     * @return {number}
-     */
-    size(): number;
-    /**
-     * Convert an array to a Queue.
-     * @param {Array} values An array of values which will be converted to queueables in this queue
-     * @param {Queueable} queueableClass The class to use for each queueable
-     * @param {Queue|Iterable} listClass The class to use to manage the queueables
-     * @returns {Queue}
-     */
-    static fromArray: (values?: Array<any>, queueableClass?: typeof Queueable, listClass?: any) => Queue;
-}
+/**
+ * @file queue
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+import { Queueable } from './Queueable';
+import { IsArrayable } from '../../recipes/IsArrayable';
+import { IsLinker } from '../../recipes/IsLinker';
+import { completeResponse } from '../../recipes/Runnable';
+/**
+ * Maintain a series of queued items.
+ */
+export declare class Queue {
+    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
+     */
+    constructor(queuedList?: IsArrayable<any>, listClass?: any, queueableClass?: typeof Queueable);
+    /**
+     * Take a queued task from the front of the queue and run it if ready.
+     * @return {completeResponse|*}
+     */
+    dequeue(): completeResponse | any;
+    /**
+     * Return true if the queue is empty (there are no tasks in the queue list)
+     * @return {boolean}
+     */
+    empty(): boolean;
+    /**
+     * Add a queued task to the end of the queue
+     * @param {Queueable} queueable Add a new queueable to the end of the queue
+     */
+    enqueue(queueable: Queueable): void;
+    /**
+     * Take a look at the next queued task
+     * @return {Queueable}
+     */
+    peek(): IsLinker;
+    /**
+     * Remove the next queued item and return it.
+     * @return {Queueable|null}
+     */
+    remove(): Queueable | null;
+    /**
+     * Get the length of the current queue.
+     * @return {number}
+     */
+    size(): number;
+    /**
+     * Convert an array to a Queue.
+     * @param {Array} values An array of values which will be converted to queueables in this queue
+     * @param {Queueable} queueableClass The class to use for each queueable
+     * @param {Queue|Iterable} listClass The class to use to manage the queueables
+     * @returns {Queue}
+     */
+    static fromArray: (values?: Array<any>, queueableClass?: typeof Queueable, listClass?: any) => Queue;
+}

package/dist/collections/queue/Queue.js

@@ -1,130 +1,130 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.Queue = void 0
-var _Queueable = require('./Queueable')
-var _LinkedList = require('../linked-list/LinkedList')
-/**
- * @file queue
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-
-/**
- * Maintain a series of queued items.
- */
-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
-   */
-  constructor (queuedList = null, listClass = _LinkedList.LinkedList, queueableClass = _Queueable.Queueable) {
-    this.listClass = listClass
-    this.queueableClass = queueableClass
-    if (queuedList === null) {
-      queuedList = new listClass(queueableClass)
-    }
-    this.queuedList = queuedList
-  }
-
-  /**
-   * Take a queued task from the front of the queue and run it if ready.
-   * @return {completeResponse|*}
-   */
-  dequeue () {
-    const next = this.remove()
-    if (!next) {
-      return {
-        success: 'No more queueable tasks in the queue',
-        error: false,
-        context: this.queuedList
-      }
-    }
-    if (next.complete) {
-      // Previously ran queued, run next
-      return this.dequeue()
-    }
-    if (next.running) {
-      return {
-        success: false,
-        error: 'The queue has been blocked by an unfinished 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 true if the queue is empty (there are no tasks in the queue list)
-   * @return {boolean}
-   */
-  empty () {
-    return this.size() <= 0
-  }
-
-  /**
-   * Add a queued task to the end of the queue
-   * @param {Queueable} queueable Add a new queueable to the end of the queue
-   */
-  enqueue (queueable) {
-    this.queuedList.append(queueable)
-  }
-
-  /**
-   * Take a look at the next queued task
-   * @return {Queueable}
-   */
-  peek () {
-    return this.queuedList.first
-  }
-
-  /**
-   * Remove the next queued item and return it.
-   * @return {Queueable|null}
-   */
-  remove () {
-    if (this.empty()) {
-      return null
-    }
-    return this.queuedList.remove(this.queuedList.first)
-  }
-
-  /**
-   * Get the length of the current queue.
-   * @return {number}
-   */
-  size () {
-    return this.queuedList.length
-  }
-}
-/**
- * Convert an array to a Queue.
- * @param {Array} values An array of values which will be converted to queueables in this queue
- * @param {Queueable} queueableClass The class to use for each queueable
- * @param {Queue|Iterable} listClass The class to use to manage the queueables
- * @returns {Queue}
- */
-exports.Queue = Queue
-Queue.fromArray = (values = [], queueableClass = _Queueable.Queueable, listClass = _LinkedList.LinkedList) => {
-  const list = new listClass(queueableClass)
-  list.initialize(queueableClass.fromArray(values, queueableClass).head)
-  return new Queue(list, listClass, queueableClass)
-}
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.Queue = void 0
+var _Queueable = require('./Queueable')
+var _LinkedList = require('../linked-list/LinkedList')
+/**
+ * @file queue
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+
+/**
+ * Maintain a series of queued items.
+ */
+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
+   */
+  constructor (queuedList = null, listClass = _LinkedList.LinkedList, queueableClass = _Queueable.Queueable) {
+    this.listClass = listClass
+    this.queueableClass = queueableClass
+    if (queuedList === null) {
+      queuedList = new listClass(queueableClass)
+    }
+    this.queuedList = queuedList
+  }
+
+  /**
+   * Take a queued task from the front of the queue and run it if ready.
+   * @return {completeResponse|*}
+   */
+  dequeue () {
+    const next = this.remove()
+    if (!next) {
+      return {
+        success: 'No more queueable tasks in the queue',
+        error: false,
+        context: this.queuedList
+      }
+    }
+    if (next.complete) {
+      // Previously ran queued, run next
+      return this.dequeue()
+    }
+    if (next.running) {
+      return {
+        success: false,
+        error: 'The queue has been blocked by an unfinished 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 true if the queue is empty (there are no tasks in the queue list)
+   * @return {boolean}
+   */
+  empty () {
+    return this.size() <= 0
+  }
+
+  /**
+   * Add a queued task to the end of the queue
+   * @param {Queueable} queueable Add a new queueable to the end of the queue
+   */
+  enqueue (queueable) {
+    this.queuedList.append(queueable)
+  }
+
+  /**
+   * Take a look at the next queued task
+   * @return {Queueable}
+   */
+  peek () {
+    return this.queuedList.first
+  }
+
+  /**
+   * Remove the next queued item and return it.
+   * @return {Queueable|null}
+   */
+  remove () {
+    if (this.empty()) {
+      return null
+    }
+    return this.queuedList.remove(this.queuedList.first)
+  }
+
+  /**
+   * Get the length of the current queue.
+   * @return {number}
+   */
+  size () {
+    return this.queuedList.length
+  }
+}
+/**
+ * Convert an array to a Queue.
+ * @param {Array} values An array of values which will be converted to queueables in this queue
+ * @param {Queueable} queueableClass The class to use for each queueable
+ * @param {Queue|Iterable} listClass The class to use to manage the queueables
+ * @returns {Queue}
+ */
+exports.Queue = Queue
+Queue.fromArray = (values = [], queueableClass = _Queueable.Queueable, listClass = _LinkedList.LinkedList) => {
+  const list = new listClass(queueableClass)
+  list.initialize(queueableClass.fromArray(values, queueableClass).head)
+  return new Queue(list, listClass, queueableClass)
+}