treenode.ts 0.7.0 → 0.9.0

package/dist/{TreeNode.d.ts → index.d.mts}

@@ -1,28 +1,35 @@
-import { IParseable } from "./IParseable";
 /**
- * Search callback passed to `.pre`, `.post`, and `.breadth`.
  * @public
  */
-export type SearchCallback<T> = (node: TreeNode<T>) => boolean | void;
+interface IParseable<T> {
+    model: T;
+    children: IParseable<T>[];
+}
+
 /**
- * Search methods on TreeNode, passed to `.flatten`.
+ * Search callback passed to `.pre`, `.post`, and `.breadth`.
  * @public
  */
-export type SearchStrategy = "pre" | "post" | "breadth";
+type SearchCallback<T> = (node: TreeNode<T>) => boolean | void;
 /**
- * Nested array representation of a tree.
+ * Search methods on TreeNode, passed to `.flatten`.
  * @public
  */
-export type NestedArray<T> = T | [T, ...(NestedArray<T> | T[])[]];
+type SearchStrategy = "pre" | "post" | "breadth";
 /**
  * @public
  */
-export declare class TreeNode<T> {
+declare class TreeNode<T> {
     model: T;
     parent: TreeNode<T> | null;
-    children: TreeNode<T>[];
     private _index;
+    private _children;
     constructor(model: T, parent?: TreeNode<T> | null, children?: TreeNode<T>[]);
+    /**
+     * Returns the children of the node as a readonly array.
+     * Use add(), drop(), or swap() to modify children.
+     */
+    get children(): readonly TreeNode<T>[];
     /**
      * Parses object into a tree and returns the root node.
      */
@@ -66,12 +73,23 @@ export declare class TreeNode<T> {
     get siblings(): TreeNode<T>[];
     /**
      * Add node as a child.
+     * @param child - The node to add
+     * @param index - Optional index to insert at. If omitted, appends to end.
+     * @throws RangeError if index is out of bounds (negative or > children.length)
+     */
+    add(child: TreeNode<T>, index?: number): TreeNode<T>;
+    /**
+     * Swap children at indices i and j.
+     * @param i - First index
+     * @param j - Second index
      */
-    add(child: TreeNode<T>): TreeNode<T>;
+    swap(i: number, j: number): void;
     /**
      * Add model as a child.
+     * @param model - The model to add
+     * @param index - Optional index to insert at. If omitted, appends to end.
      */
-    addModel(model: T): TreeNode<T>;
+    addModel(model: T, index?: number): TreeNode<T>;
     /**
      * Remove current node and its children from the tree and return.
      */
@@ -125,22 +143,10 @@ export declare class TreeNode<T> {
      * Returns a list of nodes.
      */
     flatten(method: SearchStrategy): TreeNode<T>[];
-    /**
-     * Returns a nested array representation of the tree.
-     * - Leaf -> value
-     * - Single child -> [model, ...childResult]
-     * - Multiple leaf children -> [model, [leaves...]]
-     * - Multiple mixed children -> [model, child1Result, child2Result, ...]
-     */
-    toNestedArray(): NestedArray<T>;
-    /**
-     * Creates a tree from a nested array representation.
-     * @see toNestedArray
-     */
-    static fromNestedArray<T>(input: NestedArray<T>): TreeNode<T>;
     /**
      * Returns an object representation of the tree.
      */
     toObject(): IParseable<T>;
 }
-//# sourceMappingURL=TreeNode.d.ts.map
+
+export { type IParseable, type SearchCallback, type SearchStrategy, TreeNode };

package/dist/index.d.ts

@@ -1,3 +1,152 @@
-export { TreeNode, SearchCallback, SearchStrategy, NestedArray } from './TreeNode';
-export { IParseable } from './IParseable';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * @public
+ */
+interface IParseable<T> {
+    model: T;
+    children: IParseable<T>[];
+}
+
+/**
+ * Search callback passed to `.pre`, `.post`, and `.breadth`.
+ * @public
+ */
+type SearchCallback<T> = (node: TreeNode<T>) => boolean | void;
+/**
+ * Search methods on TreeNode, passed to `.flatten`.
+ * @public
+ */
+type SearchStrategy = "pre" | "post" | "breadth";
+/**
+ * @public
+ */
+declare class TreeNode<T> {
+    model: T;
+    parent: TreeNode<T> | null;
+    private _index;
+    private _children;
+    constructor(model: T, parent?: TreeNode<T> | null, children?: TreeNode<T>[]);
+    /**
+     * Returns the children of the node as a readonly array.
+     * Use add(), drop(), or swap() to modify children.
+     */
+    get children(): readonly TreeNode<T>[];
+    /**
+     * Parses object into a tree and returns the root node.
+     */
+    static parse<T>(tree: IParseable<T>): TreeNode<T>;
+    /**
+     * Index of the node among its siblings.
+     */
+    get index(): number;
+    /**
+     * Indices from the root to the node.
+     */
+    get indices(): number[];
+    /**
+     * Compressed path key: positive = run of first-children, negative = child index.
+     * e.g. [0,0,0,1,0,0] -> "3,-1,2"
+     */
+    get pathKey(): string;
+    /**
+     * Returns true if the node has children.
+     */
+    get hasChildren(): boolean;
+    /**
+     * Returns true if the node is the root (has no parent).
+     */
+    get isRoot(): boolean;
+    /**
+     * Returns true if the node is a leaf (has no children).
+     */
+    get isLeaf(): boolean;
+    /**
+     * Returns the root node of the tree.
+     */
+    get root(): TreeNode<T>;
+    /**
+     * Returns the depth of the node (root is 0).
+     */
+    get depth(): number;
+    /**
+     * Returns siblings of this node (excluding self).
+     */
+    get siblings(): TreeNode<T>[];
+    /**
+     * Add node as a child.
+     * @param child - The node to add
+     * @param index - Optional index to insert at. If omitted, appends to end.
+     * @throws RangeError if index is out of bounds (negative or > children.length)
+     */
+    add(child: TreeNode<T>, index?: number): TreeNode<T>;
+    /**
+     * Swap children at indices i and j.
+     * @param i - First index
+     * @param j - Second index
+     */
+    swap(i: number, j: number): void;
+    /**
+     * Add model as a child.
+     * @param model - The model to add
+     * @param index - Optional index to insert at. If omitted, appends to end.
+     */
+    addModel(model: T, index?: number): TreeNode<T>;
+    /**
+     * Remove current node and its children from the tree and return.
+     */
+    drop(): TreeNode<T>;
+    /**
+     * Returns a deep copy of structure, shallow copy of model.
+     */
+    clone(): TreeNode<T>;
+    /**
+     * Returns a node given a list of indices
+     */
+    fetch(indices: number[]): TreeNode<T> | null;
+    /**
+     * Returns a node given a pathKey string.
+     * @see pathKey
+     */
+    fetchByPathKey(pathKey: string): TreeNode<T> | null;
+    /**
+     * Returns list of nodes to the root.
+     */
+    path(): TreeNode<T>[];
+    /**
+     * Iterates over a node's children and returns a new root node.
+     */
+    map<U>(callback: (node: TreeNode<T>) => U): TreeNode<U>;
+    /**
+     * Iterates over a node's children and returns a new root node.
+     */
+    mapAsync<U>(callback: (node: TreeNode<T>, parent: TreeNode<U> | undefined) => Promise<U>, parent?: TreeNode<U>): Promise<TreeNode<U>>;
+    /**
+     * Breadth-first search, return true in the callback to end iteration.
+     */
+    breadth(callback: SearchCallback<T>): TreeNode<T> | null;
+    /**
+     * Depth-first pre-order search, return true in the callback to end iteration.
+     */
+    pre(callback: SearchCallback<T>): TreeNode<T> | null;
+    /**
+     * Depth-first post-order search, return true in the callback to end iteration.
+     */
+    post(callback: SearchCallback<T>): TreeNode<T> | null;
+    /**
+     * Find the first node matching the predicate.
+     */
+    find(predicate: (node: TreeNode<T>) => boolean, method?: SearchStrategy): TreeNode<T> | null;
+    /**
+     * Find all nodes matching the predicate.
+     */
+    findAll(predicate: (node: TreeNode<T>) => boolean, method?: SearchStrategy): TreeNode<T>[];
+    /**
+     * Returns a list of nodes.
+     */
+    flatten(method: SearchStrategy): TreeNode<T>[];
+    /**
+     * Returns an object representation of the tree.
+     */
+    toObject(): IParseable<T>;
+}
+
+export { type IParseable, type SearchCallback, type SearchStrategy, TreeNode };

package/dist/index.js

@@ -1,6 +1,355 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeNode = void 0;
-var TreeNode_1 = require("./TreeNode");
-Object.defineProperty(exports, "TreeNode", { enumerable: true, get: function () { return TreeNode_1.TreeNode; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TreeNode: () => TreeNode
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/TreeNode.ts
+var TreeNode = class _TreeNode {
+  constructor(model, parent = null, children = []) {
+    this.model = model;
+    this.parent = parent;
+    this._index = 0;
+    this._children = [];
+    this._children = children;
+  }
+  /**
+   * Returns the children of the node as a readonly array.
+   * Use add(), drop(), or swap() to modify children.
+   */
+  get children() {
+    return this._children;
+  }
+  /**
+   * Parses object into a tree and returns the root node.
+   */
+  static parse(tree) {
+    const node = new _TreeNode(tree.model);
+    tree.children.forEach((child) => node.add(_TreeNode.parse(child)));
+    return node;
+  }
+  /**
+   * Index of the node among its siblings.
+   */
+  get index() {
+    return this._index;
+  }
+  /**
+   * Indices from the root to the node.
+   */
+  get indices() {
+    const indices = [];
+    let node = this;
+    while (node.parent) {
+      indices.push(node.index);
+      node = node.parent;
+    }
+    return indices.reverse();
+  }
+  /**
+   * Compressed path key: positive = run of first-children, negative = child index.
+   * e.g. [0,0,0,1,0,0] -> "3,-1,2"
+   */
+  get pathKey() {
+    const indices = this.indices;
+    if (indices.length === 0) return "";
+    const parts = [];
+    let zeroCount = 0;
+    for (const idx of indices) {
+      if (idx === 0) {
+        zeroCount++;
+      } else {
+        if (zeroCount > 0) {
+          parts.push(zeroCount);
+          zeroCount = 0;
+        }
+        parts.push(-idx);
+      }
+    }
+    if (zeroCount > 0) {
+      parts.push(zeroCount);
+    }
+    return parts.join(",");
+  }
+  /**
+   * Returns true if the node has children.
+   */
+  get hasChildren() {
+    return this._children.length > 0;
+  }
+  /**
+   * Returns true if the node is the root (has no parent).
+   */
+  get isRoot() {
+    return this.parent === null;
+  }
+  /**
+   * Returns true if the node is a leaf (has no children).
+   */
+  get isLeaf() {
+    return !this.hasChildren;
+  }
+  /**
+   * Returns the root node of the tree.
+   */
+  get root() {
+    let node = this;
+    while (node.parent) {
+      node = node.parent;
+    }
+    return node;
+  }
+  /**
+   * Returns the depth of the node (root is 0).
+   */
+  get depth() {
+    return this.parent ? this.parent.depth + 1 : 0;
+  }
+  /**
+   * Returns siblings of this node (excluding self).
+   */
+  get siblings() {
+    if (this.isRoot) return [];
+    return this.parent.children.filter((child) => child !== this);
+  }
+  /**
+   * Add node as a child.
+   * @param child - The node to add
+   * @param index - Optional index to insert at. If omitted, appends to end.
+   * @throws RangeError if index is out of bounds (negative or > children.length)
+   */
+  add(child, index) {
+    child.parent = this;
+    if (index === void 0) {
+      child._index = this._children.length;
+      this._children.push(child);
+    } else {
+      if (index < 0 || index > this._children.length) {
+        throw new RangeError(`Invalid index: ${index}. Valid range: 0 to ${this._children.length}`);
+      }
+      this._children.splice(index, 0, child);
+      for (let i = index; i < this._children.length; i++) {
+        this._children[i]._index = i;
+      }
+    }
+    return child;
+  }
+  /**
+   * Swap children at indices i and j.
+   * @param i - First index
+   * @param j - Second index
+   */
+  swap(i, j) {
+    if (i < 0 || j < 0 || i >= this._children.length || j >= this._children.length) {
+      throw new RangeError(`Invalid indices: ${i}, ${j}. Children length: ${this._children.length}`);
+    }
+    if (i === j) return;
+    const temp = this._children[i];
+    this._children[i] = this._children[j];
+    this._children[j] = temp;
+    this._children[i]._index = i;
+    this._children[j]._index = j;
+  }
+  /**
+   * Add model as a child.
+   * @param model - The model to add
+   * @param index - Optional index to insert at. If omitted, appends to end.
+   */
+  addModel(model, index) {
+    return this.add(new _TreeNode(model), index);
+  }
+  /**
+   * Remove current node and its children from the tree and return.
+   */
+  drop() {
+    if (!this.isRoot) {
+      const idx = this._index;
+      const parentChildren = this.parent._children;
+      parentChildren.splice(idx, 1);
+      for (let i = idx; i < parentChildren.length; i++) {
+        parentChildren[i]._index = i;
+      }
+      this.parent = null;
+      this._index = 0;
+    }
+    return this;
+  }
+  /**
+   * Returns a deep copy of structure, shallow copy of model.
+   */
+  clone() {
+    const node = new _TreeNode(this.model);
+    node._children = this._children.map((child, i) => {
+      const newChild = child.clone();
+      newChild.parent = node;
+      newChild._index = i;
+      return newChild;
+    });
+    return node;
+  }
+  /**
+   * Returns a node given a list of indices
+   */
+  fetch(indices) {
+    let node = this;
+    for (const i of indices) {
+      node = node.children[i];
+      if (!node) return null;
+    }
+    return node;
+  }
+  /**
+   * Returns a node given a pathKey string.
+   * @see pathKey
+   */
+  fetchByPathKey(pathKey) {
+    if (pathKey === "") return this;
+    const indices = [];
+    const parts = pathKey.split(",").map(Number);
+    for (const part of parts) {
+      if (part >= 0) {
+        for (let i = 0; i < part; i++) {
+          indices.push(0);
+        }
+      } else {
+        indices.push(-part);
+      }
+    }
+    return this.fetch(indices);
+  }
+  /**
+   * Returns list of nodes to the root.
+   */
+  path() {
+    const path = [];
+    let node = this;
+    while (node) {
+      path.push(node);
+      node = node.parent;
+    }
+    return path.reverse();
+  }
+  /**
+   * Iterates over a node's children and returns a new root node.
+   */
+  map(callback) {
+    const node = new _TreeNode(callback(this));
+    node._children = this._children.map((child, i) => {
+      const newChild = child.map(callback);
+      newChild.parent = node;
+      newChild._index = i;
+      return newChild;
+    });
+    return node;
+  }
+  /**
+   * Iterates over a node's children and returns a new root node.
+   */
+  async mapAsync(callback, parent) {
+    const node = new _TreeNode(await callback(this, parent));
+    node._children = await Promise.all(this._children.map(async (child, i) => {
+      const newChild = await child.mapAsync(callback, node);
+      newChild.parent = node;
+      newChild._index = i;
+      return newChild;
+    }));
+    return node;
+  }
+  /**
+   * Breadth-first search, return true in the callback to end iteration.
+   */
+  breadth(callback) {
+    const queue = [this];
+    let head = 0;
+    while (head < queue.length) {
+      const node = queue[head++];
+      if (callback(node)) return node;
+      for (let i = 0, childCount = node.children.length; i < childCount; i++) {
+        queue.push(node.children[i]);
+      }
+    }
+    return null;
+  }
+  /**
+   * Depth-first pre-order search, return true in the callback to end iteration.
+   */
+  pre(callback) {
+    if (callback(this)) return this;
+    for (let i = 0, childCount = this.children.length; i < childCount; i++) {
+      const node = this.children[i].pre(callback);
+      if (node) return node;
+    }
+    return null;
+  }
+  /**
+   * Depth-first post-order search, return true in the callback to end iteration.
+   */
+  post(callback) {
+    for (let i = 0, childCount = this.children.length; i < childCount; i++) {
+      const node = this.children[i].post(callback);
+      if (node) return node;
+    }
+    if (callback(this)) return this;
+    return null;
+  }
+  /**
+   * Find the first node matching the predicate.
+   */
+  find(predicate, method = "pre") {
+    return this[method]((node) => predicate(node));
+  }
+  /**
+   * Find all nodes matching the predicate.
+   */
+  findAll(predicate, method = "pre") {
+    const results = [];
+    this[method]((node) => {
+      if (predicate(node)) results.push(node);
+    });
+    return results;
+  }
+  /**
+   * Returns a list of nodes.
+   */
+  flatten(method) {
+    const list = [];
+    this[method].call(this, (node) => {
+      list.push(node);
+    });
+    return list;
+  }
+  /**
+   * Returns an object representation of the tree.
+   */
+  toObject() {
+    return {
+      model: this.model,
+      children: this.children.map((child) => child.toObject())
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TreeNode
+});
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,uCAAmF;AAA1E,oGAAA,QAAQ,OAAA"}
+{"version":3,"sources":["../src/index.ts","../src/TreeNode.ts"],"sourcesContent":["export { TreeNode, SearchCallback, SearchStrategy } from './TreeNode';\nexport { IParseable } from './IParseable';\n","import { IParseable } from \"./IParseable\";\n\n/**\n * Search callback passed to `.pre`, `.post`, and `.breadth`.\n * @public\n */\nexport type SearchCallback<T> = (node: TreeNode<T>) => boolean | void;\n\n/**\n * Search methods on TreeNode, passed to `.flatten`.\n * @public\n */\nexport type SearchStrategy = \"pre\" | \"post\" | \"breadth\";\n\n\n/**\n * @public\n */\nexport class TreeNode<T> {\n  private _index: number = 0;\n  private _children: TreeNode<T>[] = [];\n\n  constructor(\n    public model: T,\n    public parent: TreeNode<T> | null = null,\n    children: TreeNode<T>[] = []\n  ) {\n    this._children = children;\n  }\n\n  /**\n   * Returns the children of the node as a readonly array.\n   * Use add(), drop(), or swap() to modify children.\n   */\n  get children(): readonly TreeNode<T>[] {\n    return this._children;\n  }\n\n  /**\n   * Parses object into a tree and returns the root node.\n   */\n  static parse<T>(tree: IParseable<T>): TreeNode<T> {\n    const node = new TreeNode(tree.model);\n    tree.children.forEach((child) => node.add(TreeNode.parse(child)));\n    return node;\n  }\n\n  /**\n   * Index of the node among its siblings.\n   */\n  get index(): number {\n    return this._index;\n  }\n\n  /**\n   * Indices from the root to the node.\n   */\n  get indices(): number[] {\n    const indices: number[] = [];\n    let node: TreeNode<T> | null = this;\n    while (node.parent) {\n      indices.push(node.index);\n      node = node.parent;\n    }\n    return indices.reverse();\n  }\n\n  /**\n   * Compressed path key: positive = run of first-children, negative = child index.\n   * e.g. [0,0,0,1,0,0] -> \"3,-1,2\"\n   */\n  get pathKey(): string {\n    const indices = this.indices;\n    if (indices.length === 0) return '';\n\n    const parts: number[] = [];\n    let zeroCount = 0;\n\n    for (const idx of indices) {\n      if (idx === 0) {\n        zeroCount++;\n      } else {\n        if (zeroCount > 0) {\n          parts.push(zeroCount);\n          zeroCount = 0;\n        }\n        parts.push(-idx);\n      }\n    }\n\n    if (zeroCount > 0) {\n      parts.push(zeroCount);\n    }\n\n    return parts.join(',');\n  }\n\n  /**\n   * Returns true if the node has children.\n   */\n  get hasChildren(): boolean {\n    return this._children.length > 0;\n  }\n\n  /**\n   * Returns true if the node is the root (has no parent).\n   */\n  get isRoot(): boolean {\n    return this.parent === null;\n  }\n\n  /**\n   * Returns true if the node is a leaf (has no children).\n   */\n  get isLeaf(): boolean {\n    return !this.hasChildren;\n  }\n\n  /**\n   * Returns the root node of the tree.\n   */\n  get root(): TreeNode<T> {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    let node: TreeNode<T> = this;\n    while (node.parent) {\n      node = node.parent;\n    }\n    return node;\n  }\n\n  /**\n   * Returns the depth of the node (root is 0).\n   */\n  get depth(): number {\n    return this.parent ? this.parent.depth + 1 : 0;\n  }\n\n  /**\n   * Returns siblings of this node (excluding self).\n   */\n  get siblings(): TreeNode<T>[] {\n    if (this.isRoot) return [];\n    return this.parent!.children.filter((child) => child !== this);\n  }\n\n  /**\n   * Add node as a child.\n   * @param child - The node to add\n   * @param index - Optional index to insert at. If omitted, appends to end.\n   * @throws RangeError if index is out of bounds (negative or > children.length)\n   */\n  add(child: TreeNode<T>, index?: number): TreeNode<T> {\n    child.parent = this;\n    if (index === undefined) {\n      // Append at end\n      child._index = this._children.length;\n      this._children.push(child);\n    } else {\n      // Validate index\n      if (index < 0 || index > this._children.length) {\n        throw new RangeError(`Invalid index: ${index}. Valid range: 0 to ${this._children.length}`);\n      }\n      // Insert at specific index\n      this._children.splice(index, 0, child);\n      // Update indices for inserted and subsequent siblings\n      for (let i = index; i < this._children.length; i++) {\n        this._children[i]._index = i;\n      }\n    }\n    return child;\n  }\n\n  /**\n   * Swap children at indices i and j.\n   * @param i - First index\n   * @param j - Second index\n   */\n  swap(i: number, j: number): void {\n    if (i < 0 || j < 0 || i >= this._children.length || j >= this._children.length) {\n      throw new RangeError(`Invalid indices: ${i}, ${j}. Children length: ${this._children.length}`);\n    }\n    if (i === j) return;\n    const temp = this._children[i];\n    this._children[i] = this._children[j];\n    this._children[j] = temp;\n    this._children[i]._index = i;\n    this._children[j]._index = j;\n  }\n\n  /**\n   * Add model as a child.\n   * @param model - The model to add\n   * @param index - Optional index to insert at. If omitted, appends to end.\n   */\n  addModel(model: T, index?: number): TreeNode<T> {\n    return this.add(new TreeNode<T>(model), index);\n  }\n\n  /**\n   * Remove current node and its children from the tree and return.\n   */\n  drop(): TreeNode<T> {\n    if (!this.isRoot) {\n      const idx = this._index;\n      const parentChildren = (this.parent as TreeNode<T>)._children;\n      parentChildren.splice(idx, 1);\n      // Update indices of subsequent siblings\n      for (let i = idx; i < parentChildren.length; i++) {\n        parentChildren[i]._index = i;\n      }\n      this.parent = null;\n      this._index = 0;\n    }\n    return this;\n  }\n\n  /**\n   * Returns a deep copy of structure, shallow copy of model.\n   */\n  clone(): TreeNode<T> {\n    const node = new TreeNode<T>(this.model);\n    node._children = this._children.map((child, i) => {\n      const newChild = child.clone();\n      newChild.parent = node;\n      newChild._index = i;\n      return newChild;\n    });\n    return node;\n  }\n\n  /**\n   * Returns a node given a list of indices\n   */\n  fetch(indices: number[]): TreeNode<T> | null {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    let node: TreeNode<T> = this;\n    for (const i of indices) {\n      node = node.children[i];\n      if (!node) return null;\n    }\n    return node;\n  }\n\n  /**\n   * Returns a node given a pathKey string.\n   * @see pathKey\n   */\n  fetchByPathKey(pathKey: string): TreeNode<T> | null {\n    if (pathKey === '') return this;\n\n    const indices: number[] = [];\n    const parts = pathKey.split(',').map(Number);\n\n    for (const part of parts) {\n      if (part >= 0) {\n        for (let i = 0; i < part; i++) {\n          indices.push(0);\n        }\n      } else {\n        indices.push(-part);\n      }\n    }\n\n    return this.fetch(indices);\n  }\n\n  /**\n   * Returns list of nodes to the root.\n   */\n  path(): TreeNode<T>[] {\n    const path: TreeNode<T>[] = [];\n    let node: TreeNode<T> | null = this;\n    while (node) {\n      path.push(node);\n      node = node.parent;\n    }\n    return path.reverse();\n  }\n\n  /**\n   * Iterates over a node's children and returns a new root node.\n   */\n  map<U>(callback: (node: TreeNode<T>) => U): TreeNode<U> {\n    const node = new TreeNode<U>(callback(this));\n    node._children = this._children.map((child, i) => {\n      const newChild = child.map(callback);\n      newChild.parent = node;\n      newChild._index = i;\n      return newChild;\n    });\n    return node;\n  }\n\n  /**\n   * Iterates over a node's children and returns a new root node.\n   */\n  async mapAsync<U>(callback: (node: TreeNode<T>, parent: TreeNode<U> | undefined) => Promise<U>, parent?: TreeNode<U>): Promise<TreeNode<U>>{\n    const node = new TreeNode<U>(await callback(this, parent));\n    node._children = await Promise.all(this._children.map(async (child, i) => {\n      const newChild = await child.mapAsync(callback, node);\n      newChild.parent = node;\n      newChild._index = i;\n      return newChild;\n    }));\n    return node;\n  }\n\n  /**\n   * Breadth-first search, return true in the callback to end iteration.\n   */\n  breadth(callback: SearchCallback<T>): TreeNode<T> | null {\n    const queue: TreeNode<T>[] = [this];\n    let head = 0;\n\n    while (head < queue.length) {\n      const node = queue[head++];\n      if (callback(node)) return node;\n      for (let i = 0, childCount = node.children.length; i < childCount; i++) {\n        queue.push(node.children[i]);\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Depth-first pre-order search, return true in the callback to end iteration.\n   */\n  pre(callback: SearchCallback<T>): TreeNode<T> | null {\n    if (callback(this)) return this;\n\n    for (let i = 0, childCount = this.children.length; i < childCount; i++) {\n      const node = this.children[i].pre(callback);\n      if (node) return node;\n    }\n\n    return null;\n  }\n\n  /**\n   * Depth-first post-order search, return true in the callback to end iteration.\n   */\n  post(callback: SearchCallback<T>): TreeNode<T> | null {\n    for (let i = 0, childCount = this.children.length; i < childCount; i++) {\n      const node = this.children[i].post(callback);\n      if (node) return node;\n    }\n\n    if (callback(this)) return this;\n\n    return null;\n  }\n\n  /**\n   * Find the first node matching the predicate.\n   */\n  find(predicate: (node: TreeNode<T>) => boolean, method: SearchStrategy = \"pre\"): TreeNode<T> | null {\n    return this[method]((node) => predicate(node));\n  }\n\n  /**\n   * Find all nodes matching the predicate.\n   */\n  findAll(predicate: (node: TreeNode<T>) => boolean, method: SearchStrategy = \"pre\"): TreeNode<T>[] {\n    const results: TreeNode<T>[] = [];\n    this[method]((node) => {\n      if (predicate(node)) results.push(node);\n    });\n    return results;\n  }\n\n  /**\n   * Returns a list of nodes.\n   */\n  flatten(method: SearchStrategy): TreeNode<T>[] {\n    const list: TreeNode<T>[] = [];\n    this[method].call(this, (node) => {\n      list.push(node);\n    });\n    return list;\n  }\n\n  /**\n   * Returns an object representation of the tree.\n   */\n  toObject(): IParseable<T> {\n    return {\n      model: this.model,\n      children: this.children.map((child) => child.toObject()),\n    };\n  }\n}\n"],"mappings":"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","names":[]}