collect-your-stuff 2.0.0 → 2.1.0

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

@@ -25,6 +25,8 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
     private tailCache;
     /** The number of linkers, kept up to date by the list's own methods so that the length does not need to walk the whole list (null when not known yet). */
     private countCache;
+    /** The node these linkers are the children of, remembered so that it is known even while the list is empty (undefined until it is known). */
+    private ownerNode;
     /**
      * Create the new LinkedTreeList instance, configure the list class.
      * @param {TreeLinker} [linkerClass=TreeLinker] The class used to wrap given data as tree linkers.
@@ -58,15 +60,17 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
      */
     get length(): number;
     /**
-     * Get the parent of this tree list.
-     * @return {TreeLinker}
+     * Get the parent of this tree list: the node these linkers are the children of (remembered even while the list is
+     * empty), or null for the linkers at the top of a tree.
+     * @return {TreeLinker|null}
      */
-    get parent(): TreeLinker;
+    get parent(): TreeLinker | null;
     /**
-     * Set the parent of this tree list
-     * @param {TreeLinker} parent The new node to use as the parent for this group of children
+     * Set the parent of this tree list: every linker in it gets the node as its parent, and the node gets this list as its
+     * children. Linkers added to the list later get this parent too.
+     * @param {TreeLinker|null} parent The new node to use as the parent for this group of children
      */
-    set parent(parent: TreeLinker);
+    set parent(parent: TreeLinker | null);
     /**
      * Return the root parent of the entire tree.
      * @return {TreeLinker}
@@ -74,24 +78,31 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
     get rootParent(): TreeLinker;
     /**
      * Set the children on a parent item.
-     * @param {TreeLinker} item The TreeLinker node that will be the parent of the children
-     * @param {LinkedTreeList} children The LinkedTreeList which has the child nodes to use
+     * @param {TreeLinker} item The TreeLinker node (one of the linkers of this list) that will be the parent of the children
+     * @param {LinkedTreeList|null} [children=null] The LinkedTreeList which has the child nodes to use, or null to remove the children of the item
+     * @throws {Error} When the item is not one of the linkers of this list
      */
-    setChildren(item: TreeLinker, children?: LinkedTreeList): void;
+    setChildren(item: TreeLinker, children?: LinkedTreeList | null): void;
     /**
-     * Insert a new node (or data) after a node.
-     * @param {TreeLinker|*} node The existing node as reference
+     * Make a linker of the given node (or data) and make this list's parent its parent.
+     * @param {TreeLinker|*} newNode The node (or data) which is being added to this list
+     * @returns {TreeLinker}
+     */
+    private adopt;
+    /**
+     * Insert a new node (or data) after a node. The new node gets the parent of this list.
+     * @param {TreeLinker|*} node The existing node as reference, or null to insert at the start of the list
      * @param {TreeLinker|*} newNode The new node to go after the existing node
      * @returns {LinkedTreeList}
      */
-    insertAfter(node: TreeLinker, newNode: TreeLinker | any): LinkedTreeList;
+    insertAfter(node: TreeLinker | null, newNode: TreeLinker | any): LinkedTreeList;
     /**
-     * Insert a new node (or data) before a node.
-     * @param {TreeLinker|*} node The existing node as reference
+     * Insert a new node (or data) before a node. The new node gets the parent of this list.
+     * @param {TreeLinker|*} node The existing node as reference, or null to insert at the end of the list
      * @param {TreeLinker|*} newNode The new node to go before the existing node
      * @returns {LinkedTreeList}
      */
-    insertBefore(node: TreeLinker, newNode: TreeLinker | any): LinkedTreeList;
+    insertBefore(node: TreeLinker | null, newNode: TreeLinker | any): LinkedTreeList;
     /**
      * Add a node (or data) after the given (or last) node in the list.
      * @param {TreeLinker|*} node The new node to add to the end of the list
@@ -107,11 +118,11 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
      */
     prepend(node: TreeLinker | any, before?: TreeLinker): LinkedTreeList;
     /**
-     * Remove a linker from this linked list.
+     * Remove a linker from this linked list. The removed node no longer has a parent.
      * @param {TreeLinker} node The node we wish to remove (and it will be returned after removal)
-     * @return {TreeLinker}
+     * @return {TreeLinker|null} The removed node, or null when there was nothing to remove
      */
