collect-your-stuff 1.1.0 → 1.1.2

package/dist/collections/doubly-linked-list/DoubleLinker.js

@@ -1,77 +1,77 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.default = void 0
-require('core-js/modules/esnext.async-iterator.reduce.js')
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.reduce.js')
-var _Linker = _interopRequireDefault(require('../linked-list/Linker'))
-function _interopRequireDefault (obj) { return obj && obj.__esModule ? obj : { default: obj } }
-/**
- * DoubleLinker represents a node in a DoublyLinkedList which is chained by next and prev.
- * @extends Linker
- */
-class DoubleLinker {
-  /**
-   * Create the new DoubleLinker instance, provide the data and optionally the next and prev references.
-   * @param {Object} [nodeData={}]
-   * @param {*} [nodeData.data=null] The data to be stored in this linker
-   * @param {DoubleLinker|null} [nodeData.next=null] The reference to the next linker if any
-   * @param {DoubleLinker|null} [nodeData.prev=null] The reference to the previous linker if any
-   */
-  constructor () {
-    const {
-      data = null,
-      next = null,
-      prev = null
-    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}
-    this.classType = DoubleLinker
-    this.data = null
-    this.next = null
-    this.prev = null
-    this.data = data
-    this.next = next
-    this.prev = prev
-  }
-}
-/**
- * Make a new DoubleLinker from the data given if it is not already a valid Linker.
- * @param {DoubleLinker|*} linker Return a valid Linker instance from given data, or even an already valid one.
- * @param {IsDoubleLinker} [classType=DoubleLinker] Provide the type of IsDoubleLinker to use.
- * @return {DoubleLinker}
- */
-DoubleLinker.make = function (linker) {
-  const classType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DoubleLinker
-  return _Linker.default.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 linkers.
- * @param {IsDoubleLinker} [classType=DoubleLinker] Provide the type of IsDoubleLinker to use.
- * @returns {{head: DoubleLinker, tail: DoubleLinker}}
- */
-DoubleLinker.fromArray = function () {
-  const values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []
-  const classType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DoubleLinker
-  return values.reduce((references, linker) => {
-    const newLinker = classType.make(linker, classType)
-    if (references.head === null) {
-      // Initialize the head and tail with the new node
-      return {
-        head: newLinker,
-        tail: newLinker
-      }
-    }
-    newLinker.prev = references.tail
-    // Only update the tail once head has been set, tail is always the most recent node
-    references.tail.next = newLinker
-    references.tail = newLinker
-    return references
-  }, {
-    head: null,
-    tail: null
-  })
-}
-var _default = exports.default = DoubleLinker
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+require('core-js/modules/esnext.async-iterator.reduce.js')
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.reduce.js')
+var _Linker = _interopRequireDefault(require('../linked-list/Linker'))
+function _interopRequireDefault (obj) { return obj && obj.__esModule ? obj : { default: obj } }
+/**
+ * DoubleLinker represents a node in a DoublyLinkedList which is chained by next and prev.
+ * @extends Linker
+ */
+class DoubleLinker {
+  /**
+   * Create the new DoubleLinker instance, provide the data and optionally the next and prev references.
+   * @param {Object} [nodeData={}]
+   * @param {*} [nodeData.data=null] The data to be stored in this linker
+   * @param {DoubleLinker|null} [nodeData.next=null] The reference to the next linker if any
+   * @param {DoubleLinker|null} [nodeData.prev=null] The reference to the previous linker if any
+   */
+  constructor () {
+    const {
+      data = null,
+      next = null,
+      prev = null
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}
+    this.classType = DoubleLinker
+    this.data = null
+    this.next = null
+    this.prev = null
+    this.data = data
+    this.next = next
+    this.prev = prev
+  }
+}
+/**
+ * Make a new DoubleLinker from the data given if it is not already a valid Linker.
+ * @param {DoubleLinker|*} linker Return a valid Linker instance from given data, or even an already valid one.
+ * @param {IsDoubleLinker} [classType=DoubleLinker] Provide the type of IsDoubleLinker to use.
+ * @return {DoubleLinker}
+ */
+DoubleLinker.make = function (linker) {
+  const classType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DoubleLinker
+  return _Linker.default.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 linkers.
+ * @param {IsDoubleLinker} [classType=DoubleLinker] Provide the type of IsDoubleLinker to use.
+ * @returns {{head: DoubleLinker, tail: DoubleLinker}}
+ */
+DoubleLinker.fromArray = function () {
+  const values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []
+  const classType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DoubleLinker
+  return values.reduce((references, linker) => {
+    const newLinker = classType.make(linker, classType)
+    if (references.head === null) {
+      // Initialize the head and tail with the new node
+      return {
+        head: newLinker,
+        tail: newLinker
+      }
+    }
+    newLinker.prev = references.tail
+    // Only update the tail once head has been set, tail is always the most recent node
+    references.tail.next = newLinker
+    references.tail = newLinker
+    return references
+  }, {
+    head: null,
+    tail: null
+  })
+}
+var _default = exports.default = DoubleLinker

package/dist/collections/doubly-linked-list/DoublyLinkedList.d.ts

@@ -1,113 +1,114 @@
-/**
- * @file doubly linked list.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import DoubleLinker from './DoubleLinker';
-import IsArrayable, { forEachCallback } from '../../recipes/IsArrayable';
-import IsDoubleLinker from '../../recipes/IsDoubleLinker';
-/**
- * DoublyLinkedList represents a collection stored as a LinkedList with prev and next references.
- * @extends LinkedList
- */
-declare class DoublyLinkedList implements IsArrayable<DoubleLinker>, Iterable<DoubleLinker> {
-    readonly classType: typeof DoublyLinkedList;
-    innerList: DoubleLinker;
-    initialized: boolean;
-    /**
-     * Create the new DoublyLinkedList instance.
-     */
-    constructor();
-    /**
-     * Initialize the inner list, should only run once.
-     * @param {DoubleLinker} initialList Give the list of double-linkers to start in this doubly linked-list.
-     * @return {DoublyLinkedList}
-     */
-    initialize(initialList: DoubleLinker): DoublyLinkedList;
-    /**
-     * Retrieve a copy of the innerList used.
-     * @returns {DoubleLinker}
-     */
-    get list(): DoubleLinker;
-    /**
-     * Retrieve the first DoubleLinker in the list.
-     * @returns {DoubleLinker}
-     */
-    get first(): DoubleLinker;
-    /**
-     * Retrieve the last DoubleLinker in the list.
-     * @returns {DoubleLinker}
-     */
-    get last(): DoubleLinker;
-    /**
-     * Return the length of the list.
-     * @returns {number}
-     */
-    get length(): number;
-    /**
-     * Insert a new node (or data) after a node.
-     * @param {DoubleLinker|*} node The existing node as reference
-     * @param {DoubleLinker|*} newNode The new node to go after the existing node
-     * @returns {DoublyLinkedList}
-     */
-    insertAfter(node: DoubleLinker, newNode: DoubleLinker | any): DoublyLinkedList;
-    /**
-     * Insert a new node (or data) before a node.
-     * @param {DoubleLinker|*} node The existing node as reference
-     * @param {DoubleLinker|*} newNode The new node to go before the existing node
-     * @returns {DoublyLinkedList}
-     */
-    insertBefore(node: DoubleLinker, newNode: DoubleLinker | any): DoublyLinkedList;
-    /**
-     * Add a node (or data) after the given (or last) node in the list.
-     * @param {DoubleLinker|*} node The new node to add to the end of the list
-     * @param {DoubleLinker} after The existing last node
-     * @returns {DoubleLinker}
-     */
-    append(node: DoubleLinker | any, after?: DoubleLinker): DoublyLinkedList;
-    /**
-     * Add a node (or data) before the given (or first) node in the list.
-     * @param {DoubleLinker|*} node The new node to add to the start of the list
-     * @param {DoubleLinker} before The existing first node
-     * @returns {DoubleLinker}
-     */
-    prepend(node: DoubleLinker | any, before?: DoubleLinker): DoublyLinkedList;
-    /**
-     * Remove a linker from this linked list.
-     * @param {DoubleLinker} node The node we wish to remove (and it will be returned after removal)
-     * @return {DoubleLinker}
-     */
-    remove(node: DoubleLinker): DoubleLinker;
-    /**
-     * Refresh all references and return head reference.
-     * @return {DoubleLinker}
-     */
-    reset(): DoubleLinker;
-    /**
-     * Retrieve a DoubleLinker item from this list by numeric index, otherwise return null.
-     * @param {number} index The integer number for retrieving a node by position.
-     * @returns {DoubleLinker|null}
-     */
-    item(index: number): DoubleLinker;
-    /**
-     * Be able to run forEach on this DoublyLinkedList to iterate over the DoubleLinker Items.
-     * @param {forEachCallback} callback The function to call for-each double linker
-     * @param {DoublyLinkedList} thisArg Optional, 'this' reference
-     */
-    forEach(callback: forEachCallback, thisArg?: DoublyLinkedList): DoublyLinkedList;
-    /**
-     * Be able to iterate over this class.
-     * @returns {Iterator}
-     */
-    [Symbol.iterator](): Iterator<DoubleLinker>;
-    /**
-     * Convert an array into a DoublyLinkedList instance, return the new instance.
-     * @param {Array} [values=[]] An array of values which will be converted to linkers in this doubly-linked-list
-     * @param {IsDoubleLinker} [linkerClass=DoubleLinker] The class to use for each linker
-     * @param {IsArrayable<IsDoubleLinker>} [classType=LinkedList] Provide the type of IsArrayable to use.
-     * @returns {DoublyLinkedList}
-     */
-    static fromArray: (values?: Array<any>, linkerClass?: typeof DoubleLinker, classType?: any) => IsArrayable<IsDoubleLinker> | any;
-}
-export default DoublyLinkedList;
+/**
+ * @file doubly linked list.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+import DoubleLinker from './DoubleLinker';
+import IsArrayable, { forEachCallback } from '../../recipes/IsArrayable';
+import IsDoubleLinker from '../../recipes/IsDoubleLinker';
+/**
+ * DoublyLinkedList represents a collection stored as a LinkedList with prev and next references.
+ * @extends LinkedList
+ */
+declare class DoublyLinkedList implements IsArrayable<DoubleLinker>, Iterable<DoubleLinker> {
+    readonly classType: typeof DoublyLinkedList;
+    innerList: DoubleLinker;
+    initialized: boolean;
+    linkerClass: typeof DoubleLinker;
+    /**
+     * Create the new DoublyLinkedList instance.
+     */
+    constructor(linkerClass?: typeof DoubleLinker);
+    /**
+     * Initialize the inner list, should only run once.
+     * @param {DoubleLinker} initialList Give the list of double-linkers to start in this doubly linked-list.
+     * @return {DoublyLinkedList}
+     */
+    initialize(initialList: DoubleLinker): DoublyLinkedList;
+    /**
+     * Retrieve a copy of the innerList used.
+     * @returns {DoubleLinker}
+     */
+    get list(): DoubleLinker;
+    /**
+     * Retrieve the first DoubleLinker in the list.
+     * @returns {DoubleLinker}
+     */
+    get first(): DoubleLinker;
+    /**
+     * Retrieve the last DoubleLinker in the list.
+     * @returns {DoubleLinker}
+     */
+    get last(): DoubleLinker;
+    /**
+     * Return the length of the list.
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     * Insert a new node (or data) after a node.
+     * @param {DoubleLinker|*} node The existing node as reference
+     * @param {DoubleLinker|*} newNode The new node to go after the existing node
+     * @returns {DoublyLinkedList}
+     */
+    insertAfter(node: DoubleLinker, newNode: DoubleLinker | any): DoublyLinkedList;
+    /**
+     * Insert a new node (or data) before a node.
+     * @param {DoubleLinker|*} node The existing node as reference
+     * @param {DoubleLinker|*} newNode The new node to go before the existing node
+     * @returns {DoublyLinkedList}
+     */
+    insertBefore(node: DoubleLinker, newNode: DoubleLinker | any): DoublyLinkedList;
+    /**
+     * Add a node (or data) after the given (or last) node in the list.
+     * @param {DoubleLinker|*} node The new node to add to the end of the list
+     * @param {DoubleLinker} after The existing last node
+     * @returns {DoubleLinker}
+     */
+    append(node: DoubleLinker | any, after?: DoubleLinker): DoublyLinkedList;
+    /**
+     * Add a node (or data) before the given (or first) node in the list.
+     * @param {DoubleLinker|*} node The new node to add to the start of the list
+     * @param {DoubleLinker} before The existing first node
+     * @returns {DoubleLinker}
+     */
+    prepend(node: DoubleLinker | any, before?: DoubleLinker): DoublyLinkedList;
+    /**
+     * Remove a linker from this linked list.
+     * @param {DoubleLinker} node The node we wish to remove (and it will be returned after removal)
+     * @return {DoubleLinker}
+     */
+    remove(node: DoubleLinker): DoubleLinker;
+    /**
+     * Refresh all references and return head reference.
+     * @return {DoubleLinker}
+     */
+    reset(): DoubleLinker;
+    /**
+     * Retrieve a DoubleLinker item from this list by numeric index, otherwise return null.
+     * @param {number} index The integer number for retrieving a node by position.
+     * @returns {DoubleLinker|null}
+     */
+    item(index: number): DoubleLinker;
+    /**
+     * Be able to run forEach on this DoublyLinkedList to iterate over the DoubleLinker Items.
+     * @param {forEachCallback} callback The function to call for-each double linker
+     * @param {DoublyLinkedList} thisArg Optional, 'this' reference
+     */
+    forEach(callback: forEachCallback, thisArg?: DoublyLinkedList): DoublyLinkedList;
+    /**
+     * Be able to iterate over this class.
+     * @returns {Iterator}
+     */
+    [Symbol.iterator](): Iterator<DoubleLinker>;
+    /**
+     * Convert an array into a DoublyLinkedList instance, return the new instance.
+     * @param {Array} [values=[]] An array of values which will be converted to linkers in this doubly-linked-list
+     * @param {IsDoubleLinker} [linkerClass=DoubleLinker] The class to use for each linker
+     * @param {IsArrayable<IsDoubleLinker>} [classType=LinkedList] Provide the type of IsArrayable to use.
+     * @returns {DoublyLinkedList}
+     */
+    static fromArray: (values?: Array<any>, linkerClass?: typeof DoubleLinker, classType?: any) => IsArrayable<IsDoubleLinker> | any;
+}
+export default DoublyLinkedList;