collect-your-stuff 2.1.1 → 2.2.0

package/dist/collections/linked-tree-list/TreeLinker.d.ts

@@ -1,71 +1,65 @@
-/**
- * @file doubly linked tree node.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-import { IsArrayable } from '../../recipes/IsArrayable';
-import { IsTreeNode } from '../../recipes/IsTreeNode';
-import { IsTree } from '../../recipes/IsTree';
-/**
- * TreeLinker represents a node in a LinkedTreeList having a parent (or root) and child nodes.
- * @extends DoubleLinker
- */
-export declare class TreeLinker implements IsTreeNode {
-    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
-    readonly classType: typeof TreeLinker;
-    /** The data stored in this tree node. */
-    data: any;
-    /** The sibling after this node, or null when this is the last child. */
-    next: IsTreeNode | null;
-    /** The sibling before this node, or null when this is the first child. */
-    prev: IsTreeNode | null;
-    /** The node this node is a child of, or null for a root node. */
-    parent: IsTreeNode;
-    /** The list of the children of this node, or null when it has none. */
-    children: IsArrayable<IsTreeNode>;
-    /**
-     * Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
-     * @param {Object} [settings={}] The settings for the new tree node.
-     * @param {*} [settings.data=null] The data to be stored in this tree node
-     * @param {TreeLinker} [settings.next=null] The reference to the next linker if any
-     * @param {TreeLinker} [settings.prev=null] The reference to the previous linker if any
-     * @param {LinkedTreeList} [settings.children=null] The references to child linkers if any
-     * @param {TreeLinker} [settings.parent=null] The reference to a parent linker if any
-     * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
-     */
-    constructor({ data, next, prev, children, parent, listClass }?: {
-        data?: any;
-        next?: IsTreeNode;
-        prev?: IsTreeNode;
-        children?: Array<any>;
-        parent?: IsTreeNode;
-        listClass?: any;
-    });
-    /**
-     * Create the children for this tree from an array. Each child becomes a tree linker with this node as its parent: an
-     * existing linker is kept as it is, an object with a data property gives the settings of the linker, and anything
-     * else is the data of the linker.
-     * @param {Array|null} children Provide an array of data / linker references to be children of this tree node.
-     * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
-     * @return {LinkedTreeList|null}
-     */
-    childrenFromArray(children?: Array<any> | null, listClass?: any): IsTree | any;
-    /**
-     * Make a new DoubleLinker from the data given if it is not already a valid Linker.
-     * @param {TreeLinker|*} linker Return a valid TreeLinker instance from given data, or even an already valid one.
-     * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
-     * @return {TreeLinker}
-     */
-    static make: (linker: TreeLinker | any, classType?: any) => IsTreeNode | any;
-    /**
-     * 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 tree-linkers.
-     * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
-     * @returns {{head: TreeLinker, tail: TreeLinker}}
-     */
-    static fromArray: (values?: Array<any>, classType?: any) => {
-        head: TreeLinker | any;
-        tail: TreeLinker | any;
-    };
-}
+/**
+ * doubly linked tree node.
+ */
+import { IsArrayable } from '../../recipes/IsArrayable';
+import { IsTreeNode } from '../../recipes/IsTreeNode';
+import { IsTree } from '../../recipes/IsTree';
+/**
+ * TreeLinker represents a node in a LinkedTreeList having a parent (or root) and child nodes.
+ * @extends DoubleLinker
+ */
+export declare class TreeLinker implements IsTreeNode {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
+    readonly classType: typeof TreeLinker;
+    /** The data stored in this tree node. */
+    data: any;
+    /** The sibling after this node, or null when this is the last child. */
+    next: IsTreeNode | null;
+    /** The sibling before this node, or null when this is the first child. */
+    prev: IsTreeNode | null;
+    /** The node this node is a child of, or null for a root node. */
+    parent: IsTreeNode;
+    /** The list of the children of this node, or null when it has none. */
+    children: IsArrayable<IsTreeNode>;
+    /**
+     * Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
+     * @param settings The settings for the new tree node.
+     * @param settings.data The data to be stored in this tree node
+     * @param settings.next The reference to the next linker if any
+     * @param settings.prev The reference to the previous linker if any
+     * @param settings.children The references to child linkers if any
+     * @param settings.parent The reference to a parent linker if any
+     * @param listClass Give the type of list to use for storing the children
+     */
+    constructor({ data, next, prev, children, parent, listClass }?: {
+        data?: any;
+        next?: IsTreeNode;
+        prev?: IsTreeNode;
+        children?: Array<any>;
+        parent?: IsTreeNode;
+        listClass?: any;
+    });
+    /**
+     * Create the children for this tree from an array. Each child becomes a tree linker with this node as its parent: an
+     * existing linker is kept as it is, an object with a data property gives the settings of the linker, and anything
+     * else is the data of the linker.
+     * @param children Provide an array of data / linker references to be children of this tree node.
+     * @param listClass Give the type of list to use for storing the children
+     */
+    childrenFromArray(children?: Array<any> | null, listClass?: any): IsTree | any;
+    /**
+     * Make a new DoubleLinker from the data given if it is not already a valid Linker.
+     * @param linker Return a valid TreeLinker instance from given data, or even an already valid one.
+     * @param classType Provide the type of IsTreeNode to use.
+     */
+    static make: (linker: TreeLinker | any, classType?: any) => IsTreeNode | any;
+    /**
+     * 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 tree-linkers.
+     * @param classType Provide the type of IsTreeNode to use.
+     */
+    static fromArray: (values?: Array<any>, classType?: any) => {
+        head: TreeLinker | any;
+        tail: TreeLinker | any;
+    };
+}