-    remove(node: TreeLinker): TreeLinker;
+    remove(node: TreeLinker): TreeLinker | 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.
@@ -132,7 +143,8 @@ export declare class LinkedTreeList implements IsTree, Iterable<TreeLinker> {
      */
     forEach(callback: forEachCallback, thisArg?: LinkedTreeList): LinkedTreeList;
     /**
-     * Be able to iterate over this class.
+     * Be able to iterate over this class: the linkers of this list and everything below them (left-first). It stays within
+     * this list (it does not start at, or climb up to, the parents), use the parseTree service to parse a whole tree.
      * @returns {Iterator}
      */
     [Symbol.iterator](): Iterator<TreeLinker>;

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

@@ -4,6 +4,8 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 exports.LinkedTreeList = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.for-each.js')
 var _TreeLinker = require('./TreeLinker')
 var _TreeLinkerIterator = require('../../recipes/TreeLinkerIterator')
 var _DoublyLinkedList = require('../doubly-linked-list/DoublyLinkedList')
@@ -41,6 +43,8 @@ class LinkedTreeList {
     this.tailCache = null
     /** The number of linkers, kept up to date by the list's own methods so that the length does not need to walk the whole list (null when not known yet). */
     this.countCache = null
+    /** The node these linkers are the children of, remembered so that it is known even while the list is empty (undefined until it is known). */
+    this.ownerNode = undefined
     this.linkerClass = linkerClass
   }
 
@@ -93,22 +97,25 @@ class LinkedTreeList {
   }
 
   /**
-   * Get the parent of this tree list.
-   * @return {TreeLinker}
+   * Get the parent of this tree list: the node these linkers are the children of (remembered even while the list is
+   * empty), or null for the linkers at the top of a tree.
+   * @return {TreeLinker|null}
    */
   get parent () {
-    const first = this.first
-    if (first === null) {
-      return null
+    if (this.ownerNode !== undefined) {
+      return this.ownerNode
     }
-    return this.first.parent
+    const first = this.first
+    return first === null ? null : first.parent
   }
 
   /**
-   * Set the parent of this tree list
-   * @param {TreeLinker} parent The new node to use as the parent for this group of children
+   * Set the parent of this tree list: every linker in it gets the node as its parent, and the node gets this list as its
+   * children. Linkers added to the list later get this parent too.
+   * @param {TreeLinker|null} parent The new node to use as the parent for this group of children
    */
   set parent (parent) {
+    this.ownerNode = parent
     let current = this.first
     while (current !== null) {
       current.parent = parent
@@ -138,34 +145,57 @@ class LinkedTreeList {
 
   /**
    * Set the children on a parent item.
-   * @param {TreeLinker} item The TreeLinker node that will be the parent of the children
-   * @param {LinkedTreeList} children The LinkedTreeList which has the child nodes to use
+   * @param {TreeLinker} item The TreeLinker node (one of the linkers of this list) that will be the parent of the children
+   * @param {LinkedTreeList|null} [children=null] The LinkedTreeList which has the child nodes to use, or null to remove the children of the item
+   * @throws {Error} When the item is not one of the linkers of this list
    */
   setChildren (item, children = null) {
-    if (Array.from(this).indexOf(item) < 0) {
-      console.error('item is not a child of this')
+    // The item must be one of the linkers of this list (only the siblings are checked, not the whole tree)
+    let isChild = false
+    this.forEach(linker => {
+      if (linker === item) {
+        isChild = true
+      }
+    })
+    if (!isChild) {
+      throw new Error('The item is not one of the linkers of this list.')
+    }
+    if (children === null || typeof children === 'undefined') {
+      item.children = null
+      return
     }
     children.parent = item
   }
 
   /**
-   * Insert a new node (or data) after a node.
-   * @param {TreeLinker|*} node The existing node as reference
+   * Make a linker of the given node (or data) and make this list's parent its parent.
+   * @param {TreeLinker|*} newNode The node (or data) which is being added to this list
+   * @returns {TreeLinker}
+   */
+  adopt (newNode) {
+    const linker = this.linkerClass.make(newNode, this.linkerClass)
+    linker.parent = this.parent
+    return linker
+  }
+
+  /**
+   * Insert a new node (or data) after a node. The new node gets the parent of this list.
+   * @param {TreeLinker|*} node The existing node as reference, or null to insert at the start of the list
    * @param {TreeLinker|*} newNode The new node to go after the existing node
    * @returns {LinkedTreeList}
    */
   insertAfter (node, newNode) {
-    return _DoublyLinkedList.DoublyLinkedList.prototype.insertAfter.call(this, node, newNode)
+    return _DoublyLinkedList.DoublyLinkedList.prototype.insertAfter.call(this, node, this.adopt(newNode))
   }
 
   /**
-   * Insert a new node (or data) before a node.
-   * @param {TreeLinker|*} node The existing node as reference
+   * Insert a new node (or data) before a node. The new node gets the parent of this list.
+   * @param {TreeLinker|*} node The existing node as reference, or null to insert at the end of the list
    * @param {TreeLinker|*} newNode The new node to go before the existing node
    * @returns {LinkedTreeList}
    */
   insertBefore (node, newNode) {
-    return _DoublyLinkedList.DoublyLinkedList.prototype.insertBefore.call(this, node, newNode)
+    return _DoublyLinkedList.DoublyLinkedList.prototype.insertBefore.call(this, node, this.adopt(newNode))
   }
 
   /**
@@ -189,12 +219,19 @@ class LinkedTreeList {
   }
 
   /**
-   * Remove a linker from this linked list.
+   * Remove a linker from this linked list. The removed node no longer has a parent.
    * @param {TreeLinker} node The node we wish to remove (and it will be returned after removal)
-   * @return {TreeLinker}
+   * @return {TreeLinker|null} The removed node, or null when there was nothing to remove
    */
   remove (node) {
-    return _DoublyLinkedList.DoublyLinkedList.prototype.remove.call(this, node)
+    const owner = this.parent
+    const removed = _DoublyLinkedList.DoublyLinkedList.prototype.remove.call(this, node)
+    if (removed && removed.parent === owner) {
+      // Remember whose children these are (the list may now be empty), the removed node no longer has that parent
+      this.ownerNode = owner
+      removed.parent = null
+    }
+    return removed
   }
 
   /**
@@ -233,12 +270,14 @@ class LinkedTreeList {
   }
 
   /**
-   * Be able to iterate over this class.
+   * Be able to iterate over this class: the linkers of this list and everything below them (left-first). It stays within
+   * this list (it does not start at, or climb up to, the parents), use the parseTree service to parse a whole tree.
    * @returns {Iterator}
    */
   [Symbol.iterator] () {
-    const root = this.rootParent
-    return new _TreeLinkerIterator.TreeLinkerIterator(root)
+    // The linkers of this list and everything below them, left-first. It stays within this list: it does not start at,
+    // or climb up to, the parents (use the parseTree service to parse a whole tree)
+    return new _TreeLinkerIterator.TreeLinkerIterator(this.first, this.parent)
   }
 }
 /**

package/dist/collections/linked-tree-list/LinkedTreeList.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LinkedTreeList=void 0;var _TreeLinker=require("./TreeLinker"),_TreeLinkerIterator=require("../../recipes/TreeLinkerIterator"),_DoublyLinkedList=require("../doubly-linked-list/DoublyLinkedList");const borrowedGetter=(e,t)=>Object.getOwnPropertyDescriptor(_DoublyLinkedList.DoublyLinkedList.prototype,e).get.call(t);class LinkedTreeList{constructor(e=_TreeLinker.TreeLinker){this.classType=LinkedTreeList,this.innerList=null,this.initialized=!1,this.tailCache=null,this.countCache=null,this.linkerClass=e}initialize(e){return this.initialized?(console.warn("Attempt to initialize LinkedTreeList which is not empty."),this):(this.initialized=!0,this.innerList=e,this)}get list(){return this.innerList}get first(){return borrowedGetter("first",this)}get last(){return borrowedGetter("last",this)}get length(){return borrowedGetter("length",this)}get parent(){return null===this.first?null:this.first.parent}set parent(e){let t=this.first;for(;null!==t;)t.parent=e,t=t.next;e&&(e.children=this)}get rootParent(){let e=this.first;if(!e)return null;let t=this.first.parent;for(;null!==t;)e=t,t=e.parent;return e}setChildren(e,t=null){Array.from(this).indexOf(e)<0&&console.error("item is not a child of this"),t.parent=e}insertAfter(e,t){return _DoublyLinkedList.DoublyLinkedList.prototype.insertAfter.call(this,e,t)}insertBefore(e,t){return _DoublyLinkedList.DoublyLinkedList.prototype.insertBefore.call(this,e,t)}append(e,t=this.last){return _DoublyLinkedList.DoublyLinkedList.prototype.append.call(this,e,t)}prepend(e,t=this.first){return _DoublyLinkedList.DoublyLinkedList.prototype.prepend.call(this,e,t)}remove(e){return _DoublyLinkedList.DoublyLinkedList.prototype.remove.call(this,e)}reset(){return _DoublyLinkedList.DoublyLinkedList.prototype.reset.call(this)}item(e){return _DoublyLinkedList.DoublyLinkedList.prototype.item.call(this,e)}forEach(e,t=this){let r=0,i=t.first;for(;null!==i;)e(i,r,t),i=i.next,++r;return t}[Symbol.iterator](){let e=this.rootParent;return new _TreeLinkerIterator.TreeLinkerIterator(e)}}exports.LinkedTreeList=LinkedTreeList,LinkedTreeList.fromArray=(e=[],t=_TreeLinker.TreeLinker,r=LinkedTreeList)=>new r(t).initialize(t.fromArray(e).head);
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LinkedTreeList=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.for-each.js");var _TreeLinker=require("./TreeLinker"),_TreeLinkerIterator=require("../../recipes/TreeLinkerIterator"),_DoublyLinkedList=require("../doubly-linked-list/DoublyLinkedList");const borrowedGetter=(e,t)=>Object.getOwnPropertyDescriptor(_DoublyLinkedList.DoublyLinkedList.prototype,e).get.call(t);class LinkedTreeList{constructor(e=_TreeLinker.TreeLinker){this.classType=LinkedTreeList,this.innerList=null,this.initialized=!1,this.tailCache=null,this.countCache=null,this.ownerNode=void 0,this.linkerClass=e}initialize(e){return this.initialized?(console.warn("Attempt to initialize LinkedTreeList which is not empty."),this):(this.initialized=!0,this.innerList=e,this)}get list(){return this.innerList}get first(){return borrowedGetter("first",this)}get last(){return borrowedGetter("last",this)}get length(){return borrowedGetter("length",this)}get parent(){if(void 0!==this.ownerNode)return this.ownerNode;const e=this.first;return null===e?null:e.parent}set parent(e){this.ownerNode=e;let t=this.first;for(;null!==t;)t.parent=e,t=t.next;e&&(e.children=this)}get rootParent(){let e=this.first;if(!e)return null;let t=this.first.parent;for(;null!==t;)e=t,t=e.parent;return e}setChildren(e,t=null){let r=!1;if(this.forEach((t=>{t===e&&(r=!0)})),!r)throw new Error("The item is not one of the linkers of this list.");null!=t?t.parent=e:e.children=null}adopt(e){const t=this.linkerClass.make(e,this.linkerClass);return t.parent=this.parent,t}insertAfter(e,t){return _DoublyLinkedList.DoublyLinkedList.prototype.insertAfter.call(this,e,this.adopt(t))}insertBefore(e,t){return _DoublyLinkedList.DoublyLinkedList.prototype.insertBefore.call(this,e,this.adopt(t))}append(e,t=this.last){return _DoublyLinkedList.DoublyLinkedList.prototype.append.call(this,e,t)}prepend(e,t=this.first){return _DoublyLinkedList.DoublyLinkedList.prototype.prepend.call(this,e,t)}remove(e){const t=this.parent,r=_DoublyLinkedList.DoublyLinkedList.prototype.remove.call(this,e);return r&&r.parent===t&&(this.ownerNode=t,r.parent=null),r}reset(){return _DoublyLinkedList.DoublyLinkedList.prototype.reset.call(this)}item(e){return _DoublyLinkedList.DoublyLinkedList.prototype.item.call(this,e)}forEach(e,t=this){let r=0,i=t.first;for(;null!==i;)e(i,r,t),i=i.next,++r;return t}[Symbol.iterator](){return new _TreeLinkerIterator.TreeLinkerIterator(this.first,this.parent)}}exports.LinkedTreeList=LinkedTreeList,LinkedTreeList.fromArray=(e=[],t=_TreeLinker.TreeLinker,r=LinkedTreeList)=>new r(t).initialize(t.fromArray(e).head);

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

@@ -43,7 +43,9 @@ export declare class TreeLinker implements IsTreeNode {
         listClass?: any;
     });
     /**
-     * Create the children for this tree from an array.
+     * 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}

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

@@ -51,7 +51,9 @@ class TreeLinker {
   }
 
   /**
-   * Create the children for this tree from an array.
+   * 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}
@@ -60,10 +62,17 @@ class TreeLinker {
     if (children === null) {
       return null
     }
-    // Creates a linked-tree-list to store the children.
-    return listClass.fromArray(children.map(child => Object.assign({}, child, {
-      parent: this
-    })), this.classType)
+    // 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
   }
 }
 /**

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),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"),_LinkedTreeList=require("./LinkedTreeList");class TreeLinker{constructor({data:e=null,next:r=null,prev:i=null,children:n=null,parent:t=null,listClass:l=_LinkedTreeList.LinkedTreeList}={}){this.classType=TreeLinker,this.data=null,this.next=null,this.prev=null,this.parent=null,this.children=null,this.data=e,this.next=r,this.prev=i,this.parent=t,this.children=this.childrenFromArray(n,l)}childrenFromArray(e=null,r=_LinkedTreeList.LinkedTreeList){return null===e?null:r.fromArray(e.map((e=>Object.assign({},e,{parent:this}))),this.classType)}}exports.TreeLinker=TreeLinker,TreeLinker.make=(e,r=TreeLinker)=>_DoubleLinker.DoubleLinker.make(e,r),TreeLinker.fromArray=(e=[],r=TreeLinker)=>_DoubleLinker.DoubleLinker.fromArray(e,r);
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),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"),_LinkedTreeList=require("./LinkedTreeList");class TreeLinker{constructor({data:e=null,next:r=null,prev:i=null,children:n=null,parent:t=null,listClass:s=_LinkedTreeList.LinkedTreeList}={}){this.classType=TreeLinker,this.data=null,this.next=null,this.prev=null,this.parent=null,this.children=null,this.data=e,this.next=r,this.prev=i,this.parent=t,this.children=this.childrenFromArray(n,s)}childrenFromArray(e=null,r=_LinkedTreeList.LinkedTreeList){if(null===e)return null;const i=e.map((e=>{const r=this.classType.make(e,this.classType);return r.parent=this,r})),n=r.fromArray(i,this.classType);return n.parent=this,n}}exports.TreeLinker=TreeLinker,TreeLinker.make=(e,r=TreeLinker)=>_DoubleLinker.DoubleLinker.make(e,r),TreeLinker.fromArray=(e=[],r=TreeLinker)=>_DoubleLinker.DoubleLinker.fromArray(e,r);

package/dist/main.d.ts

@@ -63,7 +63,7 @@ declare const collectYourStuff: {
     };
     services: {
         parseTree: (tree: import("./main").IsTree, callback: import("./main").forEachCallback) => import("./main").IsTree;
-        parseTreeNext: (treeNode: import("./main").IsTreeNode) => import("./main").IsTreeNode | null;
+        parseTreeNext: (treeNode: import("./main").IsTreeNode, boundaryParent?: import("./main").IsTreeNode | null) => import("./main").IsTreeNode | null;
     };
 };
 export default collectYourStuff;

package/dist/recipes/TreeLinkerIterator.d.ts

@@ -4,11 +4,13 @@ import { IsTreeNode } from './IsTreeNode';
  */
 export declare class TreeLinkerIterator implements Iterator<IsTreeNode> {
     private current;
+    private readonly boundaryParent;
     /**
      * Create an iterator starting at the given item.
      * @param {IsTreeNode} current The item to start from.
+     * @param {IsTreeNode|null} [boundaryParent] The parent of the nodes to stay within (null for the top of a tree), the whole tree when not given.
      */
-    constructor(current: IsTreeNode);
+    constructor(current: IsTreeNode, boundaryParent?: IsTreeNode | null);
     /**
      * Get the current item and move on to the following one (left-first, down each branch).
      * @param {*} [value] Not used, present to match the Iterator interface.

package/dist/recipes/TreeLinkerIterator.js

@@ -12,9 +12,11 @@ class TreeLinkerIterator {
   /**
    * Create an iterator starting at the given item.
    * @param {IsTreeNode} current The item to start from.
+   * @param {IsTreeNode|null} [boundaryParent] The parent of the nodes to stay within (null for the top of a tree), the whole tree when not given.
    */
-  constructor (current) {
+  constructor (current, boundaryParent) {
     this.current = current
+    this.boundaryParent = boundaryParent
   }
 
   /**
@@ -27,7 +29,7 @@ class TreeLinkerIterator {
       value: this.current,
       done: !this.current
     }
-    this.current = (0, _parseTreeNext.parseTreeNext)(this.current)
+    this.current = (0, _parseTreeNext.parseTreeNext)(this.current, this.boundaryParent)
     return result
   }
 }

package/dist/recipes/TreeLinkerIterator.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.TreeLinkerIterator=void 0;var _parseTreeNext=require("../services/parseTreeNext");class TreeLinkerIterator{constructor(e){this.current=e}next(e){const r={value:this.current,done:!this.current};return this.current=(0,_parseTreeNext.parseTreeNext)(this.current),r}}exports.TreeLinkerIterator=TreeLinkerIterator;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.TreeLinkerIterator=void 0;var _parseTreeNext=require("../services/parseTreeNext");class TreeLinkerIterator{constructor(e,r){this.current=e,this.boundaryParent=r}next(e){const r={value:this.current,done:!this.current};return this.current=(0,_parseTreeNext.parseTreeNext)(this.current,this.boundaryParent),r}}exports.TreeLinkerIterator=TreeLinkerIterator;

package/dist/services/parseTreeNext.d.ts

@@ -8,7 +8,10 @@ import { IsTreeNode } from '../recipes/IsTreeNode';
  * 5. Repeat 3
  * 6. If no next child, return to parent and repeat 3
  * 7. Stop at root (next is null and parent is null
+ * A boundary can be given to parse only part of a tree: going back up to the parents stops at the boundary, so the
+ * parsing stays within the nodes whose parent is the boundary (and everything below them).
  * @param {IsTreeNode} treeNode Provide a node in a tree and get the next node (left-first approach)
+ * @param {IsTreeNode|null} [boundaryParent] The parent of the nodes to stay within, null for the nodes at the top of a tree. When it is not given the whole tree is parsed.
  * @returns {IsTreeNode|null}
  */
-export declare const parseTreeNext: (treeNode: IsTreeNode) => IsTreeNode | null;
+export declare const parseTreeNext: (treeNode: IsTreeNode, boundaryParent?: IsTreeNode | null) => IsTreeNode | null;

package/dist/services/parseTreeNext.js

@@ -13,35 +13,30 @@ exports.parseTreeNext = void 0
  * 5. Repeat 3
  * 6. If no next child, return to parent and repeat 3
  * 7. Stop at root (next is null and parent is null
+ * A boundary can be given to parse only part of a tree: going back up to the parents stops at the boundary, so the
+ * parsing stays within the nodes whose parent is the boundary (and everything below them).
  * @param {IsTreeNode} treeNode Provide a node in a tree and get the next node (left-first approach)
+ * @param {IsTreeNode|null} [boundaryParent] The parent of the nodes to stay within, null for the nodes at the top of a tree. When it is not given the whole tree is parsed.
  * @returns {IsTreeNode|null}
  */
-const parseTreeNext = treeNode => {
+const parseTreeNext = (treeNode, boundaryParent) => {
   if (!treeNode) {
     return null
   }
-  let test = null
   if (treeNode.children && treeNode.children.length) {
-    // Go down the left side of the tree
-    test = treeNode.children.first
+    return treeNode.children.first
   }
-  if (!test) {
-    // Reached the bottom, go the next node on the right
-    test = treeNode.next
+  if (treeNode.next) {
+    return treeNode.next
   }
-  if (!test && treeNode.parent) {
-    // No more child nodes, return to parent and check parent sibling on the right
-    let parentNext = treeNode.parent.next
-    let parent = treeNode.parent
-    while (parent && !parentNext) {
-      parentNext = parent.next
-      // Keep checking parent next, until there are no more parents, or we find the parent sibling
-      parent = parent.parent
+  // Nothing more below or beside this node, so go back up until there is a node which has a next (or the boundary)
+  let parent = treeNode.parent
+  while (parent && parent !== boundaryParent) {
+    if (parent.next) {
+      return parent.next
     }
-    // This may be the parent sibling, or it could be null indicating we are done
-    test = parentNext
+    parent = parent.parent
   }
-  // Finally, either use the node we found, or it may be null
-  return test
+  return null
 }
 exports.parseTreeNext = parseTreeNext

package/dist/services/parseTreeNext.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseTreeNext=void 0;const parseTreeNext=e=>{if(!e)return null;let r=null;if(e.children&&e.children.length&&(r=e.children.first),r||(r=e.next),!r&&e.parent){let t=e.parent.next,n=e.parent;for(;n&&!t;)t=n.next,n=n.parent;r=t}return r};exports.parseTreeNext=parseTreeNext;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.parseTreeNext=void 0;const parseTreeNext=(e,r)=>{if(!e)return null;if(e.children&&e.children.length)return e.children.first;if(e.next)return e.next;let t=e.parent;for(;t&&t!==r;){if(t.next)return t.next;t=t.parent}return null};exports.parseTreeNext=parseTreeNext;

package/dist/services/services.d.ts

@@ -9,5 +9,5 @@
  */
 export declare const services: {
     parseTree: (tree: import("../main").IsTree, callback: import("../main").forEachCallback) => import("../main").IsTree;
-    parseTreeNext: (treeNode: import("../main").IsTreeNode) => import("../main").IsTreeNode | null;
+    parseTreeNext: (treeNode: import("../main").IsTreeNode, boundaryParent?: import("../main").IsTreeNode | null) => import("../main").IsTreeNode | null;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "collect-your-stuff",
   "description": "Use a variety of collections to collect your stuff when building code.",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
   "author": "Joshua Heagle",