collect-your-stuff 1.2.6 → 1.2.8

package/dist/collections/queue/Queueable.js

@@ -1,151 +1,141 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.Queueable = void 0
-var _Linker = require('../linked-list/Linker')
-/**
- * Queueable represents a runnable entry in a queue.
- * @extends Linker
- */
-class Queueable {
-  /**
-   * Create a queueable item that can be used in a queue.
-   * @param {Object} [queueableData={}]
-   * @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 () {
-    const _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}
-    const _ref$task = _ref.task
-    const task = _ref$task === void 0 ? null : _ref$task
-    const _ref$next = _ref.next
-    const next = _ref$next === void 0 ? null : _ref$next
-    const _ref$ready = _ref.ready
-    const ready = _ref$ready === void 0 ? false : _ref$ready
-    this.data = null
-    this.next = null
-    this.complete = false
-    this.ready = false
-    this.running = false
-    this.classType = Queueable
-    this.data = task
-    this.next = next
-    this.complete = false
-    this.ready = ready
-    this.running = false
-  }
-
-  /**
-   * Check ready state.
-   * @return {boolean}
-   */
-  get isReady () {
-    return typeof this.ready === 'function' ? this.ready() : this.ready
-  }
-
-  /**
-   * Retrieve the data which should be formed as a task.
-   * @return {*}
-   */
-  get task () {
-    if (typeof this.data === 'function') {
-      return this.data
-    }
-    return complete => typeof complete === 'function' ? complete({
-      context: this.data
-    }).context : this.data
-  }
-
-  /**
-   * Set this queueable as completed.
-   * @param {Object} completeResponse
-   * @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 () {
-    const _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}
-    const _ref2$success = _ref2.success
-    const success = _ref2$success === void 0 ? true : _ref2$success
-    const _ref2$error = _ref2.error
-    const error = _ref2$error === void 0 ? false : _ref2$error
-    const _ref2$context = _ref2.context
-    const context = _ref2$context === void 0 ? null : _ref2$context
-    this.complete = true
-    this.running = false
-    return {
-      success: success,
-      error: error,
-      context: context
-    }
-  }
-
-  /**
-   * Intend to run the queued task when it is ready. If ready, mark this task as running and run the task.
-   * @return {completeResponse}
-   */
-  run () {
-    if (!this.isReady) {
-      // Not yet ready, return with errors
-      return {
-        success: false,
-        error: 'Task is not ready',
-        context: this.data
-      }
-    }
-    if (this.running) {
-      // Already running, return error since we cannot run again
-      return {
-        success: false,
-        error: 'Queued task is already running, possible missing \'complete\' callback',
-        context: this.data
-      }
-    }
-    this.running = true
-    // Wrap the task in the markCompleted function, so we can set flags and format the response
-    return this.task(this.markCompleted.bind(this))
-  }
-}
-/**
- * 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}
- */
-exports.Queueable = Queueable
-Queueable.make = function (queueable) {
-  const classType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Queueable
-  if (typeof queueable !== 'object') {
-    // It is not an object, so instantiate the Queueable with an element as the data
-    return new classType({
-      task: queueable,
-      ready: true
-    })
-  }
-  if (queueable.classType) {
-    // Already valid Queueable, return as-is
-    return queueable
-  }
-  if (!queueable.task) {
-    queueable = {
-      task: queueable,
-      ready: true
-    }
-  }
-  // Create the new node as the configured #classType
-  return new classType(queueable)
-}
-/**
- * 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}}
- */
-Queueable.fromArray = function (values) {
-  const classType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Queueable
-  return _Linker.Linker.fromArray(values, classType)
-}
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.Queueable = void 0
+var _Linker = require('../linked-list/Linker')
+/**
+ * Queueable represents a runnable entry in a queue.
+ * @extends Linker
+ */
+class Queueable {
+  /**
+   * Create a queueable item that can be used in a queue.
+   * @param {Object} [queueableData={}]
+   * @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 = null,
+    next = null,
+    ready = false
+  } = {}) {
+    this.data = null
+    this.next = null
+    this.complete = false
+    this.ready = false
+    this.running = false
+    this.classType = Queueable
+    this.data = task
+    this.next = next
+    this.complete = false
+    this.ready = ready
+    this.running = false
+  }
+
+  /**
+   * Check ready state.
+   * @return {boolean}
+   */
+  get isReady () {
+    return typeof this.ready === 'function' ? this.ready() : this.ready
+  }
+
+  /**
+   * Retrieve the data which should be formed as a task.
+   * @return {*}
+   */
+  get task () {
+    if (typeof this.data === 'function') {
+      return this.data
+    }
+    return complete => typeof complete === 'function' ? complete({
+      context: this.data
+    }).context : this.data
+  }
+
+  /**
+   * Set this queueable as completed.
+   * @param {Object} completeResponse
+   * @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 = true,
+    error = false,
+    context = null
+  } = {}) {
+    this.complete = true
+    this.running = false
+    return {
+      success: success,
+      error: error,
+      context: context
+    }
+  }
+
+  /**
+   * Intend to run the queued task when it is ready. If ready, mark this task as running and run the task.
+   * @return {completeResponse}
+   */
+  run () {
+    if (!this.isReady) {
+      // Not yet ready, return with errors
+      return {
+        success: false,
+        error: 'Task is not ready',
+        context: this.data
+      }
+    }
+    if (this.running) {
+      // Already running, return error since we cannot run again
+      return {
+        success: false,
+        error: 'Queued task is already running, possible missing \'complete\' callback',
+        context: this.data
+      }
+    }
+    this.running = true
+    // Wrap the task in the markCompleted function, so we can set flags and format the response
+    return this.task(this.markCompleted.bind(this))
+  }
+}
+/**
+ * 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}
+ */
+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
+    return new classType({
+      task: queueable,
+      ready: true
+    })
+  }
+  if (queueable.classType) {
+    // Already valid Queueable, return as-is
+    return queueable
+  }
+  if (!queueable.task) {
+    queueable = {
+      task: queueable,
+      ready: true
+    }
+  }
+  // Create the new node as the configured #classType
+  return new classType(queueable)
+}
+/**
+ * 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}}
+ */
+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(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},t=e.task,s=void 0===t?null:t,i=e.next,n=void 0===i?null:i,r=e.ready,a=void 0!==r&&r;this.data=null,this.next=null,this.complete=!1,this.ready=!1,this.running=!1,this.classType=Queueable,this.data=s,this.next=n,this.complete=!1,this.ready=a,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(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},t=e.success,s=void 0===t||t,i=e.error,n=void 0!==i&&i,r=e.context,a=void 0===r?null:r;return this.complete=!0,this.running=!1,{success:s,error:n,context:a}}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=function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Queueable;return"object"!=typeof e?new t({task:e,ready:!0}):e.classType?e:(e.task||(e={task:e,ready:!0}),new t(e))},Queueable.fromArray=function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Queueable;return _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)=>"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);

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