package/dist/collections/linked-tree-list/TreeLinker.js

@@ -1,94 +1,91 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.TreeLinker = void 0
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.map.js')
-var _DoubleLinker = require('../doubly-linked-list/DoubleLinker')
-var _LinkedTreeList = require('./LinkedTreeList')
-/**
- * TreeLinker represents a node in a LinkedTreeList having a parent (or root) and child nodes.
- * @extends DoubleLinker
- */
-class TreeLinker {
-  /**
-   * Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
-   * @param {Object} [settings={}] The settings for the new tree node.
-   * @param {*} [settings.data=null] The data to be stored in this tree node
-   * @param {TreeLinker} [settings.next=null] The reference to the next linker if any
-   * @param {TreeLinker} [settings.prev=null] The reference to the previous linker if any
-   * @param {LinkedTreeList} [settings.children=null] The references to child linkers if any
-   * @param {TreeLinker} [settings.parent=null] The reference to a parent linker if any
-   * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
-   */
-  constructor ({
-    data = null,
-    next = null,
-    prev = null,
-    children = null,
-    parent = null,
-    listClass = _LinkedTreeList.LinkedTreeList
-  } = {}) {
-    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
-    this.classType = TreeLinker
-    /** The data stored in this tree node. */
-    this.data = null
-    /** The sibling after this node, or null when this is the last child. */
-    this.next = null
-    /** The sibling before this node, or null when this is the first child. */
-    this.prev = null
-    /** The node this node is a child of, or null for a root node. */
-    this.parent = null
-    /** The list of the children of this node, or null when it has none. */
-    this.children = null
-    this.data = data
-    this.next = next
-    this.prev = prev
-    this.parent = parent
-    this.children = this.childrenFromArray(children, listClass)
-  }
-
-  /**
-   * Create the children for this tree from an array. Each child becomes a tree linker with this node as its parent: an
-   * existing linker is kept as it is, an object with a data property gives the settings of the linker, and anything
-   * else is the data of the linker.
-   * @param {Array|null} children Provide an array of data / linker references to be children of this tree node.
-   * @param {IsArrayable<IsTreeNode>} listClass Give the type of list to use for storing the children
-   * @return {LinkedTreeList|null}
-   */
-  childrenFromArray (children = null, listClass = _LinkedTreeList.LinkedTreeList) {
-    if (children === null) {
-      return null
-    }
-    // Every child is made into a tree linker (an existing one is kept as it is, and a plain value is the data) and is
-    // given this node as its parent
-    const nodes = children.map(child => {
-      const linker = this.classType.make(child, this.classType)
-      linker.parent = this
-      return linker
-    })
-    // Creates a linked-tree-list to store the children, which remembers this node as its parent even when it is empty
-    const list = listClass.fromArray(nodes, this.classType)
-    list.parent = this
-    return list
-  }
-}
-/**
- * Make a new DoubleLinker from the data given if it is not already a valid Linker.
- * @param {TreeLinker|*} linker Return a valid TreeLinker instance from given data, or even an already valid one.
- * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
- * @return {TreeLinker}
- */
-exports.TreeLinker = TreeLinker
-TreeLinker.make = (linker, classType = TreeLinker) => {
-  return _DoubleLinker.DoubleLinker.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 tree-linkers.
- * @param {IsTreeNode} [classType=TreeLinker] Provide the type of IsTreeNode to use.
- * @returns {{head: TreeLinker, tail: TreeLinker}}
- */
-TreeLinker.fromArray = (values = [], classType = TreeLinker) => _DoubleLinker.DoubleLinker.fromArray(values, classType)
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.TreeLinker = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.map.js')
+const _DoubleLinker = require('../doubly-linked-list/DoubleLinker')
+const _LinkedTreeList = require('./LinkedTreeList')
+/**
+ * TreeLinker represents a node in a LinkedTreeList having a parent (or root) and child nodes.
+ * @extends DoubleLinker
+ */
+class TreeLinker {
+  /**
+   * Create the new TreeLinker instance, provide the data and optionally set references for next, prev, parent, or children.
+   * @param settings The settings for the new tree node.
+   * @param settings.data The data to be stored in this tree node
+   * @param settings.next The reference to the next linker if any
+   * @param settings.prev The reference to the previous linker if any
+   * @param settings.children The references to child linkers if any
+   * @param settings.parent The reference to a parent linker if any
+   * @param listClass Give the type of list to use for storing the children
+   */
+  constructor ({
+    data = null,
+    next = null,
+    prev = null,
+    children = null,
+    parent = null,
+    listClass = _LinkedTreeList.LinkedTreeList
+  } = {}) {
+    /** The class used to create this instance, so that it can be recognized as valid without an instanceof check. */
+    this.classType = TreeLinker
+    /** The data stored in this tree node. */
+    this.data = null
+    /** The sibling after this node, or null when this is the last child. */
+    this.next = null
+    /** The sibling before this node, or null when this is the first child. */
+    this.prev = null
+    /** The node this node is a child of, or null for a root node. */
+    this.parent = null
+    /** The list of the children of this node, or null when it has none. */
+    this.children = null
+    this.data = data
+    this.next = next
+    this.prev = prev
+    this.parent = parent
+    this.children = this.childrenFromArray(children, listClass)
+  }
+
+  /**
+   * Create the children for this tree from an array. Each child becomes a tree linker with this node as its parent: an
+   * existing linker is kept as it is, an object with a data property gives the settings of the linker, and anything
+   * else is the data of the linker.
+   * @param children Provide an array of data / linker references to be children of this tree node.
+   * @param listClass Give the type of list to use for storing the children
+   */
+  childrenFromArray (children = null, listClass = _LinkedTreeList.LinkedTreeList) {
+    if (children === null) {
+      return null
+    }
+    // Every child is made into a tree linker (an existing one is kept as it is, and a plain value is the data) and is
+    // given this node as its parent
+    const nodes = children.map(child => {
+      const linker = this.classType.make(child, this.classType)
+      linker.parent = this
+      return linker
+    })
+    // Creates a linked-tree-list to store the children, which remembers this node as its parent even when it is empty
+    const list = listClass.fromArray(nodes, this.classType)
+    list.parent = this
+    return list
+  }
+}
+/**
+ * Make a new DoubleLinker from the data given if it is not already a valid Linker.
+ * @param linker Return a valid TreeLinker instance from given data, or even an already valid one.
+ * @param classType Provide the type of IsTreeNode to use.
+ */
+exports.TreeLinker = TreeLinker
+TreeLinker.make = (linker, classType = TreeLinker) => {
+  return _DoubleLinker.DoubleLinker.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 tree-linkers.
+ * @param classType Provide the type of IsTreeNode to use.
+ */
+TreeLinker.fromArray = (values = [], classType = TreeLinker) => _DoubleLinker.DoubleLinker.fromArray(values, classType)

package/dist/collections/queue/Queue.d.ts

@@ -1,59 +1,55 @@
-import { Linker } from '../linked-list/Linker';
-import { IsArrayable } from '../../recipes/IsArrayable';
-import { IsQueue } from '../../recipes/IsQueue';
-/**
- * A first-in-first-out collection: items are added to the back with enqueue and taken from the front with dequeue.
- * Any value can be queued (it is stored as it is, whether it is a function, an object or null), and adding and taking
- * are constant time. To queue tasks which are run as they are taken use TaskQueue.
- */
-export declare class Queue<T = any> implements IsQueue<T>, Iterable<T> {
-    /** The list which stores the queued items, the first is next to be dequeued. */
-    queuedList: IsArrayable<any>;
-    private readonly linkerClass;
-    /**
-     * Instantiate the queue, optionally with a list of items to start from.
-     * @param {IsArrayable|null} [queuedList=null] The list of linkers to start in this queue (the first is the front)
-     * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no queued list is given
-     * @param {Linker} [linkerClass=Linker] The class used to hold each queued item
-     */
-    constructor(queuedList?: IsArrayable<any> | null, listClass?: any, linkerClass?: typeof Linker);
-    /**
-     * Take the item from the front of the queue.
-     * @return {*|null} The item, or null when the queue is empty
-     */
-    dequeue(): T | null;
-    /**
-     * Check whether the queue has no items.
-     * @return {boolean}
-     */
-    empty(): boolean;
-    /**
-     * Add an item to the back of the queue.
-     * @param {*} data The item to add
-     * @return {Queue} This queue, so that adding can be chained
-     */
-    enqueue(data: T): this;
-    /**
-     * Look at the item at the front of the queue, without removing it.
-     * @return {*|null} The item, or null when the queue is empty
-     */
-    peek(): T | null;
-    /**
-     * Count the items in the queue.
-     * @return {number}
-     */
-    size(): number;
-    /**
-     * Iterate over the items from the front of the queue to the back, without removing them.
-     * @return {Iterator}
-     */
-    [Symbol.iterator](): Iterator<T>;
-    /**
-     * Convert an array to a Queue, the first value is at the front.
-     * @param {Array} [values=[]] The items to queue
-     * @param {IsArrayable} [listClass=LinkedList] The type of list used to store the items
-     * @param {Linker} [linkerClass=Linker] The class used to hold each queued item
-     * @returns {Queue}
-     */
-    static fromArray: <T_1 = any>(values?: Array<T_1>, listClass?: any, linkerClass?: typeof Linker) => Queue<T_1>;
-}
+import { Linker } from '../linked-list/Linker';
+import { IsArrayable } from '../../recipes/IsArrayable';
+import { IsQueue } from '../../recipes/IsQueue';
+/**
+ * A first-in-first-out collection: items are added to the back with enqueue and taken from the front with dequeue.
+ * Any value can be queued (it is stored as it is, whether it is a function, an object or null), and adding and taking
+ * are constant time. To queue tasks which are run as they are taken use TaskQueue.
+ */
+export declare class Queue<T = any> implements IsQueue<T>, Iterable<T> {
+    /** The list which stores the queued items, the first is next to be dequeued. */
+    queuedList: IsArrayable<any>;
+    private readonly linkerClass;
+    /**
+     * Instantiate the queue, optionally with a list of items to start from.
+     * @param queuedList The list of linkers to start in this queue (the first is the front)
+     * @param listClass The type of list to create when no queued list is given
+     * @param linkerClass The class used to hold each queued item
+     */
+    constructor(queuedList?: IsArrayable<any> | null, listClass?: any, linkerClass?: typeof Linker);
+    /**
+     * Take the item from the front of the queue.
+     * @returns The item, or null when the queue is empty
+     */
+    dequeue(): T | null;
+    /**
+     * Check whether the queue has no items.
+     */
+    empty(): boolean;
+    /**
+     * Add an item to the back of the queue.
+     * @param data The item to add
+     * @returns This queue, so that adding can be chained
+     */
+    enqueue(data: T): this;
+    /**
+     * Look at the item at the front of the queue, without removing it.
+     * @returns The item, or null when the queue is empty
+     */
+    peek(): T | null;
+    /**
+     * Count the items in the queue.
+     */
+    size(): number;
+    /**
+     * Iterate over the items from the front of the queue to the back, without removing them.
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Convert an array to a Queue, the first value is at the front.
+     * @param values The items to queue
+     * @param listClass The type of list used to store the items
+     * @param linkerClass The class used to hold each queued item
+     */
+    static fromArray: <T_1 = any>(values?: Array<T_1>, listClass?: any, linkerClass?: typeof Linker) => Queue<T_1>;
+}