collect-your-stuff 2.1.1 → 2.2.0

package/dist/collections/queue/Queue.js

@@ -1,119 +1,114 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.Queue = void 0
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.for-each.js')
-var _LinkedList = require('../linked-list/LinkedList')
-var _Linker = require('../linked-list/Linker')
-/**
- * @file queue
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 2.0.0
- * @memberOf module:collect-your-stuff
- */
-
-/**
- * A first-in-first-out collection: items are added to the back with enqueue and taken from the front with dequeue.
- * Any value can be queued (it is stored as it is, whether it is a function, an object or null), and adding and taking
- * are constant time. To queue tasks which are run as they are taken use TaskQueue.
- */
-class Queue {
-  /**
-   * Instantiate the queue, optionally with a list of items to start from.
-   * @param {IsArrayable|null} [queuedList=null] The list of linkers to start in this queue (the first is the front)
-   * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no queued list is given
-   * @param {Linker} [linkerClass=Linker] The class used to hold each queued item
-   */
-  constructor (queuedList = null, listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) {
-    this.linkerClass = linkerClass
-    this.queuedList = queuedList === null ? new listClass(linkerClass) : queuedList
-  }
-
-  /**
-   * Take the item from the front of the queue.
-   * @return {*|null} The item, or null when the queue is empty
-   */
-  dequeue () {
-    const front = this.queuedList.first
-    if (front === null || typeof front === 'undefined') {
-      return null
-    }
-    this.queuedList.remove(front)
-    return front.data
-  }
-
-  /**
-   * Check whether the queue has no items.
-   * @return {boolean}
-   */
-  empty () {
-    return this.size() <= 0
-  }
-
-  /**
-   * Add an item to the back of the queue.
-   * @param {*} data The item to add
-   * @return {Queue} This queue, so that adding can be chained
-   */
-  enqueue (data) {
-    // The item is wrapped here rather than left to the list, since the list treats objects that look like a linker's
-    // settings (they have a data property) as such, and a queue must give back exactly what it was given
-    this.queuedList.append(new this.linkerClass({
-      data
-    }))
-    return this
-  }
-
-  /**
-   * Look at the item at the front of the queue, without removing it.
-   * @return {*|null} The item, or null when the queue is empty
-   */
-  peek () {
-    const front = this.queuedList.first
-    return front === null || typeof front === 'undefined' ? null : front.data
-  }
-
-  /**
-   * Count the items in the queue.
-   * @return {number}
-   */
-  size () {
-    return this.queuedList.length
-  }
-
-  /**
-   * Iterate over the items from the front of the queue to the back, without removing them.
-   * @return {Iterator}
-   */
-  [Symbol.iterator] () {
-    const linkers = this.queuedList[Symbol.iterator]()
-    return {
-      next: () => {
-        const result = linkers.next()
-        return result.done ? {
-          done: true,
-          value: undefined
-        } : {
-          done: false,
-          value: result.value.data
-        }
-      }
-    }
-  }
-}
-/**
- * Convert an array to a Queue, the first value is at the front.
- * @param {Array} [values=[]] The items to queue
- * @param {IsArrayable} [listClass=LinkedList] The type of list used to store the items
- * @param {Linker} [linkerClass=Linker] The class used to hold each queued item
- * @returns {Queue}
- */
-exports.Queue = Queue
-Queue.fromArray = (values = [], listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) => {
-  const queue = new Queue(null, listClass, linkerClass)
-  values.forEach(value => queue.enqueue(value))
-  return queue
-}
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.Queue = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.for-each.js')
+const _LinkedList = require('../linked-list/LinkedList')
+const _Linker = require('../linked-list/Linker')
+/**
+ * queue
+ */
+
+/**
+ * A first-in-first-out collection: items are added to the back with enqueue and taken from the front with dequeue.
+ * Any value can be queued (it is stored as it is, whether it is a function, an object or null), and adding and taking
+ * are constant time. To queue tasks which are run as they are taken use TaskQueue.
+ */
+class Queue {
+  /**
+   * Instantiate the queue, optionally with a list of items to start from.
+   * @param queuedList The list of linkers to start in this queue (the first is the front)
+   * @param listClass The type of list to create when no queued list is given
+   * @param linkerClass The class used to hold each queued item
+   */
+  constructor (queuedList = null, listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) {
+    this.linkerClass = linkerClass
+    this.queuedList = queuedList === null ? new listClass(linkerClass) : queuedList
+  }
+
+  /**
+   * Take the item from the front of the queue.
+   * @returns The item, or null when the queue is empty
+   */
+  dequeue () {
+    const front = this.queuedList.first
+    if (front === null || typeof front === 'undefined') {
+      return null
+    }
+    this.queuedList.remove(front)
+    return front.data
+  }
+
+  /**
+   * Check whether the queue has no items.
+   */
+  empty () {
+    return this.size() <= 0
+  }
+
+  /**
+   * Add an item to the back of the queue.
+   * @param data The item to add
+   * @returns This queue, so that adding can be chained
+   */
+  enqueue (data) {
+    // The item is wrapped here rather than left to the list, since the list treats objects that look like a linker's
+    // settings (they have a data property) as such, and a queue must give back exactly what it was given
+    this.queuedList.append(new this.linkerClass({
+      data
+    }))
+    return this
+  }
+
+  /**
+   * Look at the item at the front of the queue, without removing it.
+   * @returns The item, or null when the queue is empty
+   */
+  peek () {
+    const front = this.queuedList.first
+    return front === null || typeof front === 'undefined' ? null : front.data
+  }
+
+  /**
+   * Count the items in the queue.
+   */
+  size () {
+    return this.queuedList.length
+  }
+
+  /**
+   * Iterate over the items from the front of the queue to the back, without removing them.
+   */
+  [Symbol.iterator] () {
+    const linkers = this.queuedList[Symbol.iterator]()
+    return {
+      next: () => {
+        const result = linkers.next()
+        return result.done
+          ? {
+              done: true,
+              value: undefined
+            }
+          : {
+              done: false,
+              value: result.value.data
+            }
+      }
+    }
+  }
+}
+/**
+ * Convert an array to a Queue, the first value is at the front.
+ * @param values The items to queue
+ * @param listClass The type of list used to store the items
+ * @param linkerClass The class used to hold each queued item
+ */
+exports.Queue = Queue
+Queue.fromArray = (values = [], listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) => {
+  const queue = new Queue(null, listClass, linkerClass)
+  values.forEach(value => queue.enqueue(value))
+  return queue
+}

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

