collect-your-stuff 2.1.1 → 2.1.2

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

@@ -1,65 +1,65 @@
-/**
- * @file task 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 tasks (Stackables) which can only be inserted and removed from the top: pop() takes the task from
- * the top and RUNS it. For a plain last-in-first-out collection of items use Stack.
- */
-export declare class TaskStack {
-    /** 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=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);
-    /**
-     * 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 TaskStack.
-     * @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 {TaskStack|Iterable} listClass The class to use to manage the stackables
-     * @returns {TaskStack}
-     */
-    static fromArray: (values?: Array<any>, stackableClass?: typeof Stackable, listClass?: any) => TaskStack;
-}
+/**
+ * @file task 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 tasks (Stackables) which can only be inserted and removed from the top: pop() takes the task from
+ * the top and RUNS it. For a plain last-in-first-out collection of items use Stack.
+ */
+export declare class TaskStack {
+    /** 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=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);
+    /**
+     * 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 TaskStack.
+     * @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 {TaskStack|Iterable} listClass The class to use to manage the stackables
+     * @returns {TaskStack}
+     */
+    static fromArray: (values?: Array<any>, stackableClass?: typeof Stackable, listClass?: any) => TaskStack;
+}

package/dist/collections/stack/TaskStack.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 exports.TaskStack = void 0
-var _Stackable = require('./Stackable')
-var _LinkedList = require('../linked-list/LinkedList')
+const _Stackable = require('./Stackable')
+const _LinkedList = require('../linked-list/LinkedList')
 /**
  * @file task stack.
  * @author Joshua Heagle <joshuaheagle@gmail.com>

package/dist/main.d.ts

@@ -1,68 +1,68 @@
-/**
- * All of the collections available.
- * @file
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- * @module collect-your-stuff
- */
-import { ArrayElement } from './collections/arrayable/ArrayElement';
-import { Arrayable } from './collections/arrayable/Arrayable';
-import { DoubleLinker } from './collections/doubly-linked-list/DoubleLinker';
-import { DoublyLinkedList } from './collections/doubly-linked-list/DoublyLinkedList';
-import { Linker } from './collections/linked-list/Linker';
-import { LinkedList } from './collections/linked-list/LinkedList';
-import { TreeLinker } from './collections/linked-tree-list/TreeLinker';
-import { LinkedTreeList } from './collections/linked-tree-list/LinkedTreeList';
-import { Queueable } from './collections/queue/Queueable';
-import { Queue } from './collections/queue/Queue';
-import { TaskQueue } from './collections/queue/TaskQueue';
-import { Stackable } from './collections/stack/Stackable';
-import { Stack } from './collections/stack/Stack';
-import { TaskStack } from './collections/stack/TaskStack';
-import { recipes } from './recipes/recipes';
-import { services } from './services/services';
-/**
- * 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
- */
-export { ArrayElement, Arrayable, DoubleLinker, DoublyLinkedList, Linker, LinkedList, TreeLinker, LinkedTreeList, Queueable, Queue, TaskQueue, Stackable, Stack, TaskStack, recipes, services };
-export type { IsArrayable, forEachCallback } from './recipes/IsArrayable';
-export type { IsDoubleLinker } from './recipes/IsDoubleLinker';
-export type { IsElement } from './recipes/IsElement';
-export type { IsLinker } from './recipes/IsLinker';
-export type { IsTree } from './recipes/IsTree';
-export type { IsTreeNode } from './recipes/IsTreeNode';
-export type { IsQueue } from './recipes/IsQueue';
-export type { IsStack } from './recipes/IsStack';
-export type { IsRunnable, completeResponse } from './recipes/Runnable';
-/**
- * All methods exported from this module are encapsulated within collect-your-stuff (this default export is the same
- * set of classes as the named exports).
- */
-declare const collectYourStuff: {
-    ArrayElement: typeof ArrayElement;
-    Arrayable: typeof Arrayable;
-    DoubleLinker: typeof DoubleLinker;
-    DoublyLinkedList: typeof DoublyLinkedList;
-    Linker: typeof Linker;
-    LinkedList: typeof LinkedList;
-    TreeLinker: typeof TreeLinker;
-    LinkedTreeList: typeof LinkedTreeList;
-    Queueable: typeof Queueable;
-    Queue: typeof Queue;
-    TaskQueue: typeof TaskQueue;
-    Stackable: typeof Stackable;
-    Stack: typeof Stack;
-    TaskStack: typeof TaskStack;
-    recipes: {
-        ArrayIterator: typeof import("./recipes/ArrayIterator").ArrayIterator;
-        Runnable: typeof import("./recipes/Runnable").Runnable;
-    };
-    services: {
-        parseTree: (tree: import("./main").IsTree, callback: import("./main").forEachCallback) => import("./main").IsTree;
-        parseTreeNext: (treeNode: import("./main").IsTreeNode, boundaryParent?: import("./main").IsTreeNode | null) => import("./main").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 { ArrayElement } from './collections/arrayable/ArrayElement';
+import { Arrayable } from './collections/arrayable/Arrayable';
+import { DoubleLinker } from './collections/doubly-linked-list/DoubleLinker';
+import { DoublyLinkedList } from './collections/doubly-linked-list/DoublyLinkedList';
+import { Linker } from './collections/linked-list/Linker';
+import { LinkedList } from './collections/linked-list/LinkedList';
+import { TreeLinker } from './collections/linked-tree-list/TreeLinker';
+import { LinkedTreeList } from './collections/linked-tree-list/LinkedTreeList';
+import { Queueable } from './collections/queue/Queueable';
+import { Queue } from './collections/queue/Queue';
+import { TaskQueue } from './collections/queue/TaskQueue';
+import { Stackable } from './collections/stack/Stackable';
+import { Stack } from './collections/stack/Stack';
+import { TaskStack } from './collections/stack/TaskStack';
+import { recipes } from './recipes/recipes';
+import { services } from './services/services';
+/**
+ * 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
+ */
+export { ArrayElement, Arrayable, DoubleLinker, DoublyLinkedList, Linker, LinkedList, TreeLinker, LinkedTreeList, Queueable, Queue, TaskQueue, Stackable, Stack, TaskStack, recipes, services };
+export type { IsArrayable, forEachCallback } from './recipes/IsArrayable';
+export type { IsDoubleLinker } from './recipes/IsDoubleLinker';
+export type { IsElement } from './recipes/IsElement';
+export type { IsLinker } from './recipes/IsLinker';
+export type { IsTree } from './recipes/IsTree';
+export type { IsTreeNode } from './recipes/IsTreeNode';
+export type { IsQueue } from './recipes/IsQueue';
+export type { IsStack } from './recipes/IsStack';
+export type { IsRunnable, completeResponse } from './recipes/Runnable';
+/**
+ * All methods exported from this module are encapsulated within collect-your-stuff (this default export is the same
+ * set of classes as the named exports).
+ */
+declare const collectYourStuff: {
+    ArrayElement: typeof ArrayElement;
+    Arrayable: typeof Arrayable;
+    DoubleLinker: typeof DoubleLinker;
+    DoublyLinkedList: typeof DoublyLinkedList;
+    Linker: typeof Linker;
+    LinkedList: typeof LinkedList;
+    TreeLinker: typeof TreeLinker;
+    LinkedTreeList: typeof LinkedTreeList;
+    Queueable: typeof Queueable;
+    Queue: typeof Queue;
+    TaskQueue: typeof TaskQueue;
+    Stackable: typeof Stackable;
+    Stack: typeof Stack;
+    TaskStack: typeof TaskStack;
+    recipes: {
+        ArrayIterator: typeof import("./recipes/ArrayIterator").ArrayIterator;
+        Runnable: typeof import("./recipes/Runnable").Runnable;
+    };
+    services: {
+        parseTree: (tree: import("./main").IsTree, callback: import("./main").forEachCallback) => import("./main").IsTree;
+        parseTreeNext: (treeNode: import("./main").IsTreeNode, boundaryParent?: import("./main").IsTreeNode | null) => import("./main").IsTreeNode | null;
+    };
+};
+export default collectYourStuff;

package/dist/main.js

@@ -155,7 +155,7 @@ const collectYourStuff = {
   recipes: _recipes.recipes,
   services: _services.services
 }
-var _default = exports.default = collectYourStuff
+const _default = exports.default = collectYourStuff
 if (void 0) {
   // @ts-ignore
   (void 0).collectYourStuff = collectYourStuff

package/dist/recipes/ArrayIterator.d.ts

@@ -1,20 +1,20 @@
-import { IsElement } from './IsElement';
-/**
- * Class ArrayIterator returns the next value when using elements of array type list.
- */
-export declare class ArrayIterator implements Iterator<IsElement> {
-    private readonly innerList;
-    private index;
-    /**
-     * Create an iterator over the given array.
-     * @param {Array<IsElement>} innerList The elements to iterate over.
-     * @param {number} [index=0] The position to start from.
-     */
-    constructor(innerList: Array<IsElement>, index?: number);
-    /**
-     * Get the next element, moving the iterator forward.
-     * @param {*} [value] Not used, present to match the Iterator interface.
-     * @return {IteratorResult<IsElement>} The next element, or done when there are no more.
-     */
-    next(value?: any): IteratorResult<IsElement>;
-}
+import { IsElement } from './IsElement';
+/**
+ * Class ArrayIterator returns the next value when using elements of array type list.
+ */
+export declare class ArrayIterator implements Iterator<IsElement> {
+    private readonly innerList;
+    private index;
+    /**
+     * Create an iterator over the given array.
+     * @param {Array<IsElement>} innerList The elements to iterate over.
+     * @param {number} [index=0] The position to start from.
+     */
+    constructor(innerList: Array<IsElement>, index?: number);
+    /**
+     * Get the next element, moving the iterator forward.
+     * @param {*} [value] Not used, present to match the Iterator interface.
+     * @return {IteratorResult<IsElement>} The next element, or done when there are no more.
+     */
+    next(value?: any): IteratorResult<IsElement>;
+}

package/dist/recipes/ArrayIterator.js

@@ -1,39 +1,39 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.ArrayIterator = void 0
-/**
- * Class ArrayIterator returns the next value when using elements of array type list.
- */
-class ArrayIterator {
-  /**
-   * Create an iterator over the given array.
-   * @param {Array<IsElement>} innerList The elements to iterate over.
-   * @param {number} [index=0] The position to start from.
-   */
-  constructor (innerList, index = 0) {
-    this.innerList = innerList
-    this.index = index
-  }
-
-  /**
-   * Get the next element, moving the iterator forward.
-   * @param {*} [value] Not used, present to match the Iterator interface.
-   * @return {IteratorResult<IsElement>} The next element, or done when there are no more.
-   */
-  next (value) {
-    if (this.index < this.innerList.length) {
-      return {
-        value: this.innerList[this.index++],
-        done: false
-      }
-    }
-    return {
-      value: undefined,
-      done: true
-    }
-  }
-}
-exports.ArrayIterator = ArrayIterator
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.ArrayIterator = void 0
+/**
+ * Class ArrayIterator returns the next value when using elements of array type list.
+ */
+class ArrayIterator {
+  /**
+   * Create an iterator over the given array.
+   * @param {Array<IsElement>} innerList The elements to iterate over.
+   * @param {number} [index=0] The position to start from.
+   */
+  constructor (innerList, index = 0) {
+    this.innerList = innerList
+    this.index = index
+  }
+
+  /**
+   * Get the next element, moving the iterator forward.
+   * @param {*} [value] Not used, present to match the Iterator interface.
+   * @return {IteratorResult<IsElement>} The next element, or done when there are no more.
+   */
+  next (value) {
+    if (this.index < this.innerList.length) {
+      return {
+        value: this.innerList[this.index++],
+        done: false
+      }
+    }
+    return {
+      value: undefined,
+      done: true
+    }
+  }
+}
+exports.ArrayIterator = ArrayIterator

package/dist/recipes/DoubleLinkerIterator.d.ts

@@ -1,18 +1,18 @@
-import { IsDoubleLinker } from './IsDoubleLinker';
-/**
- * Class DoubleLinkerIterator returns the next value when using linkers of linked type lists.
- */
-export declare class DoubleLinkerIterator implements Iterator<IsDoubleLinker> {
-    private current;
-    /**
-     * Create an iterator starting at the given item.
-     * @param {IsDoubleLinker} current The item to start from.
-     */
-    constructor(current: IsDoubleLinker);
-    /**
-     * Get the current item and move on to the following one.
-     * @param {*} [value] Not used, present to match the Iterator interface.
-     * @return {IteratorResult<IsDoubleLinker>} The current item, or done when there are no more.
-     */
-    next(value?: any): IteratorResult<IsDoubleLinker>;
-}
+import { IsDoubleLinker } from './IsDoubleLinker';
+/**
+ * Class DoubleLinkerIterator returns the next value when using linkers of linked type lists.
+ */
+export declare class DoubleLinkerIterator implements Iterator<IsDoubleLinker> {
+    private current;
+    /**
+     * Create an iterator starting at the given item.
+     * @param {IsDoubleLinker} current The item to start from.
+     */
+    constructor(current: IsDoubleLinker);
+    /**
+     * Get the current item and move on to the following one.
+     * @param {*} [value] Not used, present to match the Iterator interface.
+     * @return {IteratorResult<IsDoubleLinker>} The current item, or done when there are no more.
+     */
+    next(value?: any): IteratorResult<IsDoubleLinker>;
+}

package/dist/recipes/DoubleLinkerIterator.js

@@ -1,33 +1,33 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.DoubleLinkerIterator = void 0
-/**
- * Class DoubleLinkerIterator returns the next value when using linkers of linked type lists.
- */
-class DoubleLinkerIterator {
-  /**
-   * Create an iterator starting at the given item.
-   * @param {IsDoubleLinker} current The item to start from.
-   */
-  constructor (current) {
-    this.current = current
-  }
-
-  /**
-   * Get the current item and move on to the following one.
-   * @param {*} [value] Not used, present to match the Iterator interface.
-   * @return {IteratorResult<IsDoubleLinker>} The current item, or done when there are no more.
-   */
-  next (value) {
-    const result = {
-      value: this.current,
-      done: !this.current
-    }
-    this.current = this.current ? this.current.next : null
-    return result
-  }
-}
-exports.DoubleLinkerIterator = DoubleLinkerIterator
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.DoubleLinkerIterator = void 0
+/**
+ * Class DoubleLinkerIterator returns the next value when using linkers of linked type lists.
+ */
+class DoubleLinkerIterator {
+  /**
+   * Create an iterator starting at the given item.
+   * @param {IsDoubleLinker} current The item to start from.
+   */
+  constructor (current) {
+    this.current = current
+  }
+
+  /**
+   * Get the current item and move on to the following one.
+   * @param {*} [value] Not used, present to match the Iterator interface.
+   * @return {IteratorResult<IsDoubleLinker>} The current item, or done when there are no more.
+   */
+  next (value) {
+    const result = {
+      value: this.current,
+      done: !this.current
+    }
+    this.current = this.current ? this.current.next : null
+    return result
+  }
+}
+exports.DoubleLinkerIterator = DoubleLinkerIterator