@@ -1,63 +1,63 @@
-/**
- * @file stack.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- * @memberOf module:collect-your-stuff
- */
-import { Stackable } from './Stackable';
-import { IsArrayable } from '../../recipes/IsArrayable';
-import { IsLinker } from '../../recipes/IsLinker';
-import { completeResponse } from '../../recipes/Runnable';
-/**
- * Store a collection of items which can only be inserted and removed from the top.
- */
-export declare class 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
-     */
-    constructor(stackedList?: IsArrayable<any>, listClass?: any, stackableClass?: typeof Stackable);
-    /**
-     * Return true if the stack is empty (there are no tasks in the stacked list)
-     * @return {boolean}
-     */
-    empty(): boolean;
-    /**
-     * Take a look at the next stacked task
-     * @return {Stackable}
-     */
-    top(): IsLinker;
-    /**
-     * Remove the next stacked task and return it.
-     * @return {Stackable|null}
-     */
-    pop(): Stackable | completeResponse | null;
-    /**
-     * Push a stackable task to the top of the stack.
-     * @param {Stackable|*} stackable Add a new stackable to the top of the stack
-     */
-    push(stackable: any): void;
-    /**
-     * Remove the next stacked task and return it.
-     * @return {Stackable|null}
-     */
-    remove(): Stackable | null;
-    /**
-     * Get the size of the current stack.
-     * @return {number}
-     */
-    size(): number;
-    /**
-     * Convert an array to a Stack.
-     * @param {Array} values An array of values which will be converted to stackables in this queue
-     * @param {Stackable} stackableClass The class to use for each stackable
-     * @param {Stack|Iterable} listClass The class to use to manage the stackables
-     * @returns {Stack}
-     */
-    static fromArray: (values?: Array<any>, stackableClass?: typeof Stackable, listClass?: any) => Stack;
-}
+/**
+ * @file stack.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @memberOf module:collect-your-stuff
+ */
+import { Stackable } from './Stackable';
+import { IsArrayable } from '../../recipes/IsArrayable';
+import { IsLinker } from '../../recipes/IsLinker';
+import { completeResponse } from '../../recipes/Runnable';
+/**
+ * Store a collection of items which can only be inserted and removed from the top.
+ */
+export declare class 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
+     */
+    constructor(stackedList?: IsArrayable<any>, listClass?: any, stackableClass?: typeof Stackable);
+    /**
+     * Return true if the stack is empty (there are no tasks in the stacked list)
+     * @return {boolean}
+     */
+    empty(): boolean;
+    /**
+     * Take a look at the next stacked task
+     * @return {Stackable}
+     */
+    top(): IsLinker;
+    /**
+     * Remove the next stacked task and return it.
+     * @return {Stackable|null}
+     */
+    pop(): Stackable | completeResponse | null;
+    /**
+     * Push a stackable task to the top of the stack.
+     * @param {Stackable|*} stackable Add a new stackable to the top of the stack
+     */
+    push(stackable: any): void;
+    /**
+     * Remove the next stacked task and return it.
+     * @return {Stackable|null}
+     */
+    remove(): Stackable | null;
+    /**
+     * Get the size of the current stack.
+     * @return {number}
+     */
+    size(): number;
+    /**
+     * Convert an array to a Stack.
+     * @param {Array} values An array of values which will be converted to stackables in this queue
+     * @param {Stackable} stackableClass The class to use for each stackable
+     * @param {Stack|Iterable} listClass The class to use to manage the stackables
+     * @returns {Stack}
+     */
+    static fromArray: (values?: Array<any>, stackableClass?: typeof Stackable, listClass?: any) => Stack;
+}

