collect-your-stuff 1.2.7 → 1.2.8

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

@@ -1,269 +1,274 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.DoublyLinkedList = void 0
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.for-each.js')
-var _DoubleLinker = require('./DoubleLinker')
-var _DoubleLinkerIterator = require('../../recipes/DoubleLinkerIterator')
-var _LinkedList = require('../linked-list/LinkedList')
-/**
- * @file doubly linked list.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-
-/**
- * DoublyLinkedList represents a collection stored as a LinkedList with prev and next references.
- * @extends LinkedList
- */
-class DoublyLinkedList {
-  /**
-   * Create the new DoublyLinkedList instance.
-   */
-  constructor (linkerClass = _DoubleLinker.DoubleLinker) {
-    this.classType = DoublyLinkedList
-    this.innerList = null
-    this.initialized = false
-    this.linkerClass = linkerClass
-  }
-
-  /**
-   * 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) {
-    return _LinkedList.LinkedList.prototype.initialize.call(this, initialList)
-  }
-
-  /**
-   * Retrieve a copy of the innerList used.
-   * @returns {DoubleLinker}
-   */
-  get list () {
-    return this.innerList
-  }
-
-  /**
-   * Retrieve the first DoubleLinker in the list.
-   * @returns {DoubleLinker}
-   */
-  get first () {
-    return this.reset()
-  }
-
-  /**
-   * Retrieve the last DoubleLinker in the list.
-   * @returns {DoubleLinker}
-   */
-  get last () {
-    let tail = this.innerList
-    if (tail === null) {
-      return null
-    }
-    let next = tail.next
-    while (next !== null) {
-      tail = next
-      next = tail.next
-    }
-    return tail
-  }
-
-  /**
-   * Return the length of the list.
-   * @returns {number}
-   */
-  get length () {
-    let current = this.first
-    let length = 0
-    while (current !== null) {
-      ++length
-      current = current.next
-    }
-    return length
-  }
-
-  /**
-   * 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, newNode) {
-    newNode = this.linkerClass.make(newNode)
-    if (node !== null) {
-      // Ensure the next reference of this node is assigned to the new node
-      newNode.next = node.next
-      // Ensure this node is assigned as the prev reference of the new node
-      newNode.prev = node
-      // Then set this node's next reference to the new node
-      node.next = newNode
-    }
-    if (newNode.next) {
-      // Update the next reference to ensure circular reference for prev points to the new node
-      newNode.next.prev = newNode
-    }
-    if (!this.length) {
-      this.innerList = newNode
-    }
-    this.reset()
-    return this
-  }
-
-  /**
-   * 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, newNode) {
-    newNode = this.linkerClass.make(newNode)
-    if (node !== null) {
-      // The new node will reference this prev node as prev
-      newNode.prev = node.prev
-      // The new node will reference this node as next
-      newNode.next = node
-      // This prev will reference the new node
-      node.prev = newNode
-    }
-    if (newNode.prev) {
-      // Update the prev reference to ensure circular reference for next points to the new node
-      newNode.prev.next = newNode
-    }
-    if (!this.length) {
-      this.innerList = newNode
-    }
-    this.reset()
-    return this
-  }
-
-  /**
-   * 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, after = this.last) {
-    return this.insertAfter(after, node)
-  }
-
-  /**
-   * 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, before = this.first) {
-    return this.insertBefore(before, node)
-  }
-
-  /**
-   * 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) {
-    if (node === null) {
-      return null
-    }
-    if (node.prev) {
-      // The previous node will reference this next node
-      node.prev.next = node.next
-    }
-    if (node.next) {
-      // The next node will reference this previous node
-      node.next.prev = node.prev
-    }
-    // Update head reference
-    this.reset()
-    return node
-  }
-
-  /**
-   * Refresh all references and return head reference.
-   * @return {DoubleLinker}
-   */
-  reset () {
-    // Start at the pointer for the list
-    let pointer = this.innerList
-    if (pointer === null) {
-      return null
-    }
-    let next = pointer.next
-    // Follow references till the end
-    while (next !== null) {
-      pointer = next
-      next = pointer.next
-    }
-    let prev = pointer.prev
-    // From final reference, follow references back to the beginning
-    while (prev !== null) {
-      pointer = prev
-      prev = pointer.prev
-    }
-    // All the live references should have been found, and we are pointing to the true head
-    this.innerList = pointer
-    return pointer
-  }
-
-  /**
-   * 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) {
-    if (index >= 0) {
-      // For a positive index, start from the beginning of the list until the current item counter equals our index
-      let current = this.first
-      let currentIndex = -1
-      while (++currentIndex < index && current !== null) {
-        current = current.next
-      }
-      return currentIndex === index ? current : null
-    }
-    // For a negative index, get the delta of index and length, then go backwards until we reach that delta
-    let current = this.last
-    let currentIndex = this.length
-    const calculatedIndex = this.length + index
-    if (calculatedIndex < 0) {
-      return null
-    }
-    while (--currentIndex > calculatedIndex && current !== null) {
-      current = current.prev
-    }
-    return currentIndex === calculatedIndex ? current : null
-  }
-
-  /**
-   * 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, thisArg = this) {
-    return _LinkedList.LinkedList.prototype.forEach.call(this, callback, thisArg)
-  }
-
-  /**
-   * Be able to iterate over this class.
-   * @returns {Iterator}
-   */
-  [Symbol.iterator] () {
-    const current = this.first
-    return new _DoubleLinkerIterator.DoubleLinkerIterator(current)
-  }
-}
-/**
- * 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}
- */
-exports.DoublyLinkedList = DoublyLinkedList
-DoublyLinkedList.fromArray = (values = [], linkerClass = _DoubleLinker.DoubleLinker, classType = DoublyLinkedList) => {
-  return _LinkedList.LinkedList.fromArray(values, linkerClass, classType)
-}
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.DoublyLinkedList = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.for-each.js')
+var _DoubleLinker = require('./DoubleLinker')
+var _DoubleLinkerIterator = require('../../recipes/DoubleLinkerIterator')
+var _LinkedList = require('../linked-list/LinkedList')
+/**
+ * @file doubly linked list.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.1.0
+ * @memberOf module:collect-your-stuff
+ */
+
+/**
+ * DoublyLinkedList represents a collection stored as a LinkedList with prev and next references.
+ * @extends LinkedList
+ */
+class DoublyLinkedList {
+  /**
+   * Create the new DoublyLinkedList instance.
+   */
+  constructor (linkerClass = _DoubleLinker.DoubleLinker) {
+    this.classType = DoublyLinkedList
+    this.innerList = null
+    this.initialized = false
+    this.linkerClass = linkerClass
+  }
+
+  /**
+   * 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) {
+    return _LinkedList.LinkedList.prototype.initialize.call(this, initialList)
+  }
+
+  /**
+   * Retrieve a copy of the innerList used.
+   * @returns {DoubleLinker}
+   */
+  get list () {
+    return this.innerList
+  }
+
+  /**
+   * Retrieve the first DoubleLinker in the list.
+   * @returns {DoubleLinker}
+   */
+  get first () {
+    return this.reset()
+  }
+
+  /**
+   * Retrieve the last DoubleLinker in the list.
+   * @returns {DoubleLinker}
+   */
+  get last () {
+    let tail = this.innerList
+    if (tail === null) {
+      return null
+    }
+    let next = tail.next
+    while (next !== null) {
+      tail = next
+      next = tail.next
+    }
+    return tail
+  }
+
+  /**
+   * Return the length of the list.
+   * @returns {number}
+   */
+  get length () {
+    let current = this.first
+    let length = 0
+    while (current !== null) {
+      ++length
+      current = current.next
+    }
+    return length
+  }
+
+  /**
+   * 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, newNode) {
+    newNode = this.linkerClass.make(newNode)
+    if (node !== null) {
+      // Ensure the next reference of this node is assigned to the new node
+      newNode.next = node.next
+      // Ensure this node is assigned as the prev reference of the new node
+      newNode.prev = node
+      // Then set this node's next reference to the new node
+      node.next = newNode
+    }
+    if (newNode.next) {
+      // Update the next reference to ensure circular reference for prev points to the new node
+      newNode.next.prev = newNode
+    }
+    if (!this.length) {
+      this.innerList = newNode
+    }
+    this.reset()
+    return this
+  }
+
+  /**
+   * 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, newNode) {
+    newNode = this.linkerClass.make(newNode)
+    if (node !== null) {
+      // The new node will reference this prev node as prev
+      newNode.prev = node.prev
+      // The new node will reference this node as next
+      newNode.next = node
+      // This prev will reference the new node
+      node.prev = newNode
+    }
+    if (newNode.prev) {
+      // Update the prev reference to ensure circular reference for next points to the new node
+      newNode.prev.next = newNode
+    }
+    if (!this.length) {
+      this.innerList = newNode
+    }
+    this.reset()
+    return this
+  }
+
+  /**
+   * 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, after = this.last) {
+    return this.insertAfter(after, node)
+  }
+
+  /**
+   * 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, before = this.first) {
+    return this.insertBefore(before, node)
+  }
+
+  /**
+   * 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) {
+    if (node === null) {
+      return null
+    }
+    if (node.prev) {
+      // The previous node will reference this next node
+      node.prev.next = node.next
+    }
+    if (node.next) {
+      // The next node will reference this previous node
+      node.next.prev = node.prev
+    }
+    // The list finds its head by walking from innerList, so it must not keep pointing at the node being removed. For the
+    // last remaining node there is nothing to walk to, which would otherwise leave the removed node in the list.
+    if (this.innerList === node) {
+      this.innerList = node.next || node.prev || null
+    }
+    // Update head reference
+    this.reset()
+    return node
+  }
+
+  /**
+   * Refresh all references and return head reference.
+   * @return {DoubleLinker}
+   */
+  reset () {
+    // Start at the pointer for the list
+    let pointer = this.innerList
+    if (pointer === null) {
+      return null
+    }
+    let next = pointer.next
+    // Follow references till the end
+    while (next !== null) {
+      pointer = next
+      next = pointer.next
+    }
+    let prev = pointer.prev
+    // From final reference, follow references back to the beginning
+    while (prev !== null) {
+      pointer = prev
+      prev = pointer.prev
+    }
+    // All the live references should have been found, and we are pointing to the true head
+    this.innerList = pointer
+    return pointer
+  }
+
+  /**
+   * 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) {
+    if (index >= 0) {
+      // For a positive index, start from the beginning of the list until the current item counter equals our index
+      let current = this.first
+      let currentIndex = -1
+      while (++currentIndex < index && current !== null) {
+        current = current.next
+      }
+      return currentIndex === index ? current : null
+    }
+    // For a negative index, get the delta of index and length, then go backwards until we reach that delta
+    let current = this.last
+    let currentIndex = this.length
+    const calculatedIndex = this.length + index
+    if (calculatedIndex < 0) {
+      return null
+    }
+    while (--currentIndex > calculatedIndex && current !== null) {
+      current = current.prev
+    }
+    return currentIndex === calculatedIndex ? current : null
+  }
+
+  /**
+   * 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, thisArg = this) {
+    return _LinkedList.LinkedList.prototype.forEach.call(this, callback, thisArg)
+  }
+
+  /**
+   * Be able to iterate over this class.
+   * @returns {Iterator}
+   */
+  [Symbol.iterator] () {
+    const current = this.first
+    return new _DoubleLinkerIterator.DoubleLinkerIterator(current)
+  }
+}
+/**
+ * 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}
+ */
+exports.DoublyLinkedList = DoublyLinkedList
+DoublyLinkedList.fromArray = (values = [], linkerClass = _DoubleLinker.DoubleLinker, classType = DoublyLinkedList) => {
+  return _LinkedList.LinkedList.fromArray(values, linkerClass, classType)
+}