@@ -1,83 +1,74 @@
-/**
- * @file queueable item.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { completeResponse, IsRunnable } from '../../recipes/Runnable';
-import { IsLinker } from '../../recipes/IsLinker';
-/**
- * Queueable represents a runnable entry in a queue.
- * @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={}] 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
-     */
-    constructor({ task, next, ready }?: {
-        task?: any;
-        next?: Queueable | null;
-        ready?: boolean | Function;
-    });
-    /**
-     * Check ready state.
-     * @return {boolean}
-     */
-    get isReady(): boolean;
-    /**
-     * Retrieve the data which should be formed as a task.
-     * @return {*}
-     */
-    get task(): any;
-    /**
-     * Set this queueable as completed.
-     * @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
-     * @return {completeResponse}
-     */
-    markCompleted({ success, error, context }?: {
-        success?: any;
-        error?: any;
-        context?: any;
-    }): completeResponse;
-    /**
-     * Intend to run the queued task when it is ready. If ready, mark this task as running and run the task.
-     * @return {completeResponse}
-     */
-    run(): completeResponse;
-    /**
-     * Make a new Queueable from the data given if it is not already a valid Queueable.
-     * @param {Queueable|*} queueable Return a valid Queueable instance from given data, or even an already valid one.
-     * @param {IsLinker} [classType=Queueable] Provide the type of IsLinker to use.
-     * @return {Queueable}
-     */
-    static make: (queueable: Queueable | any, classType?: any) => IsLinker;
-    /**
-     * Convert an array into Queueable instances, return the head and tail Queueables.
-     * @param {Array} values Provide an array of data that will be converted to a chain of queueable linkers.
-     * @param {IsLinker} [classType=Queueable] Provide the type of IsLinker to use.
-     * @returns {{head: Queueable, tail: Queueable}}
-     */
-    static fromArray: (values?: Array<any>, classType?: any) => {
-        head: IsLinker;
-        tail: IsLinker;
-    };
-}
+/**
+ * queueable item.
+ */
+import { completeResponse, IsRunnable } from '../../recipes/Runnable';
+import { IsLinker } from '../../recipes/IsLinker';
+/**
+ * Queueable represents a runnable entry in a queue.
+ * @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 queueableData The settings for the new queueable.
+     * @param queueableData.task The data to be stored in this queueable
+     * @param queueableData.next The reference to the next queueable if any
+     * @param queueableData.ready Indicate if the queueable is ready to run
+     */
+    constructor({ task, next, ready }?: {
+        task?: any;
+        next?: Queueable | null;
+        ready?: boolean | Function;
+    });
+    /**
+     * Check ready state.
+     */
+    get isReady(): boolean;
+    /**
+     * Retrieve the data which should be formed as a task.
+     */
+    get task(): any;
+    /**
+     * Set this queueable as completed.
+     * @param completeResponse The result to report for the task.
+     * @param completeResponse.success Indicate when the task failed (use false) or give a success message
+     * @param completeResponse.error Indicate a task was error-free (use false) or give an error message
+     * @param completeResponse.context Provide additional data in the response
+     */
+    markCompleted({ success, error, context }?: {
+        success?: any;
+        error?: any;
+        context?: any;
+    }): completeResponse;
+    /**
+     * Intend to run the queued task when it is ready. If ready, mark this task as running and run the task.
+     */
+    run(): completeResponse;
+    /**
+     * Make a new Queueable from the data given if it is not already a valid Queueable.
+     * @param queueable Return a valid Queueable instance from given data, or even an already valid one.
+     * @param classType Provide the type of IsLinker to use.
+     */
+    static make: (queueable: Queueable | any, classType?: any) => IsLinker;
+    /**
+     * Convert an array into Queueable instances, return the head and tail Queueables.
+     * @param values Provide an array of data that will be converted to a chain of queueable linkers.
+     * @param classType Provide the type of IsLinker to use.
+     */
+    static fromArray: (values?: Array<any>, classType?: any) => {
+        head: IsLinker;
+        tail: IsLinker;
+    };
+}