package/dist/collections/stack/Stack.js

@@ -1,112 +1,106 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.Stack = void 0
-var _Stackable = require('./Stackable')
-var _LinkedList = require('../linked-list/LinkedList')
-/**
- * @file stack.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- * @memberOf module:collect-your-stuff
- */
-
-/**
- * Store a collection of items which can only be inserted and removed from the top.
- */
-class Stack {
-  /**
-   * Instantiate the state with the starter stacked list.
-   * @param {Iterable|LinkedList} stackedList
-   * @param {IsArrayable} listClass
-   * @param {Stackable} stackableClass
-   */
-  constructor () {
-    let stackedList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null
-    const listClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _LinkedList.LinkedList
-    const stackableClass = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _Stackable.Stackable
-    this.listClass = listClass
-    this.stackableClass = stackableClass
-    if (stackedList === null) {
-      stackedList = new listClass(stackableClass)
-    }
-    this.stackedList = stackedList
-  }
-
-  /**
-   * Return true if the stack is empty (there are no tasks in the stacked list)
-   * @return {boolean}
-   */
-  empty () {
-    return this.size() <= 0
-  }
-
-  /**
-   * Take a look at the next stacked task
-   * @return {Stackable}
-   */
-  top () {
-    return this.stackedList.first
-  }
-
-  /**
-   * Remove the next stacked task and return it.
-   * @return {Stackable|null}
-   */
-  pop () {
-    const next = this.remove()
-    if (!next) {
-      return {
-        success: 'No more stackable tasks in the stack',
-        error: false,
-        context: this.stackedList
-      }
-    }
-    return next.run()
-  }
-
-  /**
-   * Push a stackable task to the top of the stack.
-   * @param {Stackable|*} stackable Add a new stackable to the top of the stack
-   */
-  push (stackable) {
-    this.stackedList.prepend(stackable)
-  }
-
-  /**
-   * Remove the next stacked task and return it.
-   * @return {Stackable|null}
-   */
-  remove () {
-    if (this.empty()) {
-      return null
-    }
-    return this.stackedList.remove(this.stackedList.first)
-  }
-
-  /**
-   * Get the size of the current stack.
-   * @return {number}
-   */
-  size () {
-    return this.stackedList.length
-  }
-}
-/**
- * Convert an array to a Stack.
- * @param {Array} values An array of values which will be converted to stackables in this queue
- * @param {Stackable} stackableClass The class to use for each stackable
- * @param {Stack|Iterable} listClass The class to use to manage the stackables
- * @returns {Stack}
- */
-exports.Stack = Stack
-Stack.fromArray = function () {
-  const values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []
-  const stackableClass = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _Stackable.Stackable
-  const listClass = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _LinkedList.LinkedList
-  const list = new listClass(stackableClass)
-  list.initialize(stackableClass.fromArray(values, stackableClass).head)
-  return new Stack(list)
-}
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.Stack = void 0
+var _Stackable = require('./Stackable')
+var _LinkedList = require('../linked-list/LinkedList')
+/**
+ * @file stack.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @memberOf module:collect-your-stuff
+ */
+
+/**
+ * Store a collection of items which can only be inserted and removed from the top.
+ */
+class Stack {
+  /**
+   * Instantiate the state with the starter stacked list.
+   * @param {Iterable|LinkedList} stackedList
+   * @param {IsArrayable} listClass
+   * @param {Stackable} stackableClass
+   */
+  constructor (stackedList = null, listClass = _LinkedList.LinkedList, stackableClass = _Stackable.Stackable) {
+    this.listClass = listClass
+    this.stackableClass = stackableClass
+    if (stackedList === null) {
+      stackedList = new listClass(stackableClass)
+    }
+    this.stackedList = stackedList
+  }
+
+  /**
+   * Return true if the stack is empty (there are no tasks in the stacked list)
+   * @return {boolean}
+   */
+  empty () {
+    return this.size() <= 0
+  }
+
+  /**
+   * Take a look at the next stacked task
+   * @return {Stackable}
+   */
+  top () {
+    return this.stackedList.first
+  }
+
+  /**
+   * Remove the next stacked task and return it.
+   * @return {Stackable|null}
+   */
+  pop () {
+    const next = this.remove()
+    if (!next) {
+      return {
+        success: 'No more stackable tasks in the stack',
+        error: false,
+        context: this.stackedList
+      }
+    }
+    return next.run()
+  }
+
+  /**
+   * Push a stackable task to the top of the stack.
+   * @param {Stackable|*} stackable Add a new stackable to the top of the stack
+   */
+  push (stackable) {
+    this.stackedList.prepend(stackable)
+  }
+
+  /**
+   * Remove the next stacked task and return it.
+   * @return {Stackable|null}
+   */
+  remove () {
+    if (this.empty()) {
+      return null
+    }
+    return this.stackedList.remove(this.stackedList.first)
+  }
+
+  /**
+   * Get the size of the current stack.
+   * @return {number}
+   */
+  size () {
+    return this.stackedList.length
+  }
+}
+/**
+ * Convert an array to a Stack.
+ * @param {Array} values An array of values which will be converted to stackables in this queue
+ * @param {Stackable} stackableClass The class to use for each stackable
+ * @param {Stack|Iterable} listClass The class to use to manage the stackables
+ * @returns {Stack}
+ */
+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)
+}