package/dist/collections/doubly-linked-list/DoublyLinkedList.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.DoublyLinkedList=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.for-each.js");var _DoubleLinker=require("./DoubleLinker"),_DoubleLinkerIterator=require("../../recipes/DoubleLinkerIterator"),_LinkedList=require("../linked-list/LinkedList");class DoublyLinkedList{constructor(e=_DoubleLinker.DoubleLinker){this.classType=DoublyLinkedList,this.innerList=null,this.initialized=!1,this.linkerClass=e}initialize(e){return _LinkedList.LinkedList.prototype.initialize.call(this,e)}get list(){return this.innerList}get first(){return this.reset()}get last(){let e=this.innerList;if(null===e)return null;let t=e.next;for(;null!==t;)e=t,t=e.next;return e}get length(){let e=this.first,t=0;for(;null!==e;)++t,e=e.next;return t}insertAfter(e,t){return t=this.linkerClass.make(t),null!==e&&(t.next=e.next,t.prev=e,e.next=t),t.next&&(t.next.prev=t),this.length||(this.innerList=t),this.reset(),this}insertBefore(e,t){return t=this.linkerClass.make(t),null!==e&&(t.prev=e.prev,t.next=e,e.prev=t),t.prev&&(t.prev.next=t),this.length||(this.innerList=t),this.reset(),this}append(e,t=this.last){return this.insertAfter(t,e)}prepend(e,t=this.first){return this.insertBefore(t,e)}remove(e){return null===e?null:(e.prev&&(e.prev.next=e.next),e.next&&(e.next.prev=e.prev),this.reset(),e)}reset(){let e=this.innerList;if(null===e)return null;let t=e.next;for(;null!==t;)e=t,t=e.next;let r=e.prev;for(;null!==r;)e=r,r=e.prev;return this.innerList=e,e}item(e){if(e>=0){let t=this.first,r=-1;for(;++r<e&&null!==t;)t=t.next;return r===e?t:null}let t=this.last,r=this.length;const i=this.length+e;if(i<0)return null;for(;--r>i&&null!==t;)t=t.prev;return r===i?t:null}forEach(e,t=this){return _LinkedList.LinkedList.prototype.forEach.call(this,e,t)}[Symbol.iterator](){let e=this.first;return new _DoubleLinkerIterator.DoubleLinkerIterator(e)}}exports.DoublyLinkedList=DoublyLinkedList,DoublyLinkedList.fromArray=(e=[],t=_DoubleLinker.DoubleLinker,r=DoublyLinkedList)=>_LinkedList.LinkedList.fromArray(e,t,r);
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.DoublyLinkedList=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.for-each.js");var _DoubleLinker=require("./DoubleLinker"),_DoubleLinkerIterator=require("../../recipes/DoubleLinkerIterator"),_LinkedList=require("../linked-list/LinkedList");class DoublyLinkedList{constructor(e=_DoubleLinker.DoubleLinker){this.classType=DoublyLinkedList,this.innerList=null,this.initialized=!1,this.linkerClass=e}initialize(e){return _LinkedList.LinkedList.prototype.initialize.call(this,e)}get list(){return this.innerList}get first(){return this.reset()}get last(){let e=this.innerList;if(null===e)return null;let t=e.next;for(;null!==t;)e=t,t=e.next;return e}get length(){let e=this.first,t=0;for(;null!==e;)++t,e=e.next;return t}insertAfter(e,t){return t=this.linkerClass.make(t),null!==e&&(t.next=e.next,t.prev=e,e.next=t),t.next&&(t.next.prev=t),this.length||(this.innerList=t),this.reset(),this}insertBefore(e,t){return t=this.linkerClass.make(t),null!==e&&(t.prev=e.prev,t.next=e,e.prev=t),t.prev&&(t.prev.next=t),this.length||(this.innerList=t),this.reset(),this}append(e,t=this.last){return this.insertAfter(t,e)}prepend(e,t=this.first){return this.insertBefore(t,e)}remove(e){return null===e?null:(e.prev&&(e.prev.next=e.next),e.next&&(e.next.prev=e.prev),this.innerList===e&&(this.innerList=e.next||e.prev||null),this.reset(),e)}reset(){let e=this.innerList;if(null===e)return null;let t=e.next;for(;null!==t;)e=t,t=e.next;let r=e.prev;for(;null!==r;)e=r,r=e.prev;return this.innerList=e,e}item(e){if(e>=0){let t=this.first,r=-1;for(;++r<e&&null!==t;)t=t.next;return r===e?t:null}let t=this.last,r=this.length;const i=this.length+e;if(i<0)return null;for(;--r>i&&null!==t;)t=t.prev;return r===i?t:null}forEach(e,t=this){return _LinkedList.LinkedList.prototype.forEach.call(this,e,t)}[Symbol.iterator](){let e=this.first;return new _DoubleLinkerIterator.DoubleLinkerIterator(e)}}exports.DoublyLinkedList=DoublyLinkedList,DoublyLinkedList.fromArray=(e=[],t=_DoubleLinker.DoubleLinker,r=DoublyLinkedList)=>_LinkedList.LinkedList.fromArray(e,t,r);