collect-your-stuff 1.2.7 → 1.2.8

package/dist/collections/stack/Stack.js

@@ -1,106 +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 (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)
-}
+'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)
+}

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

@@ -1,56 +1,56 @@
-/**
- * @file stack.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { IsRunnable } from '../../recipes/Runnable';
-import { IsLinker } from '../../recipes/IsLinker';
-/**
- * Stackable represents a runnable entry in stack.
- * @extends Linker
- */
-export declare class Stackable implements IsLinker, IsRunnable {
-    readonly classType: typeof Stackable;
-    data: any;
-    next: Stackable | null;
-    /**
-     * Create a stackable item that can be used in a stack.
-     * @param {Object} [stackData={}]
-     * @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
-     */
-    constructor({ task, next, ready }?: {
-        task?: any;
-        next?: Stackable | null;
-        ready?: boolean;
-    });
-    /**
-     * Retrieve the data which should be formed as a task.
-     * @return {*}
-     */
-    get task(): any;
-    /**
-     * Run the stacked task.
-     * @return {*}
-     */
-    run(): any;
-    /**
-     * Make a new Stackable from the data given if it is not already a valid Stackable.
-     * @param {Stackable|*} stackable Return a valid Stackable instance from given data, or even an already valid one.
-     * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
-     * @return {Stackable}
-     */
-    static make: (stackable: Stackable | any, classType?: any) => Stackable;
-    /**
-     * Convert an array into Stackable instances, return the head and tail Stackables.
-     * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of stackable linkers.
-     * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
-     * @returns {{head: Stackable, tail: Stackable}}
-     */
-    static fromArray: (values?: Array<any>, classType?: any) => {
-        head: IsLinker;
-        tail: IsLinker;
-    };
-}
+/**
+ * @file stack.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+import { IsRunnable } from '../../recipes/Runnable';
+import { IsLinker } from '../../recipes/IsLinker';
+/**
+ * Stackable represents a runnable entry in stack.
+ * @extends Linker
+ */
+export declare class Stackable implements IsLinker, IsRunnable {
+    readonly classType: typeof Stackable;
+    data: any;
+    next: Stackable | null;
+    /**
+     * Create a stackable item that can be used in a stack.
+     * @param {Object} [stackData={}]
+     * @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
+     */
+    constructor({ task, next, ready }?: {
+        task?: any;
+        next?: Stackable | null;
+        ready?: boolean;
+    });
+    /**
+     * Retrieve the data which should be formed as a task.
+     * @return {*}
+     */
+    get task(): any;
+    /**
+     * Run the stacked task.
+     * @return {*}
+     */
+    run(): any;
+    /**
+     * Make a new Stackable from the data given if it is not already a valid Stackable.
+     * @param {Stackable|*} stackable Return a valid Stackable instance from given data, or even an already valid one.
+     * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
+     * @return {Stackable}
+     */
+    static make: (stackable: Stackable | any, classType?: any) => Stackable;
+    /**
+     * Convert an array into Stackable instances, return the head and tail Stackables.
+     * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of stackable linkers.
+     * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
+     * @returns {{head: Stackable, tail: Stackable}}
+     */
+    static fromArray: (values?: Array<any>, classType?: any) => {
+        head: IsLinker;
+        tail: IsLinker;
+    };
+}

package/dist/collections/stack/Stackable.js

@@ -1,83 +1,83 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.Stackable = void 0
-var _Linker = require('../linked-list/Linker')
-/**
- * Stackable represents a runnable entry in stack.
- * @extends Linker
- */
-class Stackable {
-  /**
-   * Create a stackable item that can be used in a stack.
-   * @param {Object} [stackData={}]
-   * @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
-   */
-  constructor ({
-    task = null,
-    next = null,
-    ready = false
-  } = {}) {
-    this.data = null
-    this.next = null
-    this.classType = Stackable
-    this.data = task
-    this.next = next
-  }
-
-  /**
-   * Retrieve the data which should be formed as a task.
-   * @return {*}
-   */
-  get task () {
-    if (typeof this.data === 'function') {
-      return this.data
-    }
-    return () => this.data
-  }
-
-  /**
-   * Run the stacked task.
-   * @return {*}
-   */
-  run () {
-    return this.task()
-  }
-}
-/**
- * Make a new Stackable from the data given if it is not already a valid Stackable.
- * @param {Stackable|*} stackable Return a valid Stackable instance from given data, or even an already valid one.
- * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
- * @return {Stackable}
- */
-exports.Stackable = Stackable
-Stackable.make = (stackable, classType = Stackable) => {
-  if (typeof stackable !== 'object') {
-    // It is not an object, so instantiate the Stackable with stackable as the data
-    return new classType({
-      task: stackable
-    })
-  }
-  if (stackable.classType) {
-    // Already valid Stackable, return as-is
-    return stackable
-  }
-  if (!stackable.task) {
-    stackable = {
-      task: stackable
-    }
-  }
-  // Create the new node as the configured stackableClass
-  return new Stackable(stackable)
-}
-/**
- * Convert an array into Stackable instances, return the head and tail Stackables.
- * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of stackable linkers.
- * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
- * @returns {{head: Stackable, tail: Stackable}}
- */
-Stackable.fromArray = (values = [], classType = Stackable) => _Linker.Linker.fromArray(values, classType)
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.Stackable = void 0
+var _Linker = require('../linked-list/Linker')
+/**
+ * Stackable represents a runnable entry in stack.
+ * @extends Linker
+ */
+class Stackable {
+  /**
+   * Create a stackable item that can be used in a stack.
+   * @param {Object} [stackData={}]
+   * @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
+   */
+  constructor ({
+    task = null,
+    next = null,
+    ready = false
+  } = {}) {
+    this.data = null
+    this.next = null
+    this.classType = Stackable
+    this.data = task
+    this.next = next
+  }
+
+  /**
+   * Retrieve the data which should be formed as a task.
+   * @return {*}
+   */
+  get task () {
+    if (typeof this.data === 'function') {
+      return this.data
+    }
+    return () => this.data
+  }
+
+  /**
+   * Run the stacked task.
+   * @return {*}
+   */
+  run () {
+    return this.task()
+  }
+}
+/**
+ * Make a new Stackable from the data given if it is not already a valid Stackable.
+ * @param {Stackable|*} stackable Return a valid Stackable instance from given data, or even an already valid one.
+ * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
+ * @return {Stackable}
+ */
+exports.Stackable = Stackable
+Stackable.make = (stackable, classType = Stackable) => {
+  if (typeof stackable !== 'object') {
+    // It is not an object, so instantiate the Stackable with stackable as the data
+    return new classType({
+      task: stackable
+    })
+  }
+  if (stackable.classType) {
+    // Already valid Stackable, return as-is
+    return stackable
+  }
+  if (!stackable.task) {
+    stackable = {
+      task: stackable
+    }
+  }
+  // Create the new node as the configured stackableClass
+  return new Stackable(stackable)
+}
+/**
+ * Convert an array into Stackable instances, return the head and tail Stackables.
+ * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of stackable linkers.
+ * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
+ * @returns {{head: Stackable, tail: Stackable}}
+ */
+Stackable.fromArray = (values = [], classType = Stackable) => _Linker.Linker.fromArray(values, classType)

