collect-your-stuff 2.1.2 → 2.2.0

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

@@ -1,73 +1,71 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.DoubleLinker = void 0
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.reduce.js')
-const _Linker = require('../linked-list/Linker')
-/**
- * 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={}] The settings for the new linker.
-   * @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 ({
-    data = null,
-    next = null,
-    prev = null
-  } = {}) {
-    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
-    this.classType = DoubleLinker
-    /** The data stored in this linker. */
-    this.data = null
-    /** The linker after this one, or null when this is the last. */
-    this.next = null
-    /** The linker before this one, or null when this is the first. */
-    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}
- */
-exports.DoubleLinker = DoubleLinker
-DoubleLinker.make = (linker, classType = DoubleLinker) => {
-  return _Linker.Linker.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 = (values = [], classType = DoubleLinker) => 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
-})
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.DoubleLinker = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.reduce.js')
+const _Linker = require('../linked-list/Linker')
+/**
+ * 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 nodeData The settings for the new linker.
+   * @param nodeData.data The data to be stored in this linker
+   * @param nodeData.next The reference to the next linker if any
+   * @param nodeData.prev The reference to the previous linker if any
+   */
+  constructor ({
+    data = null,
+    next = null,
+    prev = null
+  } = {}) {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
+    this.classType = DoubleLinker
+    /** The data stored in this linker. */
+    this.data = null
+    /** The linker after this one, or null when this is the last. */
+    this.next = null
+    /** The linker before this one, or null when this is the first. */
+    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 linker Return a valid Linker instance from given data, or even an already valid one.
+ * @param classType Provide the type of IsDoubleLinker to use.
+ */
+exports.DoubleLinker = DoubleLinker
+DoubleLinker.make = (linker, classType = DoubleLinker) => {
+  return _Linker.Linker.make(linker, classType)
+}
+/**
+ * Convert an array into DoubleLinker instances, return the head and tail DoubleLinkers.
+ * @param values Provide an array of data that will be converted to a chain of linkers.
+ * @param classType Provide the type of IsDoubleLinker to use.
+ */
+DoubleLinker.fromArray = (values = [], classType = DoubleLinker) => 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
+})

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

@@ -1,8 +1,5 @@
 /**
- * @file doubly linked list.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
+ * doubly linked list.
  */
 import { DoubleLinker } from './DoubleLinker';
 import { forEachCallback, IsArrayable } from '../../recipes/IsArrayable';
@@ -26,100 +23,86 @@ export declare class DoublyLinkedList implements IsArrayable<DoubleLinker>, Iter
     private countCache;
     /**
      * Create the new DoublyLinkedList instance.
-     * @param {DoubleLinker} [linkerClass=DoubleLinker] The class used to wrap given data as linkers.
+     * @param linkerClass The class used to wrap given data as linkers.
      */
     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}
+     * @param initialList Give the list of double-linkers to start in this doubly linked-list.
      */
     initialize(initialList: DoubleLinker): DoublyLinkedList;
     /**
      * Retrieve the innerList used (the list itself, not a copy).
-     * @returns {DoubleLinker}
      */
     get list(): DoubleLinker;
     /**
      * Retrieve the first DoubleLinker in the list.
-     * @returns {DoubleLinker}
      */
     get first(): DoubleLinker | null;
     /**
      * Retrieve the last DoubleLinker in the list. The end is remembered, so this does not walk the list.
-     * @returns {DoubleLinker}
      */
     get last(): DoubleLinker | null;
     /**
      * Return the length of the list. It is kept up to date by the list's own methods, so this does not walk the list
      * (call reset() after linkers were changed directly).
-     * @returns {number}
      */
     get length(): number;
     /**
      * Insert a new node (or data) after a node.
-     * @param {DoubleLinker|*} node The existing node as reference (which must be in this list, this is not checked), or null to insert at the start of the list
-     * @param {DoubleLinker|*} newNode The new node to go after the existing node
-     * @returns {DoublyLinkedList}
+     * @param node The existing node as reference (which must be in this list, this is not checked), or null to insert at the start of the list
+     * @param newNode The new node to go after the existing node
      */
     insertAfter(node: DoubleLinker | null, newNode: DoubleLinker | any): DoublyLinkedList;
     /**
      * Insert a new node (or data) before a node.
-     * @param {DoubleLinker|*} node The existing node as reference (which must be in this list, this is not checked), or null to insert at the end of the list
-     * @param {DoubleLinker|*} newNode The new node to go before the existing node
-     * @returns {DoublyLinkedList}
+     * @param node The existing node as reference (which must be in this list, this is not checked), or null to insert at the end of the list
+     * @param newNode The new node to go before the existing node
      */
     insertBefore(node: DoubleLinker | null, 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}
+     * @param node The new node to add to the end of the list
+     * @param after The existing last node
      */
     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}
+     * @param node The new node to add to the start of the list
+     * @param before The existing first node
      */
     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}
+     * @param node The node we wish to remove (and it will be returned after removal)
      */
     remove(node: DoubleLinker | null): DoubleLinker | null;
     /**
      * Refresh all references (the head, the end and the length) by walking the list once, and return the head. The list's
      * own methods keep these up to date, so this is only needed after linkers were changed directly.
-     * @return {DoubleLinker|null}
      */
     reset(): DoubleLinker | null;
     /**
      * 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}
+     * @param index The integer number for retrieving a node by position.
      */
     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
-     * @return {DoublyLinkedList} The list which was iterated.
+     * @param callback The function to call for-each double linker
+     * @param thisArg Optional, 'this' reference
+     * @returns The list which was iterated.
      */
     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}
+     * @param values An array of values which will be converted to linkers in this doubly-linked-list
+     * @param linkerClass The class to use for each linker
+     * @param classType Provide the type of IsArrayable to use.
      */
     static fromArray: (values?: Array<any>, linkerClass?: typeof DoubleLinker, classType?: any) => IsArrayable<IsDoubleLinker> | any;
 }