package/dist/main.d.ts

@@ -1,40 +1,40 @@
-/**
- * All of the collections available.
- * @file
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- * @module collect-your-stuff
- */
-import 'core-js/stable';
-import { Arrayable } from './collections/arrayable/Arrayable';
-import { DoublyLinkedList } from './collections/doubly-linked-list/DoublyLinkedList';
-import { LinkedList } from './collections/linked-list/LinkedList';
-import { LinkedTreeList } from './collections/linked-tree-list/LinkedTreeList';
-import { Queue } from './collections/queue/Queue';
-import { Stack } from './collections/stack/Stack';
-/**
- * TODO:
- * 1. Create binary tree. Use the tree, but it has a limit of only two children per parent, and when adding / removing sort is applied. Add sort function in fromArray
- * 2. Create a heap (both min and max heap variants) which is similar to binary tree in structure, but tree having its min / max value as root. and it must insert on the left-most lowest level, and removes from root. Be able to easily swap nodes to ensure min / max ordering.
- * 3. Create a graph type which can have directional and undirectional variants for linking nodes
- */
-/**
- * All methods exported from this module are encapsulated within collect-your-stuff.
- */
-declare const collectYourStuff: {
-    Arrayable: typeof Arrayable;
-    DoublyLinkedList: typeof DoublyLinkedList;
-    LinkedList: typeof LinkedList;
-    LinkedTreeList: typeof LinkedTreeList;
-    Queue: typeof Queue;
-    Stack: typeof Stack;
-    recipes: {
-        ArrayIterator: typeof import("./recipes/ArrayIterator").ArrayIterator;
-        Runnable: typeof import("./recipes/Runnable").Runnable;
-    };
-    services: {
-        parseTree: (tree: import("./recipes/IsTree").IsTree, callback: import("./recipes/IsArrayable").forEachCallback) => import("./recipes/IsTree").IsTree;
-        parseTreeNext: (treeNode: import("./recipes/IsTreeNode").IsTreeNode) => import("./recipes/IsTreeNode").IsTreeNode | null;
-    };
-};
-export default collectYourStuff;
+/**
+ * All of the collections available.
+ * @file
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @module collect-your-stuff
+ */
+import 'core-js/stable';
+import { Arrayable } from './collections/arrayable/Arrayable';
+import { DoublyLinkedList } from './collections/doubly-linked-list/DoublyLinkedList';
+import { LinkedList } from './collections/linked-list/LinkedList';
+import { LinkedTreeList } from './collections/linked-tree-list/LinkedTreeList';
+import { Queue } from './collections/queue/Queue';
+import { Stack } from './collections/stack/Stack';
+/**
+ * TODO:
+ * 1. Create binary tree. Use the tree, but it has a limit of only two children per parent, and when adding / removing sort is applied. Add sort function in fromArray
+ * 2. Create a heap (both min and max heap variants) which is similar to binary tree in structure, but tree having its min / max value as root. and it must insert on the left-most lowest level, and removes from root. Be able to easily swap nodes to ensure min / max ordering.
+ * 3. Create a graph type which can have directional and undirectional variants for linking nodes
+ */
+/**
+ * All methods exported from this module are encapsulated within collect-your-stuff.
+ */
+declare const collectYourStuff: {
+    Arrayable: typeof Arrayable;
+    DoublyLinkedList: typeof DoublyLinkedList;
+    LinkedList: typeof LinkedList;
+    LinkedTreeList: typeof LinkedTreeList;
+    Queue: typeof Queue;
+    Stack: typeof Stack;
+    recipes: {
+        ArrayIterator: typeof import("./recipes/ArrayIterator").ArrayIterator;
+        Runnable: typeof import("./recipes/Runnable").Runnable;
+    };
+    services: {
+        parseTree: (tree: import("./recipes/IsTree").IsTree, callback: import("./recipes/IsArrayable").forEachCallback) => import("./recipes/IsTree").IsTree;
+        parseTreeNext: (treeNode: import("./recipes/IsTreeNode").IsTreeNode) => import("./recipes/IsTreeNode").IsTreeNode | null;
+    };
+};
+export default collectYourStuff;