@elliemae/ds-tree-model 3.45.0-rc.0 → 3.45.0-rc.2

package/dist/cjs/DSTree.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/DSTree.ts", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["/* eslint-disable no-underscore-dangle */\nimport type {\n  AddOptions,\n  AnyObjectWithoutReservedKeys,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions,\n  JSONThatCanContrusctATree,\n  Item,\n} from './types.js';\nimport { Node } from './Node.js';\n\nexport class DSTree<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  private root: Node<AppInterface>;\n\n  private _hash: number;\n\n  private nodes: Record<string | number, Node<AppInterface>>;\n\n  getUniqueId: (item: Item<AppInterface>) => string | number;\n\n  constructor(\n    item: JSONThatCanContrusctATree<AppInterface>,\n    options: { getUniqueId: (item: Item<AppInterface>) => string | number },\n  ) {\n    this.getUniqueId = options.getUniqueId;\n    this.root = new Node<AppInterface>(item, { childIndex: 0, depth: 0, tree: this });\n    this.nodes = {};\n    this._hash = 0;\n\n    // autocalculate a dictionary where dsId are keys and nodes are values\n    // and add the tree link to each node\n    this.root.walk((node) => {\n      this.nodes[node.dsId] = node;\n      return true;\n    });\n  }\n\n  addNodeToNodesDictionary(node: Node<AppInterface>): void {\n    // check that we have no repeated ids\n    if (this.nodes[node.dsId]) {\n      throw new Error(`DSTree: repeated dsId ${node.dsId}`);\n    }\n\n    this.nodes[node.dsId] = node;\n  }\n\n  removeNodeFromNodesDictionary(node: Node<AppInterface>): void {\n    delete this.nodes[node.dsId];\n  }\n\n  get hash(): number {\n    return this._hash;\n  }\n\n  getRoot = (): Node<AppInterface> => this.root;\n\n  getNode = (id: string | number): Node<AppInterface> => this.nodes[id];\n\n  getNodes = (): Record<string, Node<AppInterface>> => this.nodes;\n\n  walk = (callback: (node: Node<AppInterface>) => boolean): void => {\n    this.root.walk(callback);\n  };\n\n  walkParents = (callback: (node: Node<AppInterface>) => boolean): void => {\n    this.root.walkParents(callback);\n  };\n\n  findNode = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface> | null =>\n    this.root.findNode(callback);\n\n  findAllNodes = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface>[] =>\n    this.root.findAllNodes(callback);\n\n  flatten = (): Node<AppInterface>[] => this.root.flatten();\n\n  addNode = (\n    item: JSONThatCanContrusctATree<AppInterface>,\n    options: AddOptions<AppInterface> = {},\n  ): Node<AppInterface> => {\n    const { position, parent, callback } = options;\n    const parentDefault = parent || this.root;\n    const positionDefault = position ?? parentDefault.children.length;\n\n    // create node and add it to the parent\n    const node = new Node<AppInterface>(item, {\n      childIndex: positionDefault,\n      depth: parentDefault.depth + 1,\n      parent: parentDefault,\n      tree: this,\n    });\n    this.getNode(parentDefault.dsId).addNode(node);\n\n    // change hash\n    this._hash += 1;\n\n    // invoke the callback if present\n    callback?.(node, this);\n\n    return node;\n  };\n\n  removeNode = (id: string | number, options: RemoveOptions<AppInterface> = {}): Node<AppInterface> => {\n    const node = this.getNode(id);\n    if (!node) throw new Error(`Node with id ${id} not found`);\n\n    node.removeNode();\n\n    // change hash\n    this._hash += 1;\n\n    // invoke the callback if present\n    options.callback?.(node, this);\n\n    return node;\n  };\n\n  moveNode = (id: string | number, options: MoveOptions<AppInterface> = {}): Node<AppInterface> => {\n    const removedNode = this.removeNode(id);\n    const node = this.addNode(removedNode.getJson(), options);\n\n    this._hash += 1;\n\n    return node;\n  };\n\n  replaceNode = (\n    id: string | number,\n    item: JSONThatCanContrusctATree<AppInterface>,\n    options: MutateOptions<AppInterface> = {},\n  ): Node<AppInterface> => {\n    const removedNode = this.removeNode(id);\n    const node = this.addNode(item, { parent: removedNode.parent, position: removedNode.childIndex });\n\n    this._hash += 1;\n\n    // invoke the callback if present\n    options.callback?.(node, this);\n\n    return node;\n  };\n\n  getPath = (id: string | number): Node<AppInterface>[] => this.getRoot().getPath(id);\n\n  getPathIds = (id: string | number) => this.getRoot().getPathIds(id);\n}\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADUvB,kBAAqB;AAEd,MAAM,OAAoF;AAAA,EAS/F,YACE,MACA,SACA;AA+BF,mBAAU,MAA0B,KAAK;AAEzC,mBAAU,CAAC,OAA4C,KAAK,MAAM,EAAE;AAEpE,oBAAW,MAA0C,KAAK;AAE1D,gBAAO,CAAC,aAA0D;AAChE,WAAK,KAAK,KAAK,QAAQ;AAAA,IACzB;AAEA,uBAAc,CAAC,aAA0D;AACvE,WAAK,KAAK,YAAY,QAAQ;AAAA,IAChC;AAEA,oBAAW,CAAC,aACV,KAAK,KAAK,SAAS,QAAQ;AAE7B,wBAAe,CAAC,aACd,KAAK,KAAK,aAAa,QAAQ;AAEjC,mBAAU,MAA4B,KAAK,KAAK,QAAQ;AAExD,mBAAU,CACR,MACA,UAAoC,CAAC,MACd;AACvB,YAAM,EAAE,UAAU,QAAQ,SAAS,IAAI;AACvC,YAAM,gBAAgB,UAAU,KAAK;AACrC,YAAM,kBAAkB,YAAY,cAAc,SAAS;AAG3D,YAAM,OAAO,IAAI,iBAAmB,MAAM;AAAA,QACxC,YAAY;AAAA,QACZ,OAAO,cAAc,QAAQ;AAAA,QAC7B,QAAQ;AAAA,QACR,MAAM;AAAA,MACR,CAAC;AACD,WAAK,QAAQ,cAAc,IAAI,EAAE,QAAQ,IAAI;AAG7C,WAAK,SAAS;AAGd,iBAAW,MAAM,IAAI;AAErB,aAAO;AAAA,IACT;AAEA,sBAAa,CAAC,IAAqB,UAAuC,CAAC,MAA0B;AACnG,YAAM,OAAO,KAAK,QAAQ,EAAE;AAC5B,UAAI,CAAC,KAAM,OAAM,IAAI,MAAM,gBAAgB,EAAE,YAAY;AAEzD,WAAK,WAAW;AAGhB,WAAK,SAAS;AAGd,cAAQ,WAAW,MAAM,IAAI;AAE7B,aAAO;AAAA,IACT;AAEA,oBAAW,CAAC,IAAqB,UAAqC,CAAC,MAA0B;AAC/F,YAAM,cAAc,KAAK,WAAW,EAAE;AACtC,YAAM,OAAO,KAAK,QAAQ,YAAY,QAAQ,GAAG,OAAO;AAExD,WAAK,SAAS;AAEd,aAAO;AAAA,IACT;AAEA,uBAAc,CACZ,IACA,MACA,UAAuC,CAAC,MACjB;AACvB,YAAM,cAAc,KAAK,WAAW,EAAE;AACtC,YAAM,OAAO,KAAK,QAAQ,MAAM,EAAE,QAAQ,YAAY,QAAQ,UAAU,YAAY,WAAW,CAAC;AAEhG,WAAK,SAAS;AAGd,cAAQ,WAAW,MAAM,IAAI;AAE7B,aAAO;AAAA,IACT;AAEA,mBAAU,CAAC,OAA8C,KAAK,QAAQ,EAAE,QAAQ,EAAE;AAElF,sBAAa,CAAC,OAAwB,KAAK,QAAQ,EAAE,WAAW,EAAE;AAxHhE,SAAK,cAAc,QAAQ;AAC3B,SAAK,OAAO,IAAI,iBAAmB,MAAM,EAAE,YAAY,GAAG,OAAO,GAAG,MAAM,KAAK,CAAC;AAChF,SAAK,QAAQ,CAAC;AACd,SAAK,QAAQ;AAIb,SAAK,KAAK,KAAK,CAAC,SAAS;AACvB,WAAK,MAAM,KAAK,IAAI,IAAI;AACxB,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA,EAEA,yBAAyB,MAAgC;AAEvD,QAAI,KAAK,MAAM,KAAK,IAAI,GAAG;AACzB,YAAM,IAAI,MAAM,yBAAyB,KAAK,IAAI,EAAE;AAAA,IACtD;AAEA,SAAK,MAAM,KAAK,IAAI,IAAI;AAAA,EAC1B;AAAA,EAEA,8BAA8B,MAAgC;AAC5D,WAAO,KAAK,MAAM,KAAK,IAAI;AAAA,EAC7B;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK;AAAA,EACd;AA6FF;",
+  "sourcesContent": ["/* eslint-disable no-underscore-dangle */\nimport type {\n  AddOptions,\n  AnyObjectWithoutReservedKeys,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions,\n  Item,\n} from './types.js';\nimport { Node } from './Node.js';\n\nexport class DSTree<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  private root: Node<AppInterface>;\n\n  private _hash: number;\n\n  private nodes: Record<string | number, Node<AppInterface>>;\n\n  getUniqueId: (item: Item<AppInterface>) => string | number;\n\n  constructor(item: Item<AppInterface>, options: { getUniqueId: (item: Item<AppInterface>) => string | number }) {\n    this.getUniqueId = options.getUniqueId;\n    this.root = new Node<AppInterface>(item, { childIndex: 0, depth: 0, tree: this });\n    this.nodes = {};\n    this._hash = 0;\n\n    // autocalculate a dictionary where dsId are keys and nodes are values\n    // and add the tree link to each node\n    this.root.walk((node) => {\n      this.nodes[node.dsId] = node;\n      return true;\n    });\n  }\n\n  addNodeToNodesDictionary(node: Node<AppInterface>): void {\n    // check that we have no repeated ids\n    if (this.nodes[node.dsId]) {\n      throw new Error(`DSTree: repeated dsId ${node.dsId}`);\n    }\n\n    this.nodes[node.dsId] = node;\n  }\n\n  removeNodeFromNodesDictionary(node: Node<AppInterface>): void {\n    delete this.nodes[node.dsId];\n  }\n\n  get hash(): number {\n    return this._hash;\n  }\n\n  getRoot = (): Node<AppInterface> => this.root;\n\n  getNode = (id: string | number): Node<AppInterface> => this.nodes[id];\n\n  getNodes = (): Record<string, Node<AppInterface>> => this.nodes;\n\n  walk = (callback: (node: Node<AppInterface>) => boolean): void => {\n    this.root.walk(callback);\n  };\n\n  walkParents = (callback: (node: Node<AppInterface>) => boolean): void => {\n    this.root.walkParents(callback);\n  };\n\n  findNode = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface> | null =>\n    this.root.findNode(callback);\n\n  findAllNodes = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface>[] =>\n    this.root.findAllNodes(callback);\n\n  flatten = (): Node<AppInterface>[] => this.root.flatten();\n\n  addNode = (item: Item<AppInterface>, options: AddOptions<AppInterface> = {}): Node<AppInterface> => {\n    const { position, parent, callback } = options;\n    const parentDefault = parent || this.root;\n    const positionDefault = position ?? parentDefault.children.length;\n\n    // create node and add it to the parent\n    const node = new Node<AppInterface>(item, {\n      childIndex: positionDefault,\n      depth: parentDefault.depth + 1,\n      parent: parentDefault,\n      tree: this,\n    });\n    this.getNode(parentDefault.dsId).addNode(node);\n\n    // change hash\n    this._hash += 1;\n\n    // invoke the callback if present\n    callback?.(node, this);\n\n    return node;\n  };\n\n  removeNode = (id: string | number, options: RemoveOptions<AppInterface> = {}): Node<AppInterface> => {\n    const node = this.getNode(id);\n    if (!node) throw new Error(`Node with id ${id} not found`);\n\n    node.removeNode();\n\n    // change hash\n    this._hash += 1;\n\n    // invoke the callback if present\n    options.callback?.(node, this);\n\n    return node;\n  };\n\n  moveNode = (id: string | number, options: MoveOptions<AppInterface> = {}): Node<AppInterface> => {\n    const removedNode = this.removeNode(id);\n    const node = this.addNode(removedNode.getJson(), options);\n\n    this._hash += 1;\n\n    return node;\n  };\n\n  replaceNode = (\n    id: string | number,\n    item: Item<AppInterface>,\n    options: MutateOptions<AppInterface> = {},\n  ): Node<AppInterface> => {\n    const removedNode = this.removeNode(id);\n    const node = this.addNode(item, { parent: removedNode.parent, position: removedNode.childIndex });\n\n    this._hash += 1;\n\n    // invoke the callback if present\n    options.callback?.(node, this);\n\n    return node;\n  };\n\n  getPath = (id: string | number): Node<AppInterface>[] => this.getRoot().getPath(id);\n\n  getPathIds = (id: string | number) => this.getRoot().getPathIds(id);\n}\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADSvB,kBAAqB;AAEd,MAAM,OAAoF;AAAA,EAS/F,YAAY,MAA0B,SAAyE;AA+B/G,mBAAU,MAA0B,KAAK;AAEzC,mBAAU,CAAC,OAA4C,KAAK,MAAM,EAAE;AAEpE,oBAAW,MAA0C,KAAK;AAE1D,gBAAO,CAAC,aAA0D;AAChE,WAAK,KAAK,KAAK,QAAQ;AAAA,IACzB;AAEA,uBAAc,CAAC,aAA0D;AACvE,WAAK,KAAK,YAAY,QAAQ;AAAA,IAChC;AAEA,oBAAW,CAAC,aACV,KAAK,KAAK,SAAS,QAAQ;AAE7B,wBAAe,CAAC,aACd,KAAK,KAAK,aAAa,QAAQ;AAEjC,mBAAU,MAA4B,KAAK,KAAK,QAAQ;AAExD,mBAAU,CAAC,MAA0B,UAAoC,CAAC,MAA0B;AAClG,YAAM,EAAE,UAAU,QAAQ,SAAS,IAAI;AACvC,YAAM,gBAAgB,UAAU,KAAK;AACrC,YAAM,kBAAkB,YAAY,cAAc,SAAS;AAG3D,YAAM,OAAO,IAAI,iBAAmB,MAAM;AAAA,QACxC,YAAY;AAAA,QACZ,OAAO,cAAc,QAAQ;AAAA,QAC7B,QAAQ;AAAA,QACR,MAAM;AAAA,MACR,CAAC;AACD,WAAK,QAAQ,cAAc,IAAI,EAAE,QAAQ,IAAI;AAG7C,WAAK,SAAS;AAGd,iBAAW,MAAM,IAAI;AAErB,aAAO;AAAA,IACT;AAEA,sBAAa,CAAC,IAAqB,UAAuC,CAAC,MAA0B;AACnG,YAAM,OAAO,KAAK,QAAQ,EAAE;AAC5B,UAAI,CAAC,KAAM,OAAM,IAAI,MAAM,gBAAgB,EAAE,YAAY;AAEzD,WAAK,WAAW;AAGhB,WAAK,SAAS;AAGd,cAAQ,WAAW,MAAM,IAAI;AAE7B,aAAO;AAAA,IACT;AAEA,oBAAW,CAAC,IAAqB,UAAqC,CAAC,MAA0B;AAC/F,YAAM,cAAc,KAAK,WAAW,EAAE;AACtC,YAAM,OAAO,KAAK,QAAQ,YAAY,QAAQ,GAAG,OAAO;AAExD,WAAK,SAAS;AAEd,aAAO;AAAA,IACT;AAEA,uBAAc,CACZ,IACA,MACA,UAAuC,CAAC,MACjB;AACvB,YAAM,cAAc,KAAK,WAAW,EAAE;AACtC,YAAM,OAAO,KAAK,QAAQ,MAAM,EAAE,QAAQ,YAAY,QAAQ,UAAU,YAAY,WAAW,CAAC;AAEhG,WAAK,SAAS;AAGd,cAAQ,WAAW,MAAM,IAAI;AAE7B,aAAO;AAAA,IACT;AAEA,mBAAU,CAAC,OAA8C,KAAK,QAAQ,EAAE,QAAQ,EAAE;AAElF,sBAAa,CAAC,OAAwB,KAAK,QAAQ,EAAE,WAAW,EAAE;AArHhE,SAAK,cAAc,QAAQ;AAC3B,SAAK,OAAO,IAAI,iBAAmB,MAAM,EAAE,YAAY,GAAG,OAAO,GAAG,MAAM,KAAK,CAAC;AAChF,SAAK,QAAQ,CAAC;AACd,SAAK,QAAQ;AAIb,SAAK,KAAK,KAAK,CAAC,SAAS;AACvB,WAAK,MAAM,KAAK,IAAI,IAAI;AACxB,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA,EAEA,yBAAyB,MAAgC;AAEvD,QAAI,KAAK,MAAM,KAAK,IAAI,GAAG;AACzB,YAAM,IAAI,MAAM,yBAAyB,KAAK,IAAI,EAAE;AAAA,IACtD;AAEA,SAAK,MAAM,KAAK,IAAI,IAAI;AAAA,EAC1B;AAAA,EAEA,8BAA8B,MAAgC;AAC5D,WAAO,KAAK,MAAM,KAAK,IAAI;AAAA,EAC7B;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK;AAAA,EACd;AA0FF;",
   "names": []
 }

package/dist/cjs/Node.js

@@ -45,7 +45,7 @@ class Node {
       this._hash += 1;
     };
     this.getCleanItem = (item) => {
-      const plainItem = (0, import_lodash.omit)(item, ["subitems"]);
+      const { subitems, ...plainItem } = item;
       return (0, import_lodash.cloneDeep)(plainItem);
     };
     this.walk = (callback) => {
@@ -128,22 +128,27 @@ class Node {
       });
       this._hash += 1;
     };
-    const itemCasted = item;
-    this.dsId = tree.getUniqueId(itemCasted);
+    this.dsId = tree.getUniqueId(item);
     this.childIndex = childIndex;
     this.depth = depth;
     this.parent = parent ?? null;
     this.tree = tree;
     this._hash = 0;
-    this.children = item.subitems?.map(
-      (subitem, index) => new Node(subitem, {
-        childIndex: index,
-        depth: depth + 1,
-        parent: this,
-        tree
-      })
-    ) ?? [];
-    this.plainItem = this.getCleanItem(itemCasted);
+    this.children = [];
+    this.plainChildren = [];
+    const subitems = item.subitems ?? [];
+    subitems.forEach((subitem, index) => {
+      this.plainChildren.push(this.getCleanItem(subitem));
+      this.children.push(
+        new Node(subitem, {
+          childIndex: index,
+          depth: depth + 1,
+          parent: this,
+          tree
+        })
+      );
+    });
+    this.plainItem = this.getCleanItem(item);
   }
   // ===========================================================================
   // READ METHODS

package/dist/cjs/Node.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/Node.ts", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["/* eslint-disable no-underscore-dangle */\n/* eslint-disable no-use-before-define */\n/* eslint-disable max-params */\nimport { cloneDeep, omit } from 'lodash';\nimport type { DSTree } from './DSTree.js';\nimport type { NodeConstructorOptions, AnyObjectWithoutReservedKeys, JSONThatCanContrusctATree, Item } from './types.js';\n\nexport class Node<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  dsId: string | number;\n\n  childIndex: number;\n\n  depth: number;\n\n  plainItem: Omit<Item<AppInterface>, 'subitems'>;\n\n  parent: Node<AppInterface> | null;\n\n  children: Node<AppInterface>[];\n\n  private tree!: DSTree<AppInterface>;\n\n  private _hash: number;\n\n  constructor(\n    item: JSONThatCanContrusctATree<AppInterface>,\n    { childIndex, depth, parent, tree }: NodeConstructorOptions<AppInterface>,\n  ) {\n    const itemCasted = item as Item<AppInterface>;\n    this.dsId = tree.getUniqueId(itemCasted);\n    this.childIndex = childIndex;\n    this.depth = depth;\n    this.parent = parent ?? null;\n    this.tree = tree;\n    this._hash = 0;\n\n    this.children =\n      item.subitems?.map(\n        (subitem, index) =>\n          new Node<AppInterface>(subitem, {\n            childIndex: index,\n            depth: depth + 1,\n            parent: this,\n            tree,\n          }),\n      ) ?? ([] as Node<AppInterface>[]);\n\n    // Save the item without the subitems\n    this.plainItem = this.getCleanItem(itemCasted);\n  }\n\n  // ===========================================================================\n  // INTERNAL METHODS\n  // ===========================================================================\n\n  fixChildIndexes = (): void => {\n    for (let i = 0; i < this.children.length; i += 1) {\n      this.children[i].childIndex = i;\n    }\n    this._hash += 1;\n  };\n\n  getCleanItem = (item: Item<AppInterface>): Omit<Item<AppInterface>, 'subitems'> => {\n    const plainItem = omit(item, ['subitems']);\n    return cloneDeep(plainItem);\n  };\n\n  // ===========================================================================\n  // READ METHODS\n  // ===========================================================================\n\n  get hash(): number {\n    return this._hash;\n  }\n\n  walk = (callback: (node: Node<AppInterface>) => boolean): void => {\n    const shouldContinueWalking = callback(this);\n    if (shouldContinueWalking) {\n      // eslint-disable-next-line no-restricted-syntax\n      for (const child of this.children) {\n        child.walk(callback);\n      }\n    }\n  };\n\n  walkParents = (callback: (node: Node<AppInterface>) => boolean): void => {\n    const shouldContinueWalking = callback(this);\n    if (shouldContinueWalking && this.parent) {\n      this.parent.walkParents(callback);\n    }\n  };\n\n  findNode = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface> | null => {\n    // find first node using walk\n    let found: Node<AppInterface> | null = null;\n    this.walk((node) => {\n      // If we already found it, don't look anymore\n      if (found) return false;\n\n      // Otherwise keep looking\n      if (callback(node)) found = node;\n      return !found;\n    });\n\n    return found;\n  };\n\n  findAllNodes = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface>[] => {\n    const found: Node<AppInterface>[] = [];\n    this.walk((node) => {\n      if (callback(node)) found.push(node);\n      return true;\n    });\n    return found;\n  };\n\n  flatten = (): Node<AppInterface>[] => {\n    const flattened: Node<AppInterface>[] = [];\n    this.walk((node) => {\n      flattened.push(node);\n      return true;\n    });\n    return flattened;\n  };\n\n  getPath = (id: string | number): Node<AppInterface>[] => {\n    const path: Node<AppInterface>[] = [];\n    const node = this.tree.getNode(id);\n    if (!node) return path;\n    node.walkParents((parent) => {\n      path.push(parent);\n      return parent.dsId !== this.dsId;\n    });\n    return path.reverse();\n  };\n\n  getPathIds = (id: string | number) => this.getPath(id).map((node) => node.dsId);\n\n  getJson = (): JSONThatCanContrusctATree<AppInterface> =>\n    ({\n      ...this.plainItem,\n      subitems: this.children?.map?.((child) => child.getJson()) ?? undefined,\n    }) as JSONThatCanContrusctATree<AppInterface>;\n\n  // ===========================================================================\n  // WRITE METHODS\n  // ===========================================================================\n\n  addNode = (node: Node<AppInterface>) => {\n    // check that the position is valid for that parent\n    const position = node.childIndex;\n    if (position < 0 || position > this.children.length) {\n      throw new Error(`Invalid position ${position} for parent ${this.dsId} with item ${node.dsId}`);\n    }\n\n    // add the new node\n    this.children.splice(position, 0, node);\n\n    // fix the childIndex of the nodes after the new one\n    this.fixChildIndexes();\n\n    // add subtree of the new node to the node dictionary\n    node.walk((child) => {\n      this.tree.addNodeToNodesDictionary(child);\n      return true;\n    });\n\n    this._hash += 1;\n  };\n\n  removeNode = () => {\n    // if no parent throw error\n    if (!this.parent) throw new Error(`Cannot remove root node with id ${this.dsId}`);\n\n    // remove from parent\n    this.parent.children.splice(this.childIndex, 1);\n\n    // fix the childIndex of the nodes of the parent\n    this.parent.fixChildIndexes();\n\n    // remove subtree from the node dictionary\n    this.walk((child) => {\n      this.tree.removeNodeFromNodesDictionary(child);\n      return true;\n    });\n\n    this._hash += 1;\n  };\n}\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": "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",
+  "sourcesContent": ["/* eslint-disable no-underscore-dangle */\n/* eslint-disable no-use-before-define */\n/* eslint-disable max-params */\nimport { cloneDeep } from 'lodash';\nimport type { DSTree } from './DSTree.js';\nimport type { NodeConstructorOptions, AnyObjectWithoutReservedKeys, Item } from './types.js';\n\nexport class Node<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  dsId: string | number;\n\n  childIndex: number;\n\n  depth: number;\n\n  plainItem: AppInterface;\n\n  plainChildren: AppInterface[];\n\n  parent: Node<AppInterface> | null;\n\n  children: Node<AppInterface>[];\n\n  private tree!: DSTree<AppInterface>;\n\n  private _hash: number;\n\n  constructor(item: Item<AppInterface>, { childIndex, depth, parent, tree }: NodeConstructorOptions<AppInterface>) {\n    this.dsId = tree.getUniqueId(item);\n    this.childIndex = childIndex;\n    this.depth = depth;\n    this.parent = parent ?? null;\n    this.tree = tree;\n    this._hash = 0;\n    this.children = [];\n    this.plainChildren = [];\n\n    // on construction, we add the children to the node\n    // this will recursively happen for all children because this triggers `new Node()` recursively\n    const subitems = item.subitems ?? [];\n    subitems.forEach((subitem, index) => {\n      this.plainChildren.push(this.getCleanItem(subitem));\n      this.children.push(\n        new Node<AppInterface>(subitem, {\n          childIndex: index,\n          depth: depth + 1,\n          parent: this,\n          tree,\n        }),\n      );\n    });\n    // Save the item without the subitems\n    this.plainItem = this.getCleanItem(item);\n  }\n\n  // ===========================================================================\n  // INTERNAL METHODS\n  // ===========================================================================\n\n  fixChildIndexes = (): void => {\n    for (let i = 0; i < this.children.length; i += 1) {\n      this.children[i].childIndex = i;\n    }\n    this._hash += 1;\n  };\n\n  getCleanItem = (item: Item<AppInterface>): AppInterface => {\n    const { subitems, ...plainItem } = item;\n    return cloneDeep(plainItem as AppInterface);\n  };\n\n  // ===========================================================================\n  // READ METHODS\n  // ===========================================================================\n\n  get hash(): number {\n    return this._hash;\n  }\n\n  walk = (callback: (node: Node<AppInterface>) => boolean): void => {\n    const shouldContinueWalking = callback(this);\n    if (shouldContinueWalking) {\n      // eslint-disable-next-line no-restricted-syntax\n      for (const child of this.children) {\n        child.walk(callback);\n      }\n    }\n  };\n\n  walkParents = (callback: (node: Node<AppInterface>) => boolean): void => {\n    const shouldContinueWalking = callback(this);\n    if (shouldContinueWalking && this.parent) {\n      this.parent.walkParents(callback);\n    }\n  };\n\n  findNode = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface> | null => {\n    // find first node using walk\n    let found: Node<AppInterface> | null = null;\n    this.walk((node) => {\n      // If we already found it, don't look anymore\n      if (found) return false;\n\n      // Otherwise keep looking\n      if (callback(node)) found = node;\n      return !found;\n    });\n\n    return found;\n  };\n\n  findAllNodes = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface>[] => {\n    const found: Node<AppInterface>[] = [];\n    this.walk((node) => {\n      if (callback(node)) found.push(node);\n      return true;\n    });\n    return found;\n  };\n\n  flatten = (): Node<AppInterface>[] => {\n    const flattened: Node<AppInterface>[] = [];\n    this.walk((node) => {\n      flattened.push(node);\n      return true;\n    });\n    return flattened;\n  };\n\n  getPath = (id: string | number): Node<AppInterface>[] => {\n    const path: Node<AppInterface>[] = [];\n    const node = this.tree.getNode(id);\n    if (!node) return path;\n    node.walkParents((parent) => {\n      path.push(parent);\n      return parent.dsId !== this.dsId;\n    });\n    return path.reverse();\n  };\n\n  getPathIds = (id: string | number) => this.getPath(id).map((node) => node.dsId);\n\n  getJson = (): Item<AppInterface> =>\n    ({\n      ...this.plainItem,\n      subitems: this.children?.map?.((child) => child.getJson()) ?? undefined,\n    }) as Item<AppInterface>;\n\n  // ===========================================================================\n  // WRITE METHODS\n  // ===========================================================================\n\n  addNode = (node: Node<AppInterface>) => {\n    // check that the position is valid for that parent\n    const position = node.childIndex;\n    if (position < 0 || position > this.children.length) {\n      throw new Error(`Invalid position ${position} for parent ${this.dsId} with item ${node.dsId}`);\n    }\n\n    // add the new node\n    this.children.splice(position, 0, node);\n\n    // fix the childIndex of the nodes after the new one\n    this.fixChildIndexes();\n\n    // add subtree of the new node to the node dictionary\n    node.walk((child) => {\n      this.tree.addNodeToNodesDictionary(child);\n      return true;\n    });\n\n    this._hash += 1;\n  };\n\n  removeNode = () => {\n    // if no parent throw error\n    if (!this.parent) throw new Error(`Cannot remove root node with id ${this.dsId}`);\n\n    // remove from parent\n    this.parent.children.splice(this.childIndex, 1);\n\n    // fix the childIndex of the nodes of the parent\n    this.parent.fixChildIndexes();\n\n    // remove subtree from the node dictionary\n    this.walk((child) => {\n      this.tree.removeNodeFromNodesDictionary(child);\n      return true;\n    });\n\n    this._hash += 1;\n  };\n}\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/cjs/adapters/arraish-tree/fromTreeishArrayToDSTree.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/adapters/arraish-tree/fromTreeishArrayToDSTree.ts", "../../../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["/* eslint-disable max-statements */\nimport { DSTree } from '../../DSTree.js';\nimport type { OverloadedItem } from '../../types.js';\n\n// we don't really need a 100% sure unique id, since we prepend a string that is most likely unique already\n//  we just need to reduce the risk of collisions\n//  we avoid depending on a library for this:\nconst unsecureUuid = () =>\n  'xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n    const r = Math.random() * 16 || 0;\n    // eslint-disable-next-line no-bitwise\n    const v = c === 'x' ? r : r & 0x3 || 0x8;\n    return v.toString(16);\n  });\n\n/*\n * @param {Object} args\n * @param {Function} args.callback - a function that will be called for each node in the treeish data-structure\n * @param {Object} args.node - the node that is being currently visited\n * @param {Object} args.opts - an object that holds the opinions of the caller on how to walk the treeish data-structure\n * @param {Function} args.opts.getChildren - a function that given a node returns an array of children\n * @returns {void}\n */\nconst walkTreeish = <T extends object>({\n  callback,\n  node,\n  opts,\n}: {\n  callback: (node: T) => void;\n  node: T;\n  opts?: {\n    getChildren: (node: T) => T[];\n  };\n}): void => {\n  callback(node);\n  const children = opts?.getChildren(node);\n  if (Array.isArray(children) && children.length > 0) {\n    for (let i = 0; i < children.length; i += 1) {\n      walkTreeish<T>({ callback, node: children[i], opts });\n    }\n  }\n};\n\n/*\n * a function that given a treeish array and some options returns a DSTree datastructure that compltely preserves the treeish array\n *  but still allows to use the full power of the DSTree datastructure\n * NOTE: This create a deep clone of the treeish array, so it's not suitable for large trees and will not preserve any reference to the original treeish array\n * @param {Array} treeish - an array of items that rapresents a tree, this will be used to create a DSTree datastructure\n * @param {Object} opts - an object that governs how the treeish array will be converted to a DSTree datastructure\n * @param {Function} opts.getChildrenKey - a function that given a node returns the key used to access the node children\n * @param {Function} opts.getUniqueId - a function that given a node returns a unique string used to identify the node\n * @returns {DSTree} - a DSTree datastructure\n */\nexport const fromTreeishArrayToDSTree = <T extends object = object>(args: {\n  treeish: T[];\n  opts: {\n    getChildrenKey: (node: T) => keyof T;\n    getUniqueId: (item: T) => string;\n  };\n}): DSTree<OverloadedItem<T>> => {\n  // we use crypto to generate a unique id for the root, this is important for reduce the risk of collisions with any user provided id\n  const rootId = `_autogenerated-ds-pseudoRoot-${unsecureUuid()}`;\n  const { opts, treeish } = args;\n  const { getUniqueId, getChildrenKey } = opts;\n\n  // a DSTree compatible datastructure has the following characteristics:\n  //  - it has a \"subitems\" property that contains an array of children\n  //  - it has a property that holds a unique string used to identify the node (accessed via the getUniqueId function)\n  //  - it is in an object format\n  // @ts-expect-error this is an extremely opinionated algorithm that was built as a one-off, we are not spending time to make it typesafe\n  const pseudoRoot: OverloadedItem<T> = {\n    id: rootId,\n    subitems: structuredClone(treeish) as unknown as OverloadedItem<T>[],\n    originalNodeData: {} as T,\n  };\n  // we now create an over-charged getChildren function\n  //  this is because we mutate the object every step during the walk\n  //  this function is going to receive the OverloadedItem<T> each step\n  const overloadedGetChildren = (node: OverloadedItem<T>) => node.subitems;\n  const overloadedGetUniqueId = (node: OverloadedItem<T>) => node.id;\n  // we now create a \"callback\" function that will be used when walking the pseudoRoot object.\n  //  this callback will mutate the pseudoRoot object, making sure that after the mutation it will be compatible with the DSTree datastructure\n  //  we can't really make an assumption that the subitems key isn't somehow already part of the data from the user,\n  //     so to avoid any collision we will create an extra-level of nesting, in this layer only 3 properties will be allowed:\n  //    - id: a unique string used to identify the node, this is already a requirement from the treeish datastructure provided by the user\n  //    - subitems: an array of children\n  //    - original: the original data provided by the user\n  //        we remove the original tree rapresentation from the node, we only want one source of truth for the tree\n  //        if we don't remove this, when operating the DSTree we would have to somehow also propagate the changes to the original tree\n  //          the way this is intended to be used is instead to convert back and forth between the DSTree and the treeish array\n  //          the conversion will restore the treeish structure with the updated tree after operating on the DSTree\n  const callback = (node: OverloadedItem<T>) => {\n    // we skip the root node\n    if (node.id === rootId) return;\n    // we safe-keep the original data provided by the user\n    const originalNodeData = structuredClone(node) as unknown as T;\n    // we now mutate the node, making it compatible with the DSTree datastructure\n    // first we clean all the properties\n    Object.keys(node).forEach((key) => {\n      delete node[key];\n    });\n    // we now add the properties that are required by the DSTree datastructure\n    const overloadedNode = node as unknown as OverloadedItem<T>;\n    const childrenKey = getChildrenKey(originalNodeData);\n    overloadedNode.id = getUniqueId(originalNodeData);\n    overloadedNode.subitems = originalNodeData[childrenKey] as OverloadedItem<T>[];\n    delete originalNodeData[childrenKey];\n    overloadedNode.originalNodeData = originalNodeData;\n  };\n  // we now walk the pseudoRoot object, mutating it in the process\n  // @ts-expect-error this is an extremely opinionated algorithm that was built as a one-off, we are not spending time to make it typesafe\n  walkTreeish<OverloadedItem<T>>({ callback, node: pseudoRoot, opts: { getChildren: overloadedGetChildren } });\n\n  // we know that pseudoRoot is an item after we have walked and mutated it, so we can safely cast it\n  // @ts-expect-error this is an extremely opinionated algorithm that was built as a one-off, we are not spending time to make it typesafe\n  return new DSTree<OverloadedItem<T>>(pseudoRoot, { getUniqueId: overloadedGetUniqueId });\n};\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,oBAAuB;AAMvB,MAAM,eAAe,MACnB,uCAAuC,QAAQ,SAAS,CAAC,MAAM;AAC7D,QAAM,IAAI,KAAK,OAAO,IAAI,MAAM;AAEhC,QAAM,IAAI,MAAM,MAAM,IAAI,IAAI,KAAO;AACrC,SAAO,EAAE,SAAS,EAAE;AACtB,CAAC;AAUH,MAAM,cAAc,CAAmB;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AACF,MAMY;AACV,WAAS,IAAI;AACb,QAAM,WAAW,MAAM,YAAY,IAAI;AACvC,MAAI,MAAM,QAAQ,QAAQ,KAAK,SAAS,SAAS,GAAG;AAClD,aAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG;AAC3C,kBAAe,EAAE,UAAU,MAAM,SAAS,CAAC,GAAG,KAAK,CAAC;AAAA,IACtD;AAAA,EACF;AACF;AAYO,MAAM,2BAA2B,CAA4B,SAMnC;AAE/B,QAAM,SAAS,gCAAgC,aAAa,CAAC;AAC7D,QAAM,EAAE,MAAM,QAAQ,IAAI;AAC1B,QAAM,EAAE,aAAa,eAAe,IAAI;AAOxC,QAAM,aAAgC;AAAA,IACpC,IAAI;AAAA,IACJ,UAAU,gBAAgB,OAAO;AAAA,IACjC,kBAAkB,CAAC;AAAA,EACrB;AAIA,QAAM,wBAAwB,CAAC,SAA4B,KAAK;AAChE,QAAM,wBAAwB,CAAC,SAA4B,KAAK;AAYhE,QAAM,WAAW,CAAC,SAA4B;AAE5C,QAAI,KAAK,OAAO,OAAQ;AAExB,UAAM,mBAAmB,gBAAgB,IAAI;AAG7C,WAAO,KAAK,IAAI,EAAE,QAAQ,CAAC,QAAQ;AACjC,aAAO,KAAK,GAAG;AAAA,IACjB,CAAC;AAED,UAAM,iBAAiB;AACvB,UAAM,cAAc,eAAe,gBAAgB;AACnD,mBAAe,KAAK,YAAY,gBAAgB;AAChD,mBAAe,WAAW,iBAAiB,WAAW;AACtD,WAAO,iBAAiB,WAAW;AACnC,mBAAe,mBAAmB;AAAA,EACpC;AAGA,cAA+B,EAAE,UAAU,MAAM,YAAY,MAAM,EAAE,aAAa,sBAAsB,EAAE,CAAC;AAI3G,SAAO,IAAI,qBAA0B,YAAY,EAAE,aAAa,sBAAsB,CAAC;AACzF;",
+  "sourcesContent": ["/* eslint-disable max-statements */\nimport { DSTree } from '../../DSTree.js';\nimport type { OverloadedItem } from '../../types.js';\n\n// we don't really need a 100% sure unique id, since we prepend a string that is most likely unique already\n//  we just need to reduce the risk of collisions\n//  we avoid depending on a library for this:\nconst unsecureUuid = () =>\n  'xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n    const r = Math.random() * 16 || 0;\n    // eslint-disable-next-line no-bitwise\n    const v = c === 'x' ? r : r & 0x3 || 0x8;\n    return v.toString(16);\n  });\n\n/*\n * @param {Object} args\n * @param {Function} args.callback - a function that will be called for each node in the treeish data-structure\n * @param {Object} args.node - the node that is being currently visited\n * @param {Object} args.opts - an object that holds the opinions of the caller on how to walk the treeish data-structure\n * @param {Function} args.opts.getChildren - a function that given a node returns an array of children\n * @returns {void}\n */\nconst walkTreeish = <T extends object>({\n  callback,\n  node,\n  opts,\n}: {\n  callback: (node: T) => void;\n  node: T;\n  opts?: {\n    getChildren: (node: T) => T[];\n  };\n}): void => {\n  callback(node);\n  const children = opts?.getChildren(node);\n  if (Array.isArray(children) && children.length > 0) {\n    for (let i = 0; i < children.length; i += 1) {\n      walkTreeish<T>({ callback, node: children[i], opts });\n    }\n  }\n};\n\n/*\n * a function that given a treeish array and some options returns a DSTree datastructure that compltely preserves the treeish array\n *  but still allows to use the full power of the DSTree datastructure\n * NOTE: This create a deep clone of the treeish array, so it's not suitable for large trees and will not preserve any reference to the original treeish array\n * @param {Array} treeish - an array of items that rapresents a tree, this will be used to create a DSTree datastructure\n * @param {Object} opts - an object that governs how the treeish array will be converted to a DSTree datastructure\n * @param {Function} opts.getChildrenKey - a function that given a node returns the key used to access the node children\n * @param {Function} opts.getUniqueId - a function that given a node returns a unique string used to identify the node\n * @returns {DSTree} - a DSTree datastructure\n */\nexport const fromTreeishArrayToDSTree = <T extends object = object>(args: {\n  treeish: T[];\n  opts: {\n    getChildrenKey: (node: T) => keyof T;\n    getUniqueId: (item: T) => string;\n  };\n}): DSTree<OverloadedItem<T>> => {\n  // we use crypto to generate a unique id for the root, this is important for reduce the risk of collisions with any user provided id\n  const rootId = `_autogenerated-ds-pseudoRoot-${unsecureUuid()}`;\n  const { opts, treeish } = args;\n  const { getUniqueId, getChildrenKey } = opts;\n\n  // a DSTree compatible datastructure has the following characteristics:\n  //  - it has a \"subitems\" property that contains an array of children\n  //  - it has a property that holds a unique string used to identify the node (accessed via the getUniqueId function)\n  //  - it is in an object format\n  const pseudoRoot: OverloadedItem<T> = {\n    id: rootId,\n    subitems: structuredClone(treeish) as unknown as OverloadedItem<T>[],\n    originalNodeData: {} as T,\n  };\n  // we now create an over-charged getChildren function\n  //  this is because we mutate the object every step during the walk\n  //  this function is going to receive the OverloadedItem<T> each step\n  const overloadedGetChildren = (node: OverloadedItem<T>) => node.subitems;\n  const overloadedGetUniqueId = (node: OverloadedItem<T>) => node.id;\n  // we now create a \"callback\" function that will be used when walking the pseudoRoot object.\n  //  this callback will mutate the pseudoRoot object, making sure that after the mutation it will be compatible with the DSTree datastructure\n  //  we can't really make an assumption that the subitems key isn't somehow already part of the data from the user,\n  //     so to avoid any collision we will create an extra-level of nesting, in this layer only 3 properties will be allowed:\n  //    - id: a unique string used to identify the node, this is already a requirement from the treeish datastructure provided by the user\n  //    - subitems: an array of children\n  //    - original: the original data provided by the user\n  //        we remove the original tree rapresentation from the node, we only want one source of truth for the tree\n  //        if we don't remove this, when operating the DSTree we would have to somehow also propagate the changes to the original tree\n  //          the way this is intended to be used is instead to convert back and forth between the DSTree and the treeish array\n  //          the conversion will restore the treeish structure with the updated tree after operating on the DSTree\n  const callback = (node: OverloadedItem<T>) => {\n    // we skip the root node\n    if (node.id === rootId) return;\n    // we safe-keep the original data provided by the user\n    const originalNodeData = structuredClone(node) as unknown as T;\n    // we now mutate the node, making it compatible with the DSTree datastructure\n    // first we clean all the properties\n    Object.keys(node).forEach((key) => {\n      delete node[key];\n    });\n    // we now add the properties that are required by the DSTree datastructure\n    const overloadedNode = node as unknown as OverloadedItem<T>;\n    const childrenKey = getChildrenKey(originalNodeData);\n    overloadedNode.id = getUniqueId(originalNodeData);\n    overloadedNode.subitems = originalNodeData[childrenKey] as OverloadedItem<T>[];\n    delete originalNodeData[childrenKey];\n    overloadedNode.originalNodeData = originalNodeData;\n  };\n  // we now walk the pseudoRoot object, mutating it in the process\n  // @ts-expect-error this is an extremely opinionated algorithm that was built as a one-off, we are not spending time to make it typesafe\n  walkTreeish<OverloadedItem<T>>({ callback, node: pseudoRoot, opts: { getChildren: overloadedGetChildren } });\n\n  // we know that pseudoRoot is an item after we have walked and mutated it, so we can safely cast it\n  return new DSTree<OverloadedItem<T>>(pseudoRoot, { getUniqueId: overloadedGetUniqueId });\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,oBAAuB;AAMvB,MAAM,eAAe,MACnB,uCAAuC,QAAQ,SAAS,CAAC,MAAM;AAC7D,QAAM,IAAI,KAAK,OAAO,IAAI,MAAM;AAEhC,QAAM,IAAI,MAAM,MAAM,IAAI,IAAI,KAAO;AACrC,SAAO,EAAE,SAAS,EAAE;AACtB,CAAC;AAUH,MAAM,cAAc,CAAmB;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AACF,MAMY;AACV,WAAS,IAAI;AACb,QAAM,WAAW,MAAM,YAAY,IAAI;AACvC,MAAI,MAAM,QAAQ,QAAQ,KAAK,SAAS,SAAS,GAAG;AAClD,aAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG;AAC3C,kBAAe,EAAE,UAAU,MAAM,SAAS,CAAC,GAAG,KAAK,CAAC;AAAA,IACtD;AAAA,EACF;AACF;AAYO,MAAM,2BAA2B,CAA4B,SAMnC;AAE/B,QAAM,SAAS,gCAAgC,aAAa,CAAC;AAC7D,QAAM,EAAE,MAAM,QAAQ,IAAI;AAC1B,QAAM,EAAE,aAAa,eAAe,IAAI;AAMxC,QAAM,aAAgC;AAAA,IACpC,IAAI;AAAA,IACJ,UAAU,gBAAgB,OAAO;AAAA,IACjC,kBAAkB,CAAC;AAAA,EACrB;AAIA,QAAM,wBAAwB,CAAC,SAA4B,KAAK;AAChE,QAAM,wBAAwB,CAAC,SAA4B,KAAK;AAYhE,QAAM,WAAW,CAAC,SAA4B;AAE5C,QAAI,KAAK,OAAO,OAAQ;AAExB,UAAM,mBAAmB,gBAAgB,IAAI;AAG7C,WAAO,KAAK,IAAI,EAAE,QAAQ,CAAC,QAAQ;AACjC,aAAO,KAAK,GAAG;AAAA,IACjB,CAAC;AAED,UAAM,iBAAiB;AACvB,UAAM,cAAc,eAAe,gBAAgB;AACnD,mBAAe,KAAK,YAAY,gBAAgB;AAChD,mBAAe,WAAW,iBAAiB,WAAW;AACtD,WAAO,iBAAiB,WAAW;AACnC,mBAAe,mBAAmB;AAAA,EACpC;AAGA,cAA+B,EAAE,UAAU,MAAM,YAAY,MAAM,EAAE,aAAa,sBAAsB,EAAE,CAAC;AAG3G,SAAO,IAAI,qBAA0B,YAAY,EAAE,aAAa,sBAAsB,CAAC;AACzF;",
   "names": []
 }

package/dist/cjs/react-desc-prop-types.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/react-desc-prop-types.ts", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import { PropTypes, type ValidationMap } from '@elliemae/ds-props-helpers';\nimport type { Node } from './Node.js';\nimport type {\n  AddOptions,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions,\n  Item,\n  AnyObjectWithoutReservedKeys,\n  JSONThatCanContrusctATree,\n} from './types.js';\n\nexport declare namespace UseDSTreeT {\n  export type TreeNode<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> =\n    Node<AppInterface>;\n  export type TreeItem<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> =\n    Item<AppInterface>;\n  export type FirstParameter<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> =\n    TreeItem<AppInterface>;\n\n  export type SecondParameter<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = {\n    getUniqueId: (item: TreeItem<AppInterface>) => string | number;\n  };\n\n  export interface OutputT<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n    hash: number;\n    getRoot: () => Node<AppInterface>;\n    getNode: (id: string | number) => Node<AppInterface>;\n    walk: (callback: (node: Node<AppInterface>) => boolean) => void;\n    walkParents: (callback: (node: Node<AppInterface>) => boolean) => void;\n    findNode: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface> | null;\n    findAllNodes: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface>[];\n    flatten: () => Node<AppInterface>[];\n    addNode: (item: JSONThatCanContrusctATree<AppInterface>, options?: AddOptions<AppInterface>) => Node<AppInterface>;\n    removeNode: (id: string | number, options?: RemoveOptions<AppInterface>) => Node<AppInterface>;\n    moveNode: (id: string | number, options?: MoveOptions<AppInterface>) => Node<AppInterface>;\n    replaceNode: (\n      id: string | number,\n      item: JSONThatCanContrusctATree<AppInterface>,\n      options?: MutateOptions<AppInterface>,\n    ) => Node<AppInterface>;\n    getPath: (id: string | number) => Node<AppInterface>[];\n    getPathIds: (id: string | number) => (string | number)[];\n  }\n}\n\nconst itemShape = {\n  dsId: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).description('Id of the root item.'),\n  label: PropTypes.string.description('Item label.'),\n  '[key]': PropTypes.string.description('Any custom key you want to add to the item.'),\n};\n\nexport const UseDSTreePropTypes = {\n  rootItem: PropTypes.shape({\n    ...itemShape,\n    subitems: PropTypes.arrayOf(PropTypes.shape(itemShape)).description(\n      'Array of subitems. Each subitem can also have subitems.',\n    ),\n  }).description('First parameter.').isRequired,\n  opts: PropTypes.shape({\n    getUniqueId: PropTypes.func\n      .signature('(item) => string | number')\n      .description('Callback to get the id of each item.').isRequired,\n  }).description('Second parameter.').isRequired,\n} as ValidationMap<unknown>;\n\nexport const UseDSTreeReturnType = {\n  hash: PropTypes.number.description('Tree hash value.'),\n  getRoot: PropTypes.func.signature('() => rootItem').description('Callback to get the root item.'),\n  getNode: PropTypes.func.signature('(id: string | number) => item').description('Callback to get an item by id.'),\n  walk: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => void')\n    .description('Callback applied to each item to determine whether to continue walking or not.'),\n  walkParents: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => void')\n    .description(\"Callback applied to each item to determine whether to continue walking the item's parents or not.\"),\n  findNode: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => FirstParameter | null')\n    .description('Callback to find an item that matches the condition.'),\n  findAllNodes: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => FirstParameter[]')\n    .description('Callback to find all the items that matches the condition.'),\n  flatten: PropTypes.func.signature('() => item[]').description('Returns an array of hte tree items.'),\n  addNode: PropTypes.func\n    .signature('(item: FirstParameter, options?: AddOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Adds an item to the tree.'),\n  removeNode: PropTypes.func\n    .signature('(id: string, options?: RemoveOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Removes an item from the tree.'),\n  moveNode: PropTypes.func\n    .signature('(id: string, options?: MoveOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Move an item within the tree.'),\n  replaceNode: PropTypes.func\n    .signature(\n      'id: string, item: FirstParameter, options?: MutateOptions<FirstParameter> | undefined) => FirstParameter',\n    )\n    .description('Replace a noe within the tree.'),\n  getPath: PropTypes.func\n    .signature('(id: string | number) => FirstParameter[]')\n    .description(\"Get the path to an item given the item's id.\"),\n  getPathIds: PropTypes.func\n    .signature('(id: string | number) => (string | number)[]')\n    .description(\"Get the path ids to an item given the item's id.\"),\n} as ValidationMap<unknown>;\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,8BAA8C;AA8C9C,MAAM,YAAY;AAAA,EAChB,MAAM,kCAAU,UAAU,CAAC,kCAAU,QAAQ,kCAAU,MAAM,CAAC,EAAE,YAAY,sBAAsB;AAAA,EAClG,OAAO,kCAAU,OAAO,YAAY,aAAa;AAAA,EACjD,SAAS,kCAAU,OAAO,YAAY,6CAA6C;AACrF;AAEO,MAAM,qBAAqB;AAAA,EAChC,UAAU,kCAAU,MAAM;AAAA,IACxB,GAAG;AAAA,IACH,UAAU,kCAAU,QAAQ,kCAAU,MAAM,SAAS,CAAC,EAAE;AAAA,MACtD;AAAA,IACF;AAAA,EACF,CAAC,EAAE,YAAY,kBAAkB,EAAE;AAAA,EACnC,MAAM,kCAAU,MAAM;AAAA,IACpB,aAAa,kCAAU,KACpB,UAAU,2BAA2B,EACrC,YAAY,sCAAsC,EAAE;AAAA,EACzD,CAAC,EAAE,YAAY,mBAAmB,EAAE;AACtC;AAEO,MAAM,sBAAsB;AAAA,EACjC,MAAM,kCAAU,OAAO,YAAY,kBAAkB;AAAA,EACrD,SAAS,kCAAU,KAAK,UAAU,gBAAgB,EAAE,YAAY,gCAAgC;AAAA,EAChG,SAAS,kCAAU,KAAK,UAAU,+BAA+B,EAAE,YAAY,gCAAgC;AAAA,EAC/G,MAAM,kCAAU,KACb,UAAU,uDAAuD,EACjE,YAAY,gFAAgF;AAAA,EAC/F,aAAa,kCAAU,KACpB,UAAU,uDAAuD,EACjE,YAAY,mGAAmG;AAAA,EAClH,UAAU,kCAAU,KACjB,UAAU,wEAAwE,EAClF,YAAY,sDAAsD;AAAA,EACrE,cAAc,kCAAU,KACrB,UAAU,mEAAmE,EAC7E,YAAY,4DAA4D;AAAA,EAC3E,SAAS,kCAAU,KAAK,UAAU,cAAc,EAAE,YAAY,qCAAqC;AAAA,EACnG,SAAS,kCAAU,KAChB,UAAU,4FAA4F,EACtG,YAAY,2BAA2B;AAAA,EAC1C,YAAY,kCAAU,KACnB,UAAU,qFAAqF,EAC/F,YAAY,gCAAgC;AAAA,EAC/C,UAAU,kCAAU,KACjB,UAAU,mFAAmF,EAC7F,YAAY,+BAA+B;AAAA,EAC9C,aAAa,kCAAU,KACpB;AAAA,IACC;AAAA,EACF,EACC,YAAY,gCAAgC;AAAA,EAC/C,SAAS,kCAAU,KAChB,UAAU,2CAA2C,EACrD,YAAY,8CAA8C;AAAA,EAC7D,YAAY,kCAAU,KACnB,UAAU,8CAA8C,EACxD,YAAY,kDAAkD;AACnE;",
+  "sourcesContent": ["import { PropTypes, type ValidationMap } from '@elliemae/ds-props-helpers';\nimport type { Node } from './Node.js';\nimport type {\n  AddOptions,\n  AnyObjectWithoutReservedKeys as AnyObjectWithoutReservedKeysToRexport,\n  Item as ItemToRexport,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions\n} from './types.js';\n\nexport declare namespace UseDSTreeT {\n  export type AnyObjectWithoutReservedKeys = AnyObjectWithoutReservedKeysToRexport;\n  export type Item<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> =\n    ItemToRexport<AppInterface>;\n\n  export type TreeNode<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> =\n    Node<AppInterface>;\n  export type TreeItem<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> =\n    Item<AppInterface>;\n  export type FirstParameter<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> =\n    TreeItem<AppInterface>;\n\n  export type SecondParameter<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> = {\n    getUniqueId: (item: TreeItem<AppInterface>) => string | number;\n  };\n\n  export interface OutputT<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> {\n    hash: number;\n    getRoot: () => Node<AppInterface>;\n    getNode: (id: string | number) => Node<AppInterface>;\n    walk: (callback: (node: Node<AppInterface>) => boolean) => void;\n    walkParents: (callback: (node: Node<AppInterface>) => boolean) => void;\n    findNode: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface> | null;\n    findAllNodes: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface>[];\n    flatten: () => Node<AppInterface>[];\n    addNode: (item: ItemToRexport<AppInterface>, options?: AddOptions<AppInterface>) => Node<AppInterface>;\n    removeNode: (id: string | number, options?: RemoveOptions<AppInterface>) => Node<AppInterface>;\n    moveNode: (id: string | number, options?: MoveOptions<AppInterface>) => Node<AppInterface>;\n    replaceNode: (\n      id: string | number,\n      item: ItemToRexport<AppInterface>,\n      options?: MutateOptions<AppInterface>,\n    ) => Node<AppInterface>;\n    getPath: (id: string | number) => Node<AppInterface>[];\n    getPathIds: (id: string | number) => (string | number)[];\n  }\n}\n\nconst itemShape = {\n  dsId: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).description('Id of the root item.'),\n  label: PropTypes.string.description('Item label.'),\n  '[key]': PropTypes.string.description('Any custom key you want to add to the item.'),\n};\n\nexport const UseDSTreePropTypes = {\n  rootItem: PropTypes.shape({\n    ...itemShape,\n    subitems: PropTypes.arrayOf(PropTypes.shape(itemShape)).description(\n      'Array of subitems. Each subitem can also have subitems.',\n    ),\n  }).description('First parameter.').isRequired,\n  opts: PropTypes.shape({\n    getUniqueId: PropTypes.func\n      .signature('(item) => string | number')\n      .description('Callback to get the id of each item.').isRequired,\n  }).description('Second parameter.').isRequired,\n} as ValidationMap<unknown>;\n\nexport const UseDSTreeReturnType = {\n  hash: PropTypes.number.description('Tree hash value.'),\n  getRoot: PropTypes.func.signature('() => rootItem').description('Callback to get the root item.'),\n  getNode: PropTypes.func.signature('(id: string | number) => item').description('Callback to get an item by id.'),\n  walk: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => void')\n    .description('Callback applied to each item to determine whether to continue walking or not.'),\n  walkParents: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => void')\n    .description(\"Callback applied to each item to determine whether to continue walking the item's parents or not.\"),\n  findNode: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => FirstParameter | null')\n    .description('Callback to find an item that matches the condition.'),\n  findAllNodes: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => FirstParameter[]')\n    .description('Callback to find all the items that matches the condition.'),\n  flatten: PropTypes.func.signature('() => item[]').description('Returns an array of hte tree items.'),\n  addNode: PropTypes.func\n    .signature('(item: FirstParameter, options?: AddOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Adds an item to the tree.'),\n  removeNode: PropTypes.func\n    .signature('(id: string, options?: RemoveOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Removes an item from the tree.'),\n  moveNode: PropTypes.func\n    .signature('(id: string, options?: MoveOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Move an item within the tree.'),\n  replaceNode: PropTypes.func\n    .signature(\n      'id: string, item: FirstParameter, options?: MutateOptions<FirstParameter> | undefined) => FirstParameter',\n    )\n    .description('Replace a noe within the tree.'),\n  getPath: PropTypes.func\n    .signature('(id: string | number) => FirstParameter[]')\n    .description(\"Get the path to an item given the item's id.\"),\n  getPathIds: PropTypes.func\n    .signature('(id: string | number) => (string | number)[]')\n    .description(\"Get the path ids to an item given the item's id.\"),\n} as ValidationMap<unknown>;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,8BAA8C;AAiD9C,MAAM,YAAY;AAAA,EAChB,MAAM,kCAAU,UAAU,CAAC,kCAAU,QAAQ,kCAAU,MAAM,CAAC,EAAE,YAAY,sBAAsB;AAAA,EAClG,OAAO,kCAAU,OAAO,YAAY,aAAa;AAAA,EACjD,SAAS,kCAAU,OAAO,YAAY,6CAA6C;AACrF;AAEO,MAAM,qBAAqB;AAAA,EAChC,UAAU,kCAAU,MAAM;AAAA,IACxB,GAAG;AAAA,IACH,UAAU,kCAAU,QAAQ,kCAAU,MAAM,SAAS,CAAC,EAAE;AAAA,MACtD;AAAA,IACF;AAAA,EACF,CAAC,EAAE,YAAY,kBAAkB,EAAE;AAAA,EACnC,MAAM,kCAAU,MAAM;AAAA,IACpB,aAAa,kCAAU,KACpB,UAAU,2BAA2B,EACrC,YAAY,sCAAsC,EAAE;AAAA,EACzD,CAAC,EAAE,YAAY,mBAAmB,EAAE;AACtC;AAEO,MAAM,sBAAsB;AAAA,EACjC,MAAM,kCAAU,OAAO,YAAY,kBAAkB;AAAA,EACrD,SAAS,kCAAU,KAAK,UAAU,gBAAgB,EAAE,YAAY,gCAAgC;AAAA,EAChG,SAAS,kCAAU,KAAK,UAAU,+BAA+B,EAAE,YAAY,gCAAgC;AAAA,EAC/G,MAAM,kCAAU,KACb,UAAU,uDAAuD,EACjE,YAAY,gFAAgF;AAAA,EAC/F,aAAa,kCAAU,KACpB,UAAU,uDAAuD,EACjE,YAAY,mGAAmG;AAAA,EAClH,UAAU,kCAAU,KACjB,UAAU,wEAAwE,EAClF,YAAY,sDAAsD;AAAA,EACrE,cAAc,kCAAU,KACrB,UAAU,mEAAmE,EAC7E,YAAY,4DAA4D;AAAA,EAC3E,SAAS,kCAAU,KAAK,UAAU,cAAc,EAAE,YAAY,qCAAqC;AAAA,EACnG,SAAS,kCAAU,KAChB,UAAU,4FAA4F,EACtG,YAAY,2BAA2B;AAAA,EAC1C,YAAY,kCAAU,KACnB,UAAU,qFAAqF,EAC/F,YAAY,gCAAgC;AAAA,EAC/C,UAAU,kCAAU,KACjB,UAAU,mFAAmF,EAC7F,YAAY,+BAA+B;AAAA,EAC9C,aAAa,kCAAU,KACpB;AAAA,IACC;AAAA,EACF,EACC,YAAY,gCAAgC;AAAA,EAC/C,SAAS,kCAAU,KAChB,UAAU,2CAA2C,EACrD,YAAY,8CAA8C;AAAA,EAC7D,YAAY,kCAAU,KACnB,UAAU,8CAA8C,EACxD,YAAY,kDAAkD;AACnE;",
   "names": []
 }

package/dist/cjs/types.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/types.ts", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import type { DSTree } from './DSTree.js';\nimport type { Node } from './Node.js';\n\nexport type AnyObjectWithoutReservedKeys = Omit<Record<string, unknown>, 'dsId' | 'subitems'>;\nexport type JSONThatCanContrusctATree<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> =\n  AppInterface & {\n    dsId: string | number;\n    subitems?: JSONThatCanContrusctATree<AppInterface>[] | ReadonlyArray<JSONThatCanContrusctATree<AppInterface>>;\n  };\n\nexport type Item<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = Omit<\n  AppInterface,\n  'dsId' | 'subitems'\n> & {\n  dsId: string | number;\n  subitems?: Item<AppInterface>[] | ReadonlyArray<Item<AppInterface>>;\n};\n\nexport interface NodeConstructorOptions<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  childIndex: number;\n  depth: number;\n  tree: DSTree<AppInterface>;\n  parent?: Node<AppInterface> | null;\n}\n\nexport interface AddOptions<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  position?: number;\n  parent?: Node<AppInterface> | null;\n  callback?: (node: Node<AppInterface>, tree: DSTree<AppInterface>) => void;\n}\n\nexport interface RemoveOptions<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  callback?: (node: Node<AppInterface>, tree: DSTree<AppInterface>) => void;\n}\n\nexport interface MoveOptions<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  position?: number;\n  parent?: Node<AppInterface>;\n  callback?: (node: Node<AppInterface>, tree: DSTree<AppInterface>) => void;\n}\n\nexport interface MutateOptions<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  callback?: (node: Node<AppInterface>, tree: DSTree<AppInterface>) => void;\n}\nexport interface OverloadedItem<AppTypedItem extends object = object> extends Item {\n  id: string;\n  subitems: OverloadedItem<AppTypedItem>[] | ReadonlyArray<OverloadedItem<AppTypedItem>>;\n  originalNodeData: AppTypedItem;\n}\n", "import * as React from 'react';\nexport { React };\n"],
+  "sourcesContent": ["import type { DSTree } from './DSTree.js';\nimport type { Node } from './Node.js';\n\nexport type AnyObjectWithoutReservedKeys = Omit<Record<string, unknown>, 'subitems'>;\n\nexport type Item<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = AppInterface & {\n  // this is not forced, this is \"optional\" in the model itself, but it's the standard way to identify a node in dimsum components\n  // the tree-model itself doesn't care about this, but do add a .dsId to the node (and not to the .plainItem) based on getUniqueId\n  // dsId: string | number;\n  subitems?: Item<AppInterface>[] | ReadonlyArray<Item<AppInterface>>;\n};\n\nexport interface NodeConstructorOptions<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  childIndex: number;\n  depth: number;\n  tree: DSTree<AppInterface>;\n  parent?: Node<AppInterface> | null;\n}\n\nexport interface AddOptions<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  position?: number;\n  parent?: Node<AppInterface> | null;\n  callback?: (node: Node<AppInterface>, tree: DSTree<AppInterface>) => void;\n}\n\nexport interface RemoveOptions<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  callback?: (node: Node<AppInterface>, tree: DSTree<AppInterface>) => void;\n}\n\nexport interface MoveOptions<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  position?: number;\n  parent?: Node<AppInterface>;\n  callback?: (node: Node<AppInterface>, tree: DSTree<AppInterface>) => void;\n}\n\nexport interface MutateOptions<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  callback?: (node: Node<AppInterface>, tree: DSTree<AppInterface>) => void;\n}\nexport interface OverloadedItem<AppTypedItem extends object = object> extends Item {\n  id: string;\n  subitems: OverloadedItem<AppTypedItem>[] | ReadonlyArray<OverloadedItem<AppTypedItem>>;\n  originalNodeData: AppTypedItem;\n}\n", "import * as React from 'react';\nexport { React };\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;ACAA,YAAuB;",
   "names": []
 }

package/dist/cjs/typescript-testing/typescript-use-ds-tree-valid.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../scripts/build/transpile/react-shim.js", "../../../src/typescript-testing/typescript-use-ds-tree-valid.tsx"],
-  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */\nimport { useDSTree } from '../index.js';\nimport type { UseDSTreeT } from '../index.js';\n\n// for the sake of this API, it's important that the app devs can pass their own interface for the item\ntype AppItemT = {\n  zipcode: number;\n  createdAt?: string;\n  likesIceCream?: boolean;\n};\n\n// test we expose the namespace and the namespace follows our deliverable conventions\ntype AppTypedItem = UseDSTreeT.TreeItem<AppItemT>;\n\nconst testPropsInferedFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n};\n\nconst testExplicitDefinitionFirstParameter: AppTypedItem = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n};\n\nconst testExplicitAsDefinitionFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444, createdAt: '2021-01-01', likesIceCream: true }],\n} as AppTypedItem;\n\nconst testDefinitionAsConstFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n} as const;\n\nconst testPropsInferedSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n};\nconst testPropsExplicitSecondParameter: UseDSTreeT.SecondParameter<AppTypedItem> = {\n  getUniqueId: (item) => item.dsId,\n};\n\nconst testPropsExplicitAsSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n} as UseDSTreeT.SecondParameter<AppTypedItem>;\n\nconst testDefinitionAsConstSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n} as const;\n\n// this is an helper to be able to check the type of the output of getPathIds\ntype IdsArrayTypeChecker = (string | number)[];\nconst ExampleUsageComponent = () => {\n  const {\n    addNode,\n    findAllNodes,\n    findNode,\n    flatten,\n    getNode,\n    getPath,\n    getPathIds,\n    getRoot,\n    hash,\n    moveNode,\n    removeNode,\n    replaceNode,\n    walk,\n    walkParents,\n  } = useDSTree<AppItemT>(testExplicitDefinitionFirstParameter, testPropsExplicitSecondParameter);\n  addNode({ dsId: 'sub_item_id2', zipcode: 4444 });\n  findAllNodes((node) => node.plainItem.zipcode === 4444);\n  findNode((node) => node.plainItem.zipcode === 4444);\n  const nodes = flatten() as UseDSTreeT.TreeNode<AppItemT>[];\n\n  const newlyAddedNode = getNode('sub_item_id2') as UseDSTreeT.TreeNode<AppItemT>;\n  const path = getPath('sub_item_id2') as UseDSTreeT.TreeNode<AppItemT>[];\n  const pathIds = getPathIds('sub_item_id2') as IdsArrayTypeChecker;\n  const root = getRoot() as UseDSTreeT.TreeNode<AppItemT>;\n  moveNode('sub_item_id1', { position: 0, parent: newlyAddedNode });\n  removeNode('sub_item_id1');\n  replaceNode('sub_item_id2', { dsId: 'sub_item_id2', zipcode: 4433 });\n  walk((node) => node.plainItem.zipcode === 4433);\n  walkParents((node) => node.plainItem.zipcode === 4433);\n\n  const outputExplicitAs = useDSTree<AppItemT>(\n    testExplicitAsDefinitionFirstParameter,\n    testPropsExplicitAsSecondParameter,\n  );\n  const outputConst = useDSTree<AppItemT>(testDefinitionAsConstFirstParameter, testDefinitionAsConstSecondParameter);\n\n  const outputInfered = useDSTree<AppItemT>(testPropsInferedFirstParameter, testPropsInferedSecondParameter);\n\n  return null;\n};\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA,YAAuB;ACCvB,eAA0B;AAa1B,MAAM,iCAAiC;AAAA,EACrC,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,uCAAqD;AAAA,EACzD,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,yCAAyC;AAAA,EAC7C,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,MAAM,WAAW,cAAc,eAAe,KAAK,CAAC;AAClG;AAEA,MAAM,sCAAsC;AAAA,EAC1C,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,kCAAkC;AAAA,EACtC,aAAa,CAAC,SAAuB,KAAK;AAC5C;AACA,MAAM,mCAA6E;AAAA,EACjF,aAAa,CAAC,SAAS,KAAK;AAC9B;AAEA,MAAM,qCAAqC;AAAA,EACzC,aAAa,CAAC,SAAuB,KAAK;AAC5C;AAEA,MAAM,uCAAuC;AAAA,EAC3C,aAAa,CAAC,SAAuB,KAAK;AAC5C;AAIA,MAAM,wBAAwB,MAAM;AAClC,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,QAAI,oBAAoB,sCAAsC,gCAAgC;AAC9F,UAAQ,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AAC/C,eAAa,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AACtD,WAAS,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAClD,QAAM,QAAQ,QAAQ;AAEtB,QAAM,iBAAiB,QAAQ,cAAc;AAC7C,QAAM,OAAO,QAAQ,cAAc;AACnC,QAAM,UAAU,WAAW,cAAc;AACzC,QAAM,OAAO,QAAQ;AACrB,WAAS,gBAAgB,EAAE,UAAU,GAAG,QAAQ,eAAe,CAAC;AAChE,aAAW,cAAc;AACzB,cAAY,gBAAgB,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACnE,OAAK,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAC9C,cAAY,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAErD,QAAM,uBAAmB;AAAA,IACvB;AAAA,IACA;AAAA,EACF;AACA,QAAM,kBAAc,oBAAoB,qCAAqC,oCAAoC;AAEjH,QAAM,oBAAgB,oBAAoB,gCAAgC,+BAA+B;AAEzG,SAAO;AACT;",
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */\nimport { useDSTree } from '../index.js';\nimport type { UseDSTreeT } from '../index.js';\n\n// for the sake of this API, it's important that the app devs can pass their own interface for the item\ntype AppItemT = {\n  dsId: string;\n  zipcode: number;\n  createdAt?: string;\n  likesIceCream?: boolean;\n};\n\n// test we expose the namespace and the namespace follows our deliverable conventions\ntype AppTypedItem = UseDSTreeT.TreeItem<AppItemT>;\n\nconst testPropsInferedFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n};\n\nconst testExplicitDefinitionFirstParameter: AppTypedItem = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n};\n\nconst testExplicitAsDefinitionFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444, createdAt: '2021-01-01', likesIceCream: true }],\n} as AppTypedItem;\n\nconst testDefinitionAsConstFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n} as const;\n\nconst testPropsInferedSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n};\nconst testPropsExplicitSecondParameter: UseDSTreeT.SecondParameter<AppTypedItem> = {\n  getUniqueId: (item) => item.dsId,\n};\n\nconst testPropsExplicitAsSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n} as UseDSTreeT.SecondParameter<AppTypedItem>;\n\nconst testDefinitionAsConstSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n} as const;\n\n// this is an helper to be able to check the type of the output of getPathIds\ntype IdsArrayTypeChecker = (string | number)[];\nconst ExampleUsageComponent = () => {\n  const {\n    addNode,\n    findAllNodes,\n    findNode,\n    flatten,\n    getNode,\n    getPath,\n    getPathIds,\n    getRoot,\n    hash,\n    moveNode,\n    removeNode,\n    replaceNode,\n    walk,\n    walkParents,\n  } = useDSTree<AppItemT>(testExplicitDefinitionFirstParameter, testPropsExplicitSecondParameter);\n  addNode({ dsId: 'sub_item_id2', zipcode: 4444 });\n  findAllNodes((node) => node.plainItem.zipcode === 4444);\n  findNode((node) => node.plainItem.zipcode === 4444);\n  const nodes = flatten() as UseDSTreeT.TreeNode<AppItemT>[];\n\n  const newlyAddedNode = getNode('sub_item_id2') as UseDSTreeT.TreeNode<AppItemT>;\n  const path = getPath('sub_item_id2') as UseDSTreeT.TreeNode<AppItemT>[];\n  const pathIds = getPathIds('sub_item_id2') as IdsArrayTypeChecker;\n  const root = getRoot() as UseDSTreeT.TreeNode<AppItemT>;\n  moveNode('sub_item_id1', { position: 0, parent: newlyAddedNode });\n  removeNode('sub_item_id1');\n  replaceNode('sub_item_id2', { dsId: 'sub_item_id2', zipcode: 4433 });\n  walk((node) => node.plainItem.zipcode === 4433);\n  walkParents((node) => node.plainItem.zipcode === 4433);\n\n  const outputExplicitAs = useDSTree<AppItemT>(\n    testExplicitAsDefinitionFirstParameter,\n    testPropsExplicitAsSecondParameter,\n  );\n  const outputConst = useDSTree<AppItemT>(testDefinitionAsConstFirstParameter, testDefinitionAsConstSecondParameter);\n\n  const outputInfered = useDSTree<AppItemT>(testPropsInferedFirstParameter, testPropsInferedSecondParameter);\n\n  return null;\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA,YAAuB;ACCvB,eAA0B;AAc1B,MAAM,iCAAiC;AAAA,EACrC,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,uCAAqD;AAAA,EACzD,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,yCAAyC;AAAA,EAC7C,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,MAAM,WAAW,cAAc,eAAe,KAAK,CAAC;AAClG;AAEA,MAAM,sCAAsC;AAAA,EAC1C,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,kCAAkC;AAAA,EACtC,aAAa,CAAC,SAAuB,KAAK;AAC5C;AACA,MAAM,mCAA6E;AAAA,EACjF,aAAa,CAAC,SAAS,KAAK;AAC9B;AAEA,MAAM,qCAAqC;AAAA,EACzC,aAAa,CAAC,SAAuB,KAAK;AAC5C;AAEA,MAAM,uCAAuC;AAAA,EAC3C,aAAa,CAAC,SAAuB,KAAK;AAC5C;AAIA,MAAM,wBAAwB,MAAM;AAClC,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,QAAI,oBAAoB,sCAAsC,gCAAgC;AAC9F,UAAQ,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AAC/C,eAAa,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AACtD,WAAS,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAClD,QAAM,QAAQ,QAAQ;AAEtB,QAAM,iBAAiB,QAAQ,cAAc;AAC7C,QAAM,OAAO,QAAQ,cAAc;AACnC,QAAM,UAAU,WAAW,cAAc;AACzC,QAAM,OAAO,QAAQ;AACrB,WAAS,gBAAgB,EAAE,UAAU,GAAG,QAAQ,eAAe,CAAC;AAChE,aAAW,cAAc;AACzB,cAAY,gBAAgB,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACnE,OAAK,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAC9C,cAAY,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAErD,QAAM,uBAAmB;AAAA,IACvB;AAAA,IACA;AAAA,EACF;AACA,QAAM,kBAAc,oBAAoB,qCAAqC,oCAAoC;AAEjH,QAAM,oBAAgB,oBAAoB,gCAAgC,+BAA+B;AAEzG,SAAO;AACT;",
   "names": []
 }

package/dist/cjs/useDSTree.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/useDSTree.ts", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import { describe } from '@elliemae/ds-props-helpers';\nimport { useCallback, useMemo, useState } from 'react';\nimport { DSTree } from './DSTree.js';\nimport type {\n  AddOptions,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions,\n  AnyObjectWithoutReservedKeys,\n  JSONThatCanContrusctATree,\n} from './types.js';\nimport { UseDSTreePropTypes, UseDSTreeReturnType, type UseDSTreeT } from './react-desc-prop-types.js';\n\nexport const useDSTree = <AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>>(\n  rootItem: JSONThatCanContrusctATree<AppInterface>,\n  opts: UseDSTreeT.SecondParameter<AppInterface>,\n) => {\n  const tree = useMemo(() => new DSTree<AppInterface>(rootItem, opts), [opts, rootItem]);\n  const [hash, setHash] = useState(tree.hash);\n\n  const addNode = useCallback(\n    (item: JSONThatCanContrusctATree<AppInterface>, options?: AddOptions<AppInterface>) => {\n      const cb: AddOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.addNode(item, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const removeNode = useCallback(\n    (id: string, options?: RemoveOptions<AppInterface>) => {\n      const cb: RemoveOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.removeNode(id, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const moveNode = useCallback(\n    (id: string, options?: MoveOptions<AppInterface>) => {\n      const cb: MoveOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.moveNode(id, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const replaceNode = useCallback(\n    (id: string, item: JSONThatCanContrusctATree<AppInterface>, options?: MutateOptions<AppInterface>) => {\n      const cb: MutateOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.replaceNode(id, item, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  return {\n    hash,\n    getRoot: tree.getRoot,\n    getNode: tree.getNode,\n    walk: tree.walk,\n    walkParents: tree.walkParents,\n    findNode: tree.findNode,\n    findAllNodes: tree.findAllNodes,\n    flatten: tree.flatten,\n    addNode,\n    removeNode,\n    moveNode,\n    replaceNode,\n    getPath: tree.getPath,\n    getPathIds: tree.getPathIds,\n  } as UseDSTreeT.OutputT<AppInterface>;\n};\n\nuseDSTree.displayName = 'useDSTree';\nexport const UseDSTreeWithSchema = describe(useDSTree);\nUseDSTreeWithSchema.propTypes = UseDSTreePropTypes;\nUseDSTreeWithSchema.returnType = UseDSTreeReturnType;\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,8BAAyB;AACzB,mBAA+C;AAC/C,oBAAuB;AASvB,mCAAyE;AAElE,MAAM,YAAY,CACvB,UACA,SACG;AACH,QAAM,WAAO,sBAAQ,MAAM,IAAI,qBAAqB,UAAU,IAAI,GAAG,CAAC,MAAM,QAAQ,CAAC;AACrF,QAAM,CAAC,MAAM,OAAO,QAAI,uBAAS,KAAK,IAAI;AAE1C,QAAM,cAAU;AAAA,IACd,CAAC,MAA+C,YAAuC;AACrF,YAAM,KAA2C,CAAC,MAAM,WAAW;AACjE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,QAAQ,MAAM,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACxD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,iBAAa;AAAA,IACjB,CAAC,IAAY,YAA0C;AACrD,YAAM,KAA8C,CAAC,MAAM,WAAW;AACpE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,WAAW,IAAI,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACzD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,eAAW;AAAA,IACf,CAAC,IAAY,YAAwC;AACnD,YAAM,KAA4C,CAAC,MAAM,WAAW;AAClE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,SAAS,IAAI,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACvD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,kBAAc;AAAA,IAClB,CAAC,IAAY,MAA+C,YAA0C;AACpG,YAAM,KAA8C,CAAC,MAAM,WAAW;AACpE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,YAAY,IAAI,MAAM,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IAChE;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,SAAO;AAAA,IACL;AAAA,IACA,SAAS,KAAK;AAAA,IACd,SAAS,KAAK;AAAA,IACd,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,UAAU,KAAK;AAAA,IACf,cAAc,KAAK;AAAA,IACnB,SAAS,KAAK;AAAA,IACd;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS,KAAK;AAAA,IACd,YAAY,KAAK;AAAA,EACnB;AACF;AAEA,UAAU,cAAc;AACjB,MAAM,0BAAsB,kCAAS,SAAS;AACrD,oBAAoB,YAAY;AAChC,oBAAoB,aAAa;",
+  "sourcesContent": ["import { describe } from '@elliemae/ds-props-helpers';\nimport { useCallback, useMemo, useState } from 'react';\nimport { DSTree } from './DSTree.js';\nimport type {\n  AddOptions,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions,\n  AnyObjectWithoutReservedKeys,\n  Item,\n} from './types.js';\nimport { UseDSTreePropTypes, UseDSTreeReturnType, type UseDSTreeT } from './react-desc-prop-types.js';\n\nexport const useDSTree = <AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>>(\n  rootItem: Item<AppInterface>,\n  opts: UseDSTreeT.SecondParameter<AppInterface>,\n) => {\n  const tree = useMemo(() => new DSTree<AppInterface>(rootItem, opts), [opts, rootItem]);\n  const [hash, setHash] = useState(tree.hash);\n\n  const addNode = useCallback(\n    (item: Item<AppInterface>, options?: AddOptions<AppInterface>) => {\n      const cb: AddOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.addNode(item, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const removeNode = useCallback(\n    (id: string, options?: RemoveOptions<AppInterface>) => {\n      const cb: RemoveOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.removeNode(id, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const moveNode = useCallback(\n    (id: string, options?: MoveOptions<AppInterface>) => {\n      const cb: MoveOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.moveNode(id, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const replaceNode = useCallback(\n    (id: string, item: Item<AppInterface>, options?: MutateOptions<AppInterface>) => {\n      const cb: MutateOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.replaceNode(id, item, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  return {\n    hash,\n    getRoot: tree.getRoot,\n    getNode: tree.getNode,\n    walk: tree.walk,\n    walkParents: tree.walkParents,\n    findNode: tree.findNode,\n    findAllNodes: tree.findAllNodes,\n    flatten: tree.flatten,\n    addNode,\n    removeNode,\n    moveNode,\n    replaceNode,\n    getPath: tree.getPath,\n    getPathIds: tree.getPathIds,\n  } as UseDSTreeT.OutputT<AppInterface>;\n};\n\nuseDSTree.displayName = 'useDSTree';\nexport const UseDSTreeWithSchema = describe(useDSTree);\nUseDSTreeWithSchema.propTypes = UseDSTreePropTypes;\nUseDSTreeWithSchema.returnType = UseDSTreeReturnType;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,8BAAyB;AACzB,mBAA+C;AAC/C,oBAAuB;AASvB,mCAAyE;AAElE,MAAM,YAAY,CACvB,UACA,SACG;AACH,QAAM,WAAO,sBAAQ,MAAM,IAAI,qBAAqB,UAAU,IAAI,GAAG,CAAC,MAAM,QAAQ,CAAC;AACrF,QAAM,CAAC,MAAM,OAAO,QAAI,uBAAS,KAAK,IAAI;AAE1C,QAAM,cAAU;AAAA,IACd,CAAC,MAA0B,YAAuC;AAChE,YAAM,KAA2C,CAAC,MAAM,WAAW;AACjE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,QAAQ,MAAM,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACxD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,iBAAa;AAAA,IACjB,CAAC,IAAY,YAA0C;AACrD,YAAM,KAA8C,CAAC,MAAM,WAAW;AACpE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,WAAW,IAAI,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACzD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,eAAW;AAAA,IACf,CAAC,IAAY,YAAwC;AACnD,YAAM,KAA4C,CAAC,MAAM,WAAW;AAClE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,SAAS,IAAI,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACvD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,kBAAc;AAAA,IAClB,CAAC,IAAY,MAA0B,YAA0C;AAC/E,YAAM,KAA8C,CAAC,MAAM,WAAW;AACpE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,YAAY,IAAI,MAAM,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IAChE;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,SAAO;AAAA,IACL;AAAA,IACA,SAAS,KAAK;AAAA,IACd,SAAS,KAAK;AAAA,IACd,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,UAAU,KAAK;AAAA,IACf,cAAc,KAAK;AAAA,IACnB,SAAS,KAAK;AAAA,IACd;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS,KAAK;AAAA,IACd,YAAY,KAAK;AAAA,EACnB;AACF;AAEA,UAAU,cAAc;AACjB,MAAM,0BAAsB,kCAAS,SAAS;AACrD,oBAAoB,YAAY;AAChC,oBAAoB,aAAa;",
   "names": []
 }

package/dist/esm/DSTree.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/DSTree.ts"],
-  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable no-underscore-dangle */\nimport type {\n  AddOptions,\n  AnyObjectWithoutReservedKeys,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions,\n  JSONThatCanContrusctATree,\n  Item,\n} from './types.js';\nimport { Node } from './Node.js';\n\nexport class DSTree<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  private root: Node<AppInterface>;\n\n  private _hash: number;\n\n  private nodes: Record<string | number, Node<AppInterface>>;\n\n  getUniqueId: (item: Item<AppInterface>) => string | number;\n\n  constructor(\n    item: JSONThatCanContrusctATree<AppInterface>,\n    options: { getUniqueId: (item: Item<AppInterface>) => string | number },\n  ) {\n    this.getUniqueId = options.getUniqueId;\n    this.root = new Node<AppInterface>(item, { childIndex: 0, depth: 0, tree: this });\n    this.nodes = {};\n    this._hash = 0;\n\n    // autocalculate a dictionary where dsId are keys and nodes are values\n    // and add the tree link to each node\n    this.root.walk((node) => {\n      this.nodes[node.dsId] = node;\n      return true;\n    });\n  }\n\n  addNodeToNodesDictionary(node: Node<AppInterface>): void {\n    // check that we have no repeated ids\n    if (this.nodes[node.dsId]) {\n      throw new Error(`DSTree: repeated dsId ${node.dsId}`);\n    }\n\n    this.nodes[node.dsId] = node;\n  }\n\n  removeNodeFromNodesDictionary(node: Node<AppInterface>): void {\n    delete this.nodes[node.dsId];\n  }\n\n  get hash(): number {\n    return this._hash;\n  }\n\n  getRoot = (): Node<AppInterface> => this.root;\n\n  getNode = (id: string | number): Node<AppInterface> => this.nodes[id];\n\n  getNodes = (): Record<string, Node<AppInterface>> => this.nodes;\n\n  walk = (callback: (node: Node<AppInterface>) => boolean): void => {\n    this.root.walk(callback);\n  };\n\n  walkParents = (callback: (node: Node<AppInterface>) => boolean): void => {\n    this.root.walkParents(callback);\n  };\n\n  findNode = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface> | null =>\n    this.root.findNode(callback);\n\n  findAllNodes = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface>[] =>\n    this.root.findAllNodes(callback);\n\n  flatten = (): Node<AppInterface>[] => this.root.flatten();\n\n  addNode = (\n    item: JSONThatCanContrusctATree<AppInterface>,\n    options: AddOptions<AppInterface> = {},\n  ): Node<AppInterface> => {\n    const { position, parent, callback } = options;\n    const parentDefault = parent || this.root;\n    const positionDefault = position ?? parentDefault.children.length;\n\n    // create node and add it to the parent\n    const node = new Node<AppInterface>(item, {\n      childIndex: positionDefault,\n      depth: parentDefault.depth + 1,\n      parent: parentDefault,\n      tree: this,\n    });\n    this.getNode(parentDefault.dsId).addNode(node);\n\n    // change hash\n    this._hash += 1;\n\n    // invoke the callback if present\n    callback?.(node, this);\n\n    return node;\n  };\n\n  removeNode = (id: string | number, options: RemoveOptions<AppInterface> = {}): Node<AppInterface> => {\n    const node = this.getNode(id);\n    if (!node) throw new Error(`Node with id ${id} not found`);\n\n    node.removeNode();\n\n    // change hash\n    this._hash += 1;\n\n    // invoke the callback if present\n    options.callback?.(node, this);\n\n    return node;\n  };\n\n  moveNode = (id: string | number, options: MoveOptions<AppInterface> = {}): Node<AppInterface> => {\n    const removedNode = this.removeNode(id);\n    const node = this.addNode(removedNode.getJson(), options);\n\n    this._hash += 1;\n\n    return node;\n  };\n\n  replaceNode = (\n    id: string | number,\n    item: JSONThatCanContrusctATree<AppInterface>,\n    options: MutateOptions<AppInterface> = {},\n  ): Node<AppInterface> => {\n    const removedNode = this.removeNode(id);\n    const node = this.addNode(item, { parent: removedNode.parent, position: removedNode.childIndex });\n\n    this._hash += 1;\n\n    // invoke the callback if present\n    options.callback?.(node, this);\n\n    return node;\n  };\n\n  getPath = (id: string | number): Node<AppInterface>[] => this.getRoot().getPath(id);\n\n  getPathIds = (id: string | number) => this.getRoot().getPathIds(id);\n}\n"],
-  "mappings": "AAAA,YAAY,WAAW;ACUvB,SAAS,YAAY;AAEd,MAAM,OAAoF;AAAA,EAS/F,YACE,MACA,SACA;AA+BF,mBAAU,MAA0B,KAAK;AAEzC,mBAAU,CAAC,OAA4C,KAAK,MAAM,EAAE;AAEpE,oBAAW,MAA0C,KAAK;AAE1D,gBAAO,CAAC,aAA0D;AAChE,WAAK,KAAK,KAAK,QAAQ;AAAA,IACzB;AAEA,uBAAc,CAAC,aAA0D;AACvE,WAAK,KAAK,YAAY,QAAQ;AAAA,IAChC;AAEA,oBAAW,CAAC,aACV,KAAK,KAAK,SAAS,QAAQ;AAE7B,wBAAe,CAAC,aACd,KAAK,KAAK,aAAa,QAAQ;AAEjC,mBAAU,MAA4B,KAAK,KAAK,QAAQ;AAExD,mBAAU,CACR,MACA,UAAoC,CAAC,MACd;AACvB,YAAM,EAAE,UAAU,QAAQ,SAAS,IAAI;AACvC,YAAM,gBAAgB,UAAU,KAAK;AACrC,YAAM,kBAAkB,YAAY,cAAc,SAAS;AAG3D,YAAM,OAAO,IAAI,KAAmB,MAAM;AAAA,QACxC,YAAY;AAAA,QACZ,OAAO,cAAc,QAAQ;AAAA,QAC7B,QAAQ;AAAA,QACR,MAAM;AAAA,MACR,CAAC;AACD,WAAK,QAAQ,cAAc,IAAI,EAAE,QAAQ,IAAI;AAG7C,WAAK,SAAS;AAGd,iBAAW,MAAM,IAAI;AAErB,aAAO;AAAA,IACT;AAEA,sBAAa,CAAC,IAAqB,UAAuC,CAAC,MAA0B;AACnG,YAAM,OAAO,KAAK,QAAQ,EAAE;AAC5B,UAAI,CAAC,KAAM,OAAM,IAAI,MAAM,gBAAgB,EAAE,YAAY;AAEzD,WAAK,WAAW;AAGhB,WAAK,SAAS;AAGd,cAAQ,WAAW,MAAM,IAAI;AAE7B,aAAO;AAAA,IACT;AAEA,oBAAW,CAAC,IAAqB,UAAqC,CAAC,MAA0B;AAC/F,YAAM,cAAc,KAAK,WAAW,EAAE;AACtC,YAAM,OAAO,KAAK,QAAQ,YAAY,QAAQ,GAAG,OAAO;AAExD,WAAK,SAAS;AAEd,aAAO;AAAA,IACT;AAEA,uBAAc,CACZ,IACA,MACA,UAAuC,CAAC,MACjB;AACvB,YAAM,cAAc,KAAK,WAAW,EAAE;AACtC,YAAM,OAAO,KAAK,QAAQ,MAAM,EAAE,QAAQ,YAAY,QAAQ,UAAU,YAAY,WAAW,CAAC;AAEhG,WAAK,SAAS;AAGd,cAAQ,WAAW,MAAM,IAAI;AAE7B,aAAO;AAAA,IACT;AAEA,mBAAU,CAAC,OAA8C,KAAK,QAAQ,EAAE,QAAQ,EAAE;AAElF,sBAAa,CAAC,OAAwB,KAAK,QAAQ,EAAE,WAAW,EAAE;AAxHhE,SAAK,cAAc,QAAQ;AAC3B,SAAK,OAAO,IAAI,KAAmB,MAAM,EAAE,YAAY,GAAG,OAAO,GAAG,MAAM,KAAK,CAAC;AAChF,SAAK,QAAQ,CAAC;AACd,SAAK,QAAQ;AAIb,SAAK,KAAK,KAAK,CAAC,SAAS;AACvB,WAAK,MAAM,KAAK,IAAI,IAAI;AACxB,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA,EAEA,yBAAyB,MAAgC;AAEvD,QAAI,KAAK,MAAM,KAAK,IAAI,GAAG;AACzB,YAAM,IAAI,MAAM,yBAAyB,KAAK,IAAI,EAAE;AAAA,IACtD;AAEA,SAAK,MAAM,KAAK,IAAI,IAAI;AAAA,EAC1B;AAAA,EAEA,8BAA8B,MAAgC;AAC5D,WAAO,KAAK,MAAM,KAAK,IAAI;AAAA,EAC7B;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK;AAAA,EACd;AA6FF;",
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable no-underscore-dangle */\nimport type {\n  AddOptions,\n  AnyObjectWithoutReservedKeys,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions,\n  Item,\n} from './types.js';\nimport { Node } from './Node.js';\n\nexport class DSTree<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  private root: Node<AppInterface>;\n\n  private _hash: number;\n\n  private nodes: Record<string | number, Node<AppInterface>>;\n\n  getUniqueId: (item: Item<AppInterface>) => string | number;\n\n  constructor(item: Item<AppInterface>, options: { getUniqueId: (item: Item<AppInterface>) => string | number }) {\n    this.getUniqueId = options.getUniqueId;\n    this.root = new Node<AppInterface>(item, { childIndex: 0, depth: 0, tree: this });\n    this.nodes = {};\n    this._hash = 0;\n\n    // autocalculate a dictionary where dsId are keys and nodes are values\n    // and add the tree link to each node\n    this.root.walk((node) => {\n      this.nodes[node.dsId] = node;\n      return true;\n    });\n  }\n\n  addNodeToNodesDictionary(node: Node<AppInterface>): void {\n    // check that we have no repeated ids\n    if (this.nodes[node.dsId]) {\n      throw new Error(`DSTree: repeated dsId ${node.dsId}`);\n    }\n\n    this.nodes[node.dsId] = node;\n  }\n\n  removeNodeFromNodesDictionary(node: Node<AppInterface>): void {\n    delete this.nodes[node.dsId];\n  }\n\n  get hash(): number {\n    return this._hash;\n  }\n\n  getRoot = (): Node<AppInterface> => this.root;\n\n  getNode = (id: string | number): Node<AppInterface> => this.nodes[id];\n\n  getNodes = (): Record<string, Node<AppInterface>> => this.nodes;\n\n  walk = (callback: (node: Node<AppInterface>) => boolean): void => {\n    this.root.walk(callback);\n  };\n\n  walkParents = (callback: (node: Node<AppInterface>) => boolean): void => {\n    this.root.walkParents(callback);\n  };\n\n  findNode = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface> | null =>\n    this.root.findNode(callback);\n\n  findAllNodes = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface>[] =>\n    this.root.findAllNodes(callback);\n\n  flatten = (): Node<AppInterface>[] => this.root.flatten();\n\n  addNode = (item: Item<AppInterface>, options: AddOptions<AppInterface> = {}): Node<AppInterface> => {\n    const { position, parent, callback } = options;\n    const parentDefault = parent || this.root;\n    const positionDefault = position ?? parentDefault.children.length;\n\n    // create node and add it to the parent\n    const node = new Node<AppInterface>(item, {\n      childIndex: positionDefault,\n      depth: parentDefault.depth + 1,\n      parent: parentDefault,\n      tree: this,\n    });\n    this.getNode(parentDefault.dsId).addNode(node);\n\n    // change hash\n    this._hash += 1;\n\n    // invoke the callback if present\n    callback?.(node, this);\n\n    return node;\n  };\n\n  removeNode = (id: string | number, options: RemoveOptions<AppInterface> = {}): Node<AppInterface> => {\n    const node = this.getNode(id);\n    if (!node) throw new Error(`Node with id ${id} not found`);\n\n    node.removeNode();\n\n    // change hash\n    this._hash += 1;\n\n    // invoke the callback if present\n    options.callback?.(node, this);\n\n    return node;\n  };\n\n  moveNode = (id: string | number, options: MoveOptions<AppInterface> = {}): Node<AppInterface> => {\n    const removedNode = this.removeNode(id);\n    const node = this.addNode(removedNode.getJson(), options);\n\n    this._hash += 1;\n\n    return node;\n  };\n\n  replaceNode = (\n    id: string | number,\n    item: Item<AppInterface>,\n    options: MutateOptions<AppInterface> = {},\n  ): Node<AppInterface> => {\n    const removedNode = this.removeNode(id);\n    const node = this.addNode(item, { parent: removedNode.parent, position: removedNode.childIndex });\n\n    this._hash += 1;\n\n    // invoke the callback if present\n    options.callback?.(node, this);\n\n    return node;\n  };\n\n  getPath = (id: string | number): Node<AppInterface>[] => this.getRoot().getPath(id);\n\n  getPathIds = (id: string | number) => this.getRoot().getPathIds(id);\n}\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACSvB,SAAS,YAAY;AAEd,MAAM,OAAoF;AAAA,EAS/F,YAAY,MAA0B,SAAyE;AA+B/G,mBAAU,MAA0B,KAAK;AAEzC,mBAAU,CAAC,OAA4C,KAAK,MAAM,EAAE;AAEpE,oBAAW,MAA0C,KAAK;AAE1D,gBAAO,CAAC,aAA0D;AAChE,WAAK,KAAK,KAAK,QAAQ;AAAA,IACzB;AAEA,uBAAc,CAAC,aAA0D;AACvE,WAAK,KAAK,YAAY,QAAQ;AAAA,IAChC;AAEA,oBAAW,CAAC,aACV,KAAK,KAAK,SAAS,QAAQ;AAE7B,wBAAe,CAAC,aACd,KAAK,KAAK,aAAa,QAAQ;AAEjC,mBAAU,MAA4B,KAAK,KAAK,QAAQ;AAExD,mBAAU,CAAC,MAA0B,UAAoC,CAAC,MAA0B;AAClG,YAAM,EAAE,UAAU,QAAQ,SAAS,IAAI;AACvC,YAAM,gBAAgB,UAAU,KAAK;AACrC,YAAM,kBAAkB,YAAY,cAAc,SAAS;AAG3D,YAAM,OAAO,IAAI,KAAmB,MAAM;AAAA,QACxC,YAAY;AAAA,QACZ,OAAO,cAAc,QAAQ;AAAA,QAC7B,QAAQ;AAAA,QACR,MAAM;AAAA,MACR,CAAC;AACD,WAAK,QAAQ,cAAc,IAAI,EAAE,QAAQ,IAAI;AAG7C,WAAK,SAAS;AAGd,iBAAW,MAAM,IAAI;AAErB,aAAO;AAAA,IACT;AAEA,sBAAa,CAAC,IAAqB,UAAuC,CAAC,MAA0B;AACnG,YAAM,OAAO,KAAK,QAAQ,EAAE;AAC5B,UAAI,CAAC,KAAM,OAAM,IAAI,MAAM,gBAAgB,EAAE,YAAY;AAEzD,WAAK,WAAW;AAGhB,WAAK,SAAS;AAGd,cAAQ,WAAW,MAAM,IAAI;AAE7B,aAAO;AAAA,IACT;AAEA,oBAAW,CAAC,IAAqB,UAAqC,CAAC,MAA0B;AAC/F,YAAM,cAAc,KAAK,WAAW,EAAE;AACtC,YAAM,OAAO,KAAK,QAAQ,YAAY,QAAQ,GAAG,OAAO;AAExD,WAAK,SAAS;AAEd,aAAO;AAAA,IACT;AAEA,uBAAc,CACZ,IACA,MACA,UAAuC,CAAC,MACjB;AACvB,YAAM,cAAc,KAAK,WAAW,EAAE;AACtC,YAAM,OAAO,KAAK,QAAQ,MAAM,EAAE,QAAQ,YAAY,QAAQ,UAAU,YAAY,WAAW,CAAC;AAEhG,WAAK,SAAS;AAGd,cAAQ,WAAW,MAAM,IAAI;AAE7B,aAAO;AAAA,IACT;AAEA,mBAAU,CAAC,OAA8C,KAAK,QAAQ,EAAE,QAAQ,EAAE;AAElF,sBAAa,CAAC,OAAwB,KAAK,QAAQ,EAAE,WAAW,EAAE;AArHhE,SAAK,cAAc,QAAQ;AAC3B,SAAK,OAAO,IAAI,KAAmB,MAAM,EAAE,YAAY,GAAG,OAAO,GAAG,MAAM,KAAK,CAAC;AAChF,SAAK,QAAQ,CAAC;AACd,SAAK,QAAQ;AAIb,SAAK,KAAK,KAAK,CAAC,SAAS;AACvB,WAAK,MAAM,KAAK,IAAI,IAAI;AACxB,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA,EAEA,yBAAyB,MAAgC;AAEvD,QAAI,KAAK,MAAM,KAAK,IAAI,GAAG;AACzB,YAAM,IAAI,MAAM,yBAAyB,KAAK,IAAI,EAAE;AAAA,IACtD;AAEA,SAAK,MAAM,KAAK,IAAI,IAAI;AAAA,EAC1B;AAAA,EAEA,8BAA8B,MAAgC;AAC5D,WAAO,KAAK,MAAM,KAAK,IAAI;AAAA,EAC7B;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK;AAAA,EACd;AA0FF;",
   "names": []
 }

package/dist/esm/Node.js

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { cloneDeep, omit } from "lodash";
+import { cloneDeep } from "lodash";
 class Node {
   constructor(item, { childIndex, depth, parent, tree }) {
     // ===========================================================================
@@ -12,7 +12,7 @@ class Node {
       this._hash += 1;
     };
     this.getCleanItem = (item) => {
-      const plainItem = omit(item, ["subitems"]);
+      const { subitems, ...plainItem } = item;
       return cloneDeep(plainItem);
     };
     this.walk = (callback) => {
@@ -95,22 +95,27 @@ class Node {
       });
       this._hash += 1;
     };
-    const itemCasted = item;
-    this.dsId = tree.getUniqueId(itemCasted);
+    this.dsId = tree.getUniqueId(item);
     this.childIndex = childIndex;
     this.depth = depth;
     this.parent = parent ?? null;
     this.tree = tree;
     this._hash = 0;
-    this.children = item.subitems?.map(
-      (subitem, index) => new Node(subitem, {
-        childIndex: index,
-        depth: depth + 1,
-        parent: this,
-        tree
-      })
-    ) ?? [];
-    this.plainItem = this.getCleanItem(itemCasted);
+    this.children = [];
+    this.plainChildren = [];
+    const subitems = item.subitems ?? [];
+    subitems.forEach((subitem, index) => {
+      this.plainChildren.push(this.getCleanItem(subitem));
+      this.children.push(
+        new Node(subitem, {
+          childIndex: index,
+          depth: depth + 1,
+          parent: this,
+          tree
+        })
+      );
+    });
+    this.plainItem = this.getCleanItem(item);
   }
   // ===========================================================================
   // READ METHODS

package/dist/esm/Node.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/Node.ts"],
-  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable no-underscore-dangle */\n/* eslint-disable no-use-before-define */\n/* eslint-disable max-params */\nimport { cloneDeep, omit } from 'lodash';\nimport type { DSTree } from './DSTree.js';\nimport type { NodeConstructorOptions, AnyObjectWithoutReservedKeys, JSONThatCanContrusctATree, Item } from './types.js';\n\nexport class Node<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  dsId: string | number;\n\n  childIndex: number;\n\n  depth: number;\n\n  plainItem: Omit<Item<AppInterface>, 'subitems'>;\n\n  parent: Node<AppInterface> | null;\n\n  children: Node<AppInterface>[];\n\n  private tree!: DSTree<AppInterface>;\n\n  private _hash: number;\n\n  constructor(\n    item: JSONThatCanContrusctATree<AppInterface>,\n    { childIndex, depth, parent, tree }: NodeConstructorOptions<AppInterface>,\n  ) {\n    const itemCasted = item as Item<AppInterface>;\n    this.dsId = tree.getUniqueId(itemCasted);\n    this.childIndex = childIndex;\n    this.depth = depth;\n    this.parent = parent ?? null;\n    this.tree = tree;\n    this._hash = 0;\n\n    this.children =\n      item.subitems?.map(\n        (subitem, index) =>\n          new Node<AppInterface>(subitem, {\n            childIndex: index,\n            depth: depth + 1,\n            parent: this,\n            tree,\n          }),\n      ) ?? ([] as Node<AppInterface>[]);\n\n    // Save the item without the subitems\n    this.plainItem = this.getCleanItem(itemCasted);\n  }\n\n  // ===========================================================================\n  // INTERNAL METHODS\n  // ===========================================================================\n\n  fixChildIndexes = (): void => {\n    for (let i = 0; i < this.children.length; i += 1) {\n      this.children[i].childIndex = i;\n    }\n    this._hash += 1;\n  };\n\n  getCleanItem = (item: Item<AppInterface>): Omit<Item<AppInterface>, 'subitems'> => {\n    const plainItem = omit(item, ['subitems']);\n    return cloneDeep(plainItem);\n  };\n\n  // ===========================================================================\n  // READ METHODS\n  // ===========================================================================\n\n  get hash(): number {\n    return this._hash;\n  }\n\n  walk = (callback: (node: Node<AppInterface>) => boolean): void => {\n    const shouldContinueWalking = callback(this);\n    if (shouldContinueWalking) {\n      // eslint-disable-next-line no-restricted-syntax\n      for (const child of this.children) {\n        child.walk(callback);\n      }\n    }\n  };\n\n  walkParents = (callback: (node: Node<AppInterface>) => boolean): void => {\n    const shouldContinueWalking = callback(this);\n    if (shouldContinueWalking && this.parent) {\n      this.parent.walkParents(callback);\n    }\n  };\n\n  findNode = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface> | null => {\n    // find first node using walk\n    let found: Node<AppInterface> | null = null;\n    this.walk((node) => {\n      // If we already found it, don't look anymore\n      if (found) return false;\n\n      // Otherwise keep looking\n      if (callback(node)) found = node;\n      return !found;\n    });\n\n    return found;\n  };\n\n  findAllNodes = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface>[] => {\n    const found: Node<AppInterface>[] = [];\n    this.walk((node) => {\n      if (callback(node)) found.push(node);\n      return true;\n    });\n    return found;\n  };\n\n  flatten = (): Node<AppInterface>[] => {\n    const flattened: Node<AppInterface>[] = [];\n    this.walk((node) => {\n      flattened.push(node);\n      return true;\n    });\n    return flattened;\n  };\n\n  getPath = (id: string | number): Node<AppInterface>[] => {\n    const path: Node<AppInterface>[] = [];\n    const node = this.tree.getNode(id);\n    if (!node) return path;\n    node.walkParents((parent) => {\n      path.push(parent);\n      return parent.dsId !== this.dsId;\n    });\n    return path.reverse();\n  };\n\n  getPathIds = (id: string | number) => this.getPath(id).map((node) => node.dsId);\n\n  getJson = (): JSONThatCanContrusctATree<AppInterface> =>\n    ({\n      ...this.plainItem,\n      subitems: this.children?.map?.((child) => child.getJson()) ?? undefined,\n    }) as JSONThatCanContrusctATree<AppInterface>;\n\n  // ===========================================================================\n  // WRITE METHODS\n  // ===========================================================================\n\n  addNode = (node: Node<AppInterface>) => {\n    // check that the position is valid for that parent\n    const position = node.childIndex;\n    if (position < 0 || position > this.children.length) {\n      throw new Error(`Invalid position ${position} for parent ${this.dsId} with item ${node.dsId}`);\n    }\n\n    // add the new node\n    this.children.splice(position, 0, node);\n\n    // fix the childIndex of the nodes after the new one\n    this.fixChildIndexes();\n\n    // add subtree of the new node to the node dictionary\n    node.walk((child) => {\n      this.tree.addNodeToNodesDictionary(child);\n      return true;\n    });\n\n    this._hash += 1;\n  };\n\n  removeNode = () => {\n    // if no parent throw error\n    if (!this.parent) throw new Error(`Cannot remove root node with id ${this.dsId}`);\n\n    // remove from parent\n    this.parent.children.splice(this.childIndex, 1);\n\n    // fix the childIndex of the nodes of the parent\n    this.parent.fixChildIndexes();\n\n    // remove subtree from the node dictionary\n    this.walk((child) => {\n      this.tree.removeNodeFromNodesDictionary(child);\n      return true;\n    });\n\n    this._hash += 1;\n  };\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable no-underscore-dangle */\n/* eslint-disable no-use-before-define */\n/* eslint-disable max-params */\nimport { cloneDeep } from 'lodash';\nimport type { DSTree } from './DSTree.js';\nimport type { NodeConstructorOptions, AnyObjectWithoutReservedKeys, Item } from './types.js';\n\nexport class Node<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n  dsId: string | number;\n\n  childIndex: number;\n\n  depth: number;\n\n  plainItem: AppInterface;\n\n  plainChildren: AppInterface[];\n\n  parent: Node<AppInterface> | null;\n\n  children: Node<AppInterface>[];\n\n  private tree!: DSTree<AppInterface>;\n\n  private _hash: number;\n\n  constructor(item: Item<AppInterface>, { childIndex, depth, parent, tree }: NodeConstructorOptions<AppInterface>) {\n    this.dsId = tree.getUniqueId(item);\n    this.childIndex = childIndex;\n    this.depth = depth;\n    this.parent = parent ?? null;\n    this.tree = tree;\n    this._hash = 0;\n    this.children = [];\n    this.plainChildren = [];\n\n    // on construction, we add the children to the node\n    // this will recursively happen for all children because this triggers `new Node()` recursively\n    const subitems = item.subitems ?? [];\n    subitems.forEach((subitem, index) => {\n      this.plainChildren.push(this.getCleanItem(subitem));\n      this.children.push(\n        new Node<AppInterface>(subitem, {\n          childIndex: index,\n          depth: depth + 1,\n          parent: this,\n          tree,\n        }),\n      );\n    });\n    // Save the item without the subitems\n    this.plainItem = this.getCleanItem(item);\n  }\n\n  // ===========================================================================\n  // INTERNAL METHODS\n  // ===========================================================================\n\n  fixChildIndexes = (): void => {\n    for (let i = 0; i < this.children.length; i += 1) {\n      this.children[i].childIndex = i;\n    }\n    this._hash += 1;\n  };\n\n  getCleanItem = (item: Item<AppInterface>): AppInterface => {\n    const { subitems, ...plainItem } = item;\n    return cloneDeep(plainItem as AppInterface);\n  };\n\n  // ===========================================================================\n  // READ METHODS\n  // ===========================================================================\n\n  get hash(): number {\n    return this._hash;\n  }\n\n  walk = (callback: (node: Node<AppInterface>) => boolean): void => {\n    const shouldContinueWalking = callback(this);\n    if (shouldContinueWalking) {\n      // eslint-disable-next-line no-restricted-syntax\n      for (const child of this.children) {\n        child.walk(callback);\n      }\n    }\n  };\n\n  walkParents = (callback: (node: Node<AppInterface>) => boolean): void => {\n    const shouldContinueWalking = callback(this);\n    if (shouldContinueWalking && this.parent) {\n      this.parent.walkParents(callback);\n    }\n  };\n\n  findNode = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface> | null => {\n    // find first node using walk\n    let found: Node<AppInterface> | null = null;\n    this.walk((node) => {\n      // If we already found it, don't look anymore\n      if (found) return false;\n\n      // Otherwise keep looking\n      if (callback(node)) found = node;\n      return !found;\n    });\n\n    return found;\n  };\n\n  findAllNodes = (callback: (node: Node<AppInterface>) => boolean): Node<AppInterface>[] => {\n    const found: Node<AppInterface>[] = [];\n    this.walk((node) => {\n      if (callback(node)) found.push(node);\n      return true;\n    });\n    return found;\n  };\n\n  flatten = (): Node<AppInterface>[] => {\n    const flattened: Node<AppInterface>[] = [];\n    this.walk((node) => {\n      flattened.push(node);\n      return true;\n    });\n    return flattened;\n  };\n\n  getPath = (id: string | number): Node<AppInterface>[] => {\n    const path: Node<AppInterface>[] = [];\n    const node = this.tree.getNode(id);\n    if (!node) return path;\n    node.walkParents((parent) => {\n      path.push(parent);\n      return parent.dsId !== this.dsId;\n    });\n    return path.reverse();\n  };\n\n  getPathIds = (id: string | number) => this.getPath(id).map((node) => node.dsId);\n\n  getJson = (): Item<AppInterface> =>\n    ({\n      ...this.plainItem,\n      subitems: this.children?.map?.((child) => child.getJson()) ?? undefined,\n    }) as Item<AppInterface>;\n\n  // ===========================================================================\n  // WRITE METHODS\n  // ===========================================================================\n\n  addNode = (node: Node<AppInterface>) => {\n    // check that the position is valid for that parent\n    const position = node.childIndex;\n    if (position < 0 || position > this.children.length) {\n      throw new Error(`Invalid position ${position} for parent ${this.dsId} with item ${node.dsId}`);\n    }\n\n    // add the new node\n    this.children.splice(position, 0, node);\n\n    // fix the childIndex of the nodes after the new one\n    this.fixChildIndexes();\n\n    // add subtree of the new node to the node dictionary\n    node.walk((child) => {\n      this.tree.addNodeToNodesDictionary(child);\n      return true;\n    });\n\n    this._hash += 1;\n  };\n\n  removeNode = () => {\n    // if no parent throw error\n    if (!this.parent) throw new Error(`Cannot remove root node with id ${this.dsId}`);\n\n    // remove from parent\n    this.parent.children.splice(this.childIndex, 1);\n\n    // fix the childIndex of the nodes of the parent\n    this.parent.fixChildIndexes();\n\n    // remove subtree from the node dictionary\n    this.walk((child) => {\n      this.tree.removeNodeFromNodesDictionary(child);\n      return true;\n    });\n\n    this._hash += 1;\n  };\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/esm/adapters/arraish-tree/fromTreeishArrayToDSTree.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../../scripts/build/transpile/react-shim.js", "../../../../src/adapters/arraish-tree/fromTreeishArrayToDSTree.ts"],
-  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable max-statements */\nimport { DSTree } from '../../DSTree.js';\nimport type { OverloadedItem } from '../../types.js';\n\n// we don't really need a 100% sure unique id, since we prepend a string that is most likely unique already\n//  we just need to reduce the risk of collisions\n//  we avoid depending on a library for this:\nconst unsecureUuid = () =>\n  'xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n    const r = Math.random() * 16 || 0;\n    // eslint-disable-next-line no-bitwise\n    const v = c === 'x' ? r : r & 0x3 || 0x8;\n    return v.toString(16);\n  });\n\n/*\n * @param {Object} args\n * @param {Function} args.callback - a function that will be called for each node in the treeish data-structure\n * @param {Object} args.node - the node that is being currently visited\n * @param {Object} args.opts - an object that holds the opinions of the caller on how to walk the treeish data-structure\n * @param {Function} args.opts.getChildren - a function that given a node returns an array of children\n * @returns {void}\n */\nconst walkTreeish = <T extends object>({\n  callback,\n  node,\n  opts,\n}: {\n  callback: (node: T) => void;\n  node: T;\n  opts?: {\n    getChildren: (node: T) => T[];\n  };\n}): void => {\n  callback(node);\n  const children = opts?.getChildren(node);\n  if (Array.isArray(children) && children.length > 0) {\n    for (let i = 0; i < children.length; i += 1) {\n      walkTreeish<T>({ callback, node: children[i], opts });\n    }\n  }\n};\n\n/*\n * a function that given a treeish array and some options returns a DSTree datastructure that compltely preserves the treeish array\n *  but still allows to use the full power of the DSTree datastructure\n * NOTE: This create a deep clone of the treeish array, so it's not suitable for large trees and will not preserve any reference to the original treeish array\n * @param {Array} treeish - an array of items that rapresents a tree, this will be used to create a DSTree datastructure\n * @param {Object} opts - an object that governs how the treeish array will be converted to a DSTree datastructure\n * @param {Function} opts.getChildrenKey - a function that given a node returns the key used to access the node children\n * @param {Function} opts.getUniqueId - a function that given a node returns a unique string used to identify the node\n * @returns {DSTree} - a DSTree datastructure\n */\nexport const fromTreeishArrayToDSTree = <T extends object = object>(args: {\n  treeish: T[];\n  opts: {\n    getChildrenKey: (node: T) => keyof T;\n    getUniqueId: (item: T) => string;\n  };\n}): DSTree<OverloadedItem<T>> => {\n  // we use crypto to generate a unique id for the root, this is important for reduce the risk of collisions with any user provided id\n  const rootId = `_autogenerated-ds-pseudoRoot-${unsecureUuid()}`;\n  const { opts, treeish } = args;\n  const { getUniqueId, getChildrenKey } = opts;\n\n  // a DSTree compatible datastructure has the following characteristics:\n  //  - it has a \"subitems\" property that contains an array of children\n  //  - it has a property that holds a unique string used to identify the node (accessed via the getUniqueId function)\n  //  - it is in an object format\n  // @ts-expect-error this is an extremely opinionated algorithm that was built as a one-off, we are not spending time to make it typesafe\n  const pseudoRoot: OverloadedItem<T> = {\n    id: rootId,\n    subitems: structuredClone(treeish) as unknown as OverloadedItem<T>[],\n    originalNodeData: {} as T,\n  };\n  // we now create an over-charged getChildren function\n  //  this is because we mutate the object every step during the walk\n  //  this function is going to receive the OverloadedItem<T> each step\n  const overloadedGetChildren = (node: OverloadedItem<T>) => node.subitems;\n  const overloadedGetUniqueId = (node: OverloadedItem<T>) => node.id;\n  // we now create a \"callback\" function that will be used when walking the pseudoRoot object.\n  //  this callback will mutate the pseudoRoot object, making sure that after the mutation it will be compatible with the DSTree datastructure\n  //  we can't really make an assumption that the subitems key isn't somehow already part of the data from the user,\n  //     so to avoid any collision we will create an extra-level of nesting, in this layer only 3 properties will be allowed:\n  //    - id: a unique string used to identify the node, this is already a requirement from the treeish datastructure provided by the user\n  //    - subitems: an array of children\n  //    - original: the original data provided by the user\n  //        we remove the original tree rapresentation from the node, we only want one source of truth for the tree\n  //        if we don't remove this, when operating the DSTree we would have to somehow also propagate the changes to the original tree\n  //          the way this is intended to be used is instead to convert back and forth between the DSTree and the treeish array\n  //          the conversion will restore the treeish structure with the updated tree after operating on the DSTree\n  const callback = (node: OverloadedItem<T>) => {\n    // we skip the root node\n    if (node.id === rootId) return;\n    // we safe-keep the original data provided by the user\n    const originalNodeData = structuredClone(node) as unknown as T;\n    // we now mutate the node, making it compatible with the DSTree datastructure\n    // first we clean all the properties\n    Object.keys(node).forEach((key) => {\n      delete node[key];\n    });\n    // we now add the properties that are required by the DSTree datastructure\n    const overloadedNode = node as unknown as OverloadedItem<T>;\n    const childrenKey = getChildrenKey(originalNodeData);\n    overloadedNode.id = getUniqueId(originalNodeData);\n    overloadedNode.subitems = originalNodeData[childrenKey] as OverloadedItem<T>[];\n    delete originalNodeData[childrenKey];\n    overloadedNode.originalNodeData = originalNodeData;\n  };\n  // we now walk the pseudoRoot object, mutating it in the process\n  // @ts-expect-error this is an extremely opinionated algorithm that was built as a one-off, we are not spending time to make it typesafe\n  walkTreeish<OverloadedItem<T>>({ callback, node: pseudoRoot, opts: { getChildren: overloadedGetChildren } });\n\n  // we know that pseudoRoot is an item after we have walked and mutated it, so we can safely cast it\n  // @ts-expect-error this is an extremely opinionated algorithm that was built as a one-off, we are not spending time to make it typesafe\n  return new DSTree<OverloadedItem<T>>(pseudoRoot, { getUniqueId: overloadedGetUniqueId });\n};\n"],
-  "mappings": "AAAA,YAAY,WAAW;ACCvB,SAAS,cAAc;AAMvB,MAAM,eAAe,MACnB,uCAAuC,QAAQ,SAAS,CAAC,MAAM;AAC7D,QAAM,IAAI,KAAK,OAAO,IAAI,MAAM;AAEhC,QAAM,IAAI,MAAM,MAAM,IAAI,IAAI,KAAO;AACrC,SAAO,EAAE,SAAS,EAAE;AACtB,CAAC;AAUH,MAAM,cAAc,CAAmB;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AACF,MAMY;AACV,WAAS,IAAI;AACb,QAAM,WAAW,MAAM,YAAY,IAAI;AACvC,MAAI,MAAM,QAAQ,QAAQ,KAAK,SAAS,SAAS,GAAG;AAClD,aAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG;AAC3C,kBAAe,EAAE,UAAU,MAAM,SAAS,CAAC,GAAG,KAAK,CAAC;AAAA,IACtD;AAAA,EACF;AACF;AAYO,MAAM,2BAA2B,CAA4B,SAMnC;AAE/B,QAAM,SAAS,gCAAgC,aAAa,CAAC;AAC7D,QAAM,EAAE,MAAM,QAAQ,IAAI;AAC1B,QAAM,EAAE,aAAa,eAAe,IAAI;AAOxC,QAAM,aAAgC;AAAA,IACpC,IAAI;AAAA,IACJ,UAAU,gBAAgB,OAAO;AAAA,IACjC,kBAAkB,CAAC;AAAA,EACrB;AAIA,QAAM,wBAAwB,CAAC,SAA4B,KAAK;AAChE,QAAM,wBAAwB,CAAC,SAA4B,KAAK;AAYhE,QAAM,WAAW,CAAC,SAA4B;AAE5C,QAAI,KAAK,OAAO,OAAQ;AAExB,UAAM,mBAAmB,gBAAgB,IAAI;AAG7C,WAAO,KAAK,IAAI,EAAE,QAAQ,CAAC,QAAQ;AACjC,aAAO,KAAK,GAAG;AAAA,IACjB,CAAC;AAED,UAAM,iBAAiB;AACvB,UAAM,cAAc,eAAe,gBAAgB;AACnD,mBAAe,KAAK,YAAY,gBAAgB;AAChD,mBAAe,WAAW,iBAAiB,WAAW;AACtD,WAAO,iBAAiB,WAAW;AACnC,mBAAe,mBAAmB;AAAA,EACpC;AAGA,cAA+B,EAAE,UAAU,MAAM,YAAY,MAAM,EAAE,aAAa,sBAAsB,EAAE,CAAC;AAI3G,SAAO,IAAI,OAA0B,YAAY,EAAE,aAAa,sBAAsB,CAAC;AACzF;",
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable max-statements */\nimport { DSTree } from '../../DSTree.js';\nimport type { OverloadedItem } from '../../types.js';\n\n// we don't really need a 100% sure unique id, since we prepend a string that is most likely unique already\n//  we just need to reduce the risk of collisions\n//  we avoid depending on a library for this:\nconst unsecureUuid = () =>\n  'xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n    const r = Math.random() * 16 || 0;\n    // eslint-disable-next-line no-bitwise\n    const v = c === 'x' ? r : r & 0x3 || 0x8;\n    return v.toString(16);\n  });\n\n/*\n * @param {Object} args\n * @param {Function} args.callback - a function that will be called for each node in the treeish data-structure\n * @param {Object} args.node - the node that is being currently visited\n * @param {Object} args.opts - an object that holds the opinions of the caller on how to walk the treeish data-structure\n * @param {Function} args.opts.getChildren - a function that given a node returns an array of children\n * @returns {void}\n */\nconst walkTreeish = <T extends object>({\n  callback,\n  node,\n  opts,\n}: {\n  callback: (node: T) => void;\n  node: T;\n  opts?: {\n    getChildren: (node: T) => T[];\n  };\n}): void => {\n  callback(node);\n  const children = opts?.getChildren(node);\n  if (Array.isArray(children) && children.length > 0) {\n    for (let i = 0; i < children.length; i += 1) {\n      walkTreeish<T>({ callback, node: children[i], opts });\n    }\n  }\n};\n\n/*\n * a function that given a treeish array and some options returns a DSTree datastructure that compltely preserves the treeish array\n *  but still allows to use the full power of the DSTree datastructure\n * NOTE: This create a deep clone of the treeish array, so it's not suitable for large trees and will not preserve any reference to the original treeish array\n * @param {Array} treeish - an array of items that rapresents a tree, this will be used to create a DSTree datastructure\n * @param {Object} opts - an object that governs how the treeish array will be converted to a DSTree datastructure\n * @param {Function} opts.getChildrenKey - a function that given a node returns the key used to access the node children\n * @param {Function} opts.getUniqueId - a function that given a node returns a unique string used to identify the node\n * @returns {DSTree} - a DSTree datastructure\n */\nexport const fromTreeishArrayToDSTree = <T extends object = object>(args: {\n  treeish: T[];\n  opts: {\n    getChildrenKey: (node: T) => keyof T;\n    getUniqueId: (item: T) => string;\n  };\n}): DSTree<OverloadedItem<T>> => {\n  // we use crypto to generate a unique id for the root, this is important for reduce the risk of collisions with any user provided id\n  const rootId = `_autogenerated-ds-pseudoRoot-${unsecureUuid()}`;\n  const { opts, treeish } = args;\n  const { getUniqueId, getChildrenKey } = opts;\n\n  // a DSTree compatible datastructure has the following characteristics:\n  //  - it has a \"subitems\" property that contains an array of children\n  //  - it has a property that holds a unique string used to identify the node (accessed via the getUniqueId function)\n  //  - it is in an object format\n  const pseudoRoot: OverloadedItem<T> = {\n    id: rootId,\n    subitems: structuredClone(treeish) as unknown as OverloadedItem<T>[],\n    originalNodeData: {} as T,\n  };\n  // we now create an over-charged getChildren function\n  //  this is because we mutate the object every step during the walk\n  //  this function is going to receive the OverloadedItem<T> each step\n  const overloadedGetChildren = (node: OverloadedItem<T>) => node.subitems;\n  const overloadedGetUniqueId = (node: OverloadedItem<T>) => node.id;\n  // we now create a \"callback\" function that will be used when walking the pseudoRoot object.\n  //  this callback will mutate the pseudoRoot object, making sure that after the mutation it will be compatible with the DSTree datastructure\n  //  we can't really make an assumption that the subitems key isn't somehow already part of the data from the user,\n  //     so to avoid any collision we will create an extra-level of nesting, in this layer only 3 properties will be allowed:\n  //    - id: a unique string used to identify the node, this is already a requirement from the treeish datastructure provided by the user\n  //    - subitems: an array of children\n  //    - original: the original data provided by the user\n  //        we remove the original tree rapresentation from the node, we only want one source of truth for the tree\n  //        if we don't remove this, when operating the DSTree we would have to somehow also propagate the changes to the original tree\n  //          the way this is intended to be used is instead to convert back and forth between the DSTree and the treeish array\n  //          the conversion will restore the treeish structure with the updated tree after operating on the DSTree\n  const callback = (node: OverloadedItem<T>) => {\n    // we skip the root node\n    if (node.id === rootId) return;\n    // we safe-keep the original data provided by the user\n    const originalNodeData = structuredClone(node) as unknown as T;\n    // we now mutate the node, making it compatible with the DSTree datastructure\n    // first we clean all the properties\n    Object.keys(node).forEach((key) => {\n      delete node[key];\n    });\n    // we now add the properties that are required by the DSTree datastructure\n    const overloadedNode = node as unknown as OverloadedItem<T>;\n    const childrenKey = getChildrenKey(originalNodeData);\n    overloadedNode.id = getUniqueId(originalNodeData);\n    overloadedNode.subitems = originalNodeData[childrenKey] as OverloadedItem<T>[];\n    delete originalNodeData[childrenKey];\n    overloadedNode.originalNodeData = originalNodeData;\n  };\n  // we now walk the pseudoRoot object, mutating it in the process\n  // @ts-expect-error this is an extremely opinionated algorithm that was built as a one-off, we are not spending time to make it typesafe\n  walkTreeish<OverloadedItem<T>>({ callback, node: pseudoRoot, opts: { getChildren: overloadedGetChildren } });\n\n  // we know that pseudoRoot is an item after we have walked and mutated it, so we can safely cast it\n  return new DSTree<OverloadedItem<T>>(pseudoRoot, { getUniqueId: overloadedGetUniqueId });\n};\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACCvB,SAAS,cAAc;AAMvB,MAAM,eAAe,MACnB,uCAAuC,QAAQ,SAAS,CAAC,MAAM;AAC7D,QAAM,IAAI,KAAK,OAAO,IAAI,MAAM;AAEhC,QAAM,IAAI,MAAM,MAAM,IAAI,IAAI,KAAO;AACrC,SAAO,EAAE,SAAS,EAAE;AACtB,CAAC;AAUH,MAAM,cAAc,CAAmB;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AACF,MAMY;AACV,WAAS,IAAI;AACb,QAAM,WAAW,MAAM,YAAY,IAAI;AACvC,MAAI,MAAM,QAAQ,QAAQ,KAAK,SAAS,SAAS,GAAG;AAClD,aAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG;AAC3C,kBAAe,EAAE,UAAU,MAAM,SAAS,CAAC,GAAG,KAAK,CAAC;AAAA,IACtD;AAAA,EACF;AACF;AAYO,MAAM,2BAA2B,CAA4B,SAMnC;AAE/B,QAAM,SAAS,gCAAgC,aAAa,CAAC;AAC7D,QAAM,EAAE,MAAM,QAAQ,IAAI;AAC1B,QAAM,EAAE,aAAa,eAAe,IAAI;AAMxC,QAAM,aAAgC;AAAA,IACpC,IAAI;AAAA,IACJ,UAAU,gBAAgB,OAAO;AAAA,IACjC,kBAAkB,CAAC;AAAA,EACrB;AAIA,QAAM,wBAAwB,CAAC,SAA4B,KAAK;AAChE,QAAM,wBAAwB,CAAC,SAA4B,KAAK;AAYhE,QAAM,WAAW,CAAC,SAA4B;AAE5C,QAAI,KAAK,OAAO,OAAQ;AAExB,UAAM,mBAAmB,gBAAgB,IAAI;AAG7C,WAAO,KAAK,IAAI,EAAE,QAAQ,CAAC,QAAQ;AACjC,aAAO,KAAK,GAAG;AAAA,IACjB,CAAC;AAED,UAAM,iBAAiB;AACvB,UAAM,cAAc,eAAe,gBAAgB;AACnD,mBAAe,KAAK,YAAY,gBAAgB;AAChD,mBAAe,WAAW,iBAAiB,WAAW;AACtD,WAAO,iBAAiB,WAAW;AACnC,mBAAe,mBAAmB;AAAA,EACpC;AAGA,cAA+B,EAAE,UAAU,MAAM,YAAY,MAAM,EAAE,aAAa,sBAAsB,EAAE,CAAC;AAG3G,SAAO,IAAI,OAA0B,YAAY,EAAE,aAAa,sBAAsB,CAAC;AACzF;",
   "names": []
 }

package/dist/esm/react-desc-prop-types.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/react-desc-prop-types.ts"],
-  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import { PropTypes, type ValidationMap } from '@elliemae/ds-props-helpers';\nimport type { Node } from './Node.js';\nimport type {\n  AddOptions,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions,\n  Item,\n  AnyObjectWithoutReservedKeys,\n  JSONThatCanContrusctATree,\n} from './types.js';\n\nexport declare namespace UseDSTreeT {\n  export type TreeNode<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> =\n    Node<AppInterface>;\n  export type TreeItem<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> =\n    Item<AppInterface>;\n  export type FirstParameter<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> =\n    TreeItem<AppInterface>;\n\n  export type SecondParameter<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = {\n    getUniqueId: (item: TreeItem<AppInterface>) => string | number;\n  };\n\n  export interface OutputT<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {\n    hash: number;\n    getRoot: () => Node<AppInterface>;\n    getNode: (id: string | number) => Node<AppInterface>;\n    walk: (callback: (node: Node<AppInterface>) => boolean) => void;\n    walkParents: (callback: (node: Node<AppInterface>) => boolean) => void;\n    findNode: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface> | null;\n    findAllNodes: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface>[];\n    flatten: () => Node<AppInterface>[];\n    addNode: (item: JSONThatCanContrusctATree<AppInterface>, options?: AddOptions<AppInterface>) => Node<AppInterface>;\n    removeNode: (id: string | number, options?: RemoveOptions<AppInterface>) => Node<AppInterface>;\n    moveNode: (id: string | number, options?: MoveOptions<AppInterface>) => Node<AppInterface>;\n    replaceNode: (\n      id: string | number,\n      item: JSONThatCanContrusctATree<AppInterface>,\n      options?: MutateOptions<AppInterface>,\n    ) => Node<AppInterface>;\n    getPath: (id: string | number) => Node<AppInterface>[];\n    getPathIds: (id: string | number) => (string | number)[];\n  }\n}\n\nconst itemShape = {\n  dsId: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).description('Id of the root item.'),\n  label: PropTypes.string.description('Item label.'),\n  '[key]': PropTypes.string.description('Any custom key you want to add to the item.'),\n};\n\nexport const UseDSTreePropTypes = {\n  rootItem: PropTypes.shape({\n    ...itemShape,\n    subitems: PropTypes.arrayOf(PropTypes.shape(itemShape)).description(\n      'Array of subitems. Each subitem can also have subitems.',\n    ),\n  }).description('First parameter.').isRequired,\n  opts: PropTypes.shape({\n    getUniqueId: PropTypes.func\n      .signature('(item) => string | number')\n      .description('Callback to get the id of each item.').isRequired,\n  }).description('Second parameter.').isRequired,\n} as ValidationMap<unknown>;\n\nexport const UseDSTreeReturnType = {\n  hash: PropTypes.number.description('Tree hash value.'),\n  getRoot: PropTypes.func.signature('() => rootItem').description('Callback to get the root item.'),\n  getNode: PropTypes.func.signature('(id: string | number) => item').description('Callback to get an item by id.'),\n  walk: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => void')\n    .description('Callback applied to each item to determine whether to continue walking or not.'),\n  walkParents: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => void')\n    .description(\"Callback applied to each item to determine whether to continue walking the item's parents or not.\"),\n  findNode: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => FirstParameter | null')\n    .description('Callback to find an item that matches the condition.'),\n  findAllNodes: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => FirstParameter[]')\n    .description('Callback to find all the items that matches the condition.'),\n  flatten: PropTypes.func.signature('() => item[]').description('Returns an array of hte tree items.'),\n  addNode: PropTypes.func\n    .signature('(item: FirstParameter, options?: AddOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Adds an item to the tree.'),\n  removeNode: PropTypes.func\n    .signature('(id: string, options?: RemoveOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Removes an item from the tree.'),\n  moveNode: PropTypes.func\n    .signature('(id: string, options?: MoveOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Move an item within the tree.'),\n  replaceNode: PropTypes.func\n    .signature(\n      'id: string, item: FirstParameter, options?: MutateOptions<FirstParameter> | undefined) => FirstParameter',\n    )\n    .description('Replace a noe within the tree.'),\n  getPath: PropTypes.func\n    .signature('(id: string | number) => FirstParameter[]')\n    .description(\"Get the path to an item given the item's id.\"),\n  getPathIds: PropTypes.func\n    .signature('(id: string | number) => (string | number)[]')\n    .description(\"Get the path ids to an item given the item's id.\"),\n} as ValidationMap<unknown>;\n"],
-  "mappings": "AAAA,YAAY,WAAW;ACAvB,SAAS,iBAAqC;AA8C9C,MAAM,YAAY;AAAA,EAChB,MAAM,UAAU,UAAU,CAAC,UAAU,QAAQ,UAAU,MAAM,CAAC,EAAE,YAAY,sBAAsB;AAAA,EAClG,OAAO,UAAU,OAAO,YAAY,aAAa;AAAA,EACjD,SAAS,UAAU,OAAO,YAAY,6CAA6C;AACrF;AAEO,MAAM,qBAAqB;AAAA,EAChC,UAAU,UAAU,MAAM;AAAA,IACxB,GAAG;AAAA,IACH,UAAU,UAAU,QAAQ,UAAU,MAAM,SAAS,CAAC,EAAE;AAAA,MACtD;AAAA,IACF;AAAA,EACF,CAAC,EAAE,YAAY,kBAAkB,EAAE;AAAA,EACnC,MAAM,UAAU,MAAM;AAAA,IACpB,aAAa,UAAU,KACpB,UAAU,2BAA2B,EACrC,YAAY,sCAAsC,EAAE;AAAA,EACzD,CAAC,EAAE,YAAY,mBAAmB,EAAE;AACtC;AAEO,MAAM,sBAAsB;AAAA,EACjC,MAAM,UAAU,OAAO,YAAY,kBAAkB;AAAA,EACrD,SAAS,UAAU,KAAK,UAAU,gBAAgB,EAAE,YAAY,gCAAgC;AAAA,EAChG,SAAS,UAAU,KAAK,UAAU,+BAA+B,EAAE,YAAY,gCAAgC;AAAA,EAC/G,MAAM,UAAU,KACb,UAAU,uDAAuD,EACjE,YAAY,gFAAgF;AAAA,EAC/F,aAAa,UAAU,KACpB,UAAU,uDAAuD,EACjE,YAAY,mGAAmG;AAAA,EAClH,UAAU,UAAU,KACjB,UAAU,wEAAwE,EAClF,YAAY,sDAAsD;AAAA,EACrE,cAAc,UAAU,KACrB,UAAU,mEAAmE,EAC7E,YAAY,4DAA4D;AAAA,EAC3E,SAAS,UAAU,KAAK,UAAU,cAAc,EAAE,YAAY,qCAAqC;AAAA,EACnG,SAAS,UAAU,KAChB,UAAU,4FAA4F,EACtG,YAAY,2BAA2B;AAAA,EAC1C,YAAY,UAAU,KACnB,UAAU,qFAAqF,EAC/F,YAAY,gCAAgC;AAAA,EAC/C,UAAU,UAAU,KACjB,UAAU,mFAAmF,EAC7F,YAAY,+BAA+B;AAAA,EAC9C,aAAa,UAAU,KACpB;AAAA,IACC;AAAA,EACF,EACC,YAAY,gCAAgC;AAAA,EAC/C,SAAS,UAAU,KAChB,UAAU,2CAA2C,EACrD,YAAY,8CAA8C;AAAA,EAC7D,YAAY,UAAU,KACnB,UAAU,8CAA8C,EACxD,YAAY,kDAAkD;AACnE;",
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import { PropTypes, type ValidationMap } from '@elliemae/ds-props-helpers';\nimport type { Node } from './Node.js';\nimport type {\n  AddOptions,\n  AnyObjectWithoutReservedKeys as AnyObjectWithoutReservedKeysToRexport,\n  Item as ItemToRexport,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions\n} from './types.js';\n\nexport declare namespace UseDSTreeT {\n  export type AnyObjectWithoutReservedKeys = AnyObjectWithoutReservedKeysToRexport;\n  export type Item<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> =\n    ItemToRexport<AppInterface>;\n\n  export type TreeNode<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> =\n    Node<AppInterface>;\n  export type TreeItem<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> =\n    Item<AppInterface>;\n  export type FirstParameter<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> =\n    TreeItem<AppInterface>;\n\n  export type SecondParameter<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> = {\n    getUniqueId: (item: TreeItem<AppInterface>) => string | number;\n  };\n\n  export interface OutputT<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> {\n    hash: number;\n    getRoot: () => Node<AppInterface>;\n    getNode: (id: string | number) => Node<AppInterface>;\n    walk: (callback: (node: Node<AppInterface>) => boolean) => void;\n    walkParents: (callback: (node: Node<AppInterface>) => boolean) => void;\n    findNode: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface> | null;\n    findAllNodes: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface>[];\n    flatten: () => Node<AppInterface>[];\n    addNode: (item: ItemToRexport<AppInterface>, options?: AddOptions<AppInterface>) => Node<AppInterface>;\n    removeNode: (id: string | number, options?: RemoveOptions<AppInterface>) => Node<AppInterface>;\n    moveNode: (id: string | number, options?: MoveOptions<AppInterface>) => Node<AppInterface>;\n    replaceNode: (\n      id: string | number,\n      item: ItemToRexport<AppInterface>,\n      options?: MutateOptions<AppInterface>,\n    ) => Node<AppInterface>;\n    getPath: (id: string | number) => Node<AppInterface>[];\n    getPathIds: (id: string | number) => (string | number)[];\n  }\n}\n\nconst itemShape = {\n  dsId: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).description('Id of the root item.'),\n  label: PropTypes.string.description('Item label.'),\n  '[key]': PropTypes.string.description('Any custom key you want to add to the item.'),\n};\n\nexport const UseDSTreePropTypes = {\n  rootItem: PropTypes.shape({\n    ...itemShape,\n    subitems: PropTypes.arrayOf(PropTypes.shape(itemShape)).description(\n      'Array of subitems. Each subitem can also have subitems.',\n    ),\n  }).description('First parameter.').isRequired,\n  opts: PropTypes.shape({\n    getUniqueId: PropTypes.func\n      .signature('(item) => string | number')\n      .description('Callback to get the id of each item.').isRequired,\n  }).description('Second parameter.').isRequired,\n} as ValidationMap<unknown>;\n\nexport const UseDSTreeReturnType = {\n  hash: PropTypes.number.description('Tree hash value.'),\n  getRoot: PropTypes.func.signature('() => rootItem').description('Callback to get the root item.'),\n  getNode: PropTypes.func.signature('(id: string | number) => item').description('Callback to get an item by id.'),\n  walk: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => void')\n    .description('Callback applied to each item to determine whether to continue walking or not.'),\n  walkParents: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => void')\n    .description(\"Callback applied to each item to determine whether to continue walking the item's parents or not.\"),\n  findNode: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => FirstParameter | null')\n    .description('Callback to find an item that matches the condition.'),\n  findAllNodes: PropTypes.func\n    .signature('(callback: (item: FirstParameter) => boolean) => FirstParameter[]')\n    .description('Callback to find all the items that matches the condition.'),\n  flatten: PropTypes.func.signature('() => item[]').description('Returns an array of hte tree items.'),\n  addNode: PropTypes.func\n    .signature('(item: FirstParameter, options?: AddOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Adds an item to the tree.'),\n  removeNode: PropTypes.func\n    .signature('(id: string, options?: RemoveOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Removes an item from the tree.'),\n  moveNode: PropTypes.func\n    .signature('(id: string, options?: MoveOptions<FirstParameter> | undefined) => FirstParameter')\n    .description('Move an item within the tree.'),\n  replaceNode: PropTypes.func\n    .signature(\n      'id: string, item: FirstParameter, options?: MutateOptions<FirstParameter> | undefined) => FirstParameter',\n    )\n    .description('Replace a noe within the tree.'),\n  getPath: PropTypes.func\n    .signature('(id: string | number) => FirstParameter[]')\n    .description(\"Get the path to an item given the item's id.\"),\n  getPathIds: PropTypes.func\n    .signature('(id: string | number) => (string | number)[]')\n    .description(\"Get the path ids to an item given the item's id.\"),\n} as ValidationMap<unknown>;\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACAvB,SAAS,iBAAqC;AAiD9C,MAAM,YAAY;AAAA,EAChB,MAAM,UAAU,UAAU,CAAC,UAAU,QAAQ,UAAU,MAAM,CAAC,EAAE,YAAY,sBAAsB;AAAA,EAClG,OAAO,UAAU,OAAO,YAAY,aAAa;AAAA,EACjD,SAAS,UAAU,OAAO,YAAY,6CAA6C;AACrF;AAEO,MAAM,qBAAqB;AAAA,EAChC,UAAU,UAAU,MAAM;AAAA,IACxB,GAAG;AAAA,IACH,UAAU,UAAU,QAAQ,UAAU,MAAM,SAAS,CAAC,EAAE;AAAA,MACtD;AAAA,IACF;AAAA,EACF,CAAC,EAAE,YAAY,kBAAkB,EAAE;AAAA,EACnC,MAAM,UAAU,MAAM;AAAA,IACpB,aAAa,UAAU,KACpB,UAAU,2BAA2B,EACrC,YAAY,sCAAsC,EAAE;AAAA,EACzD,CAAC,EAAE,YAAY,mBAAmB,EAAE;AACtC;AAEO,MAAM,sBAAsB;AAAA,EACjC,MAAM,UAAU,OAAO,YAAY,kBAAkB;AAAA,EACrD,SAAS,UAAU,KAAK,UAAU,gBAAgB,EAAE,YAAY,gCAAgC;AAAA,EAChG,SAAS,UAAU,KAAK,UAAU,+BAA+B,EAAE,YAAY,gCAAgC;AAAA,EAC/G,MAAM,UAAU,KACb,UAAU,uDAAuD,EACjE,YAAY,gFAAgF;AAAA,EAC/F,aAAa,UAAU,KACpB,UAAU,uDAAuD,EACjE,YAAY,mGAAmG;AAAA,EAClH,UAAU,UAAU,KACjB,UAAU,wEAAwE,EAClF,YAAY,sDAAsD;AAAA,EACrE,cAAc,UAAU,KACrB,UAAU,mEAAmE,EAC7E,YAAY,4DAA4D;AAAA,EAC3E,SAAS,UAAU,KAAK,UAAU,cAAc,EAAE,YAAY,qCAAqC;AAAA,EACnG,SAAS,UAAU,KAChB,UAAU,4FAA4F,EACtG,YAAY,2BAA2B;AAAA,EAC1C,YAAY,UAAU,KACnB,UAAU,qFAAqF,EAC/F,YAAY,gCAAgC;AAAA,EAC/C,UAAU,UAAU,KACjB,UAAU,mFAAmF,EAC7F,YAAY,+BAA+B;AAAA,EAC9C,aAAa,UAAU,KACpB;AAAA,IACC;AAAA,EACF,EACC,YAAY,gCAAgC;AAAA,EAC/C,SAAS,UAAU,KAChB,UAAU,2CAA2C,EACrD,YAAY,8CAA8C;AAAA,EAC7D,YAAY,UAAU,KACnB,UAAU,8CAA8C,EACxD,YAAY,kDAAkD;AACnE;",
   "names": []
 }

package/dist/esm/typescript-testing/typescript-use-ds-tree-valid.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../scripts/build/transpile/react-shim.js", "../../../src/typescript-testing/typescript-use-ds-tree-valid.tsx"],
-  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */\nimport { useDSTree } from '../index.js';\nimport type { UseDSTreeT } from '../index.js';\n\n// for the sake of this API, it's important that the app devs can pass their own interface for the item\ntype AppItemT = {\n  zipcode: number;\n  createdAt?: string;\n  likesIceCream?: boolean;\n};\n\n// test we expose the namespace and the namespace follows our deliverable conventions\ntype AppTypedItem = UseDSTreeT.TreeItem<AppItemT>;\n\nconst testPropsInferedFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n};\n\nconst testExplicitDefinitionFirstParameter: AppTypedItem = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n};\n\nconst testExplicitAsDefinitionFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444, createdAt: '2021-01-01', likesIceCream: true }],\n} as AppTypedItem;\n\nconst testDefinitionAsConstFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n} as const;\n\nconst testPropsInferedSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n};\nconst testPropsExplicitSecondParameter: UseDSTreeT.SecondParameter<AppTypedItem> = {\n  getUniqueId: (item) => item.dsId,\n};\n\nconst testPropsExplicitAsSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n} as UseDSTreeT.SecondParameter<AppTypedItem>;\n\nconst testDefinitionAsConstSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n} as const;\n\n// this is an helper to be able to check the type of the output of getPathIds\ntype IdsArrayTypeChecker = (string | number)[];\nconst ExampleUsageComponent = () => {\n  const {\n    addNode,\n    findAllNodes,\n    findNode,\n    flatten,\n    getNode,\n    getPath,\n    getPathIds,\n    getRoot,\n    hash,\n    moveNode,\n    removeNode,\n    replaceNode,\n    walk,\n    walkParents,\n  } = useDSTree<AppItemT>(testExplicitDefinitionFirstParameter, testPropsExplicitSecondParameter);\n  addNode({ dsId: 'sub_item_id2', zipcode: 4444 });\n  findAllNodes((node) => node.plainItem.zipcode === 4444);\n  findNode((node) => node.plainItem.zipcode === 4444);\n  const nodes = flatten() as UseDSTreeT.TreeNode<AppItemT>[];\n\n  const newlyAddedNode = getNode('sub_item_id2') as UseDSTreeT.TreeNode<AppItemT>;\n  const path = getPath('sub_item_id2') as UseDSTreeT.TreeNode<AppItemT>[];\n  const pathIds = getPathIds('sub_item_id2') as IdsArrayTypeChecker;\n  const root = getRoot() as UseDSTreeT.TreeNode<AppItemT>;\n  moveNode('sub_item_id1', { position: 0, parent: newlyAddedNode });\n  removeNode('sub_item_id1');\n  replaceNode('sub_item_id2', { dsId: 'sub_item_id2', zipcode: 4433 });\n  walk((node) => node.plainItem.zipcode === 4433);\n  walkParents((node) => node.plainItem.zipcode === 4433);\n\n  const outputExplicitAs = useDSTree<AppItemT>(\n    testExplicitAsDefinitionFirstParameter,\n    testPropsExplicitAsSecondParameter,\n  );\n  const outputConst = useDSTree<AppItemT>(testDefinitionAsConstFirstParameter, testDefinitionAsConstSecondParameter);\n\n  const outputInfered = useDSTree<AppItemT>(testPropsInferedFirstParameter, testPropsInferedSecondParameter);\n\n  return null;\n};\n"],
-  "mappings": "AAAA,YAAY,WAAW;ACCvB,SAAS,iBAAiB;AAa1B,MAAM,iCAAiC;AAAA,EACrC,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,uCAAqD;AAAA,EACzD,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,yCAAyC;AAAA,EAC7C,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,MAAM,WAAW,cAAc,eAAe,KAAK,CAAC;AAClG;AAEA,MAAM,sCAAsC;AAAA,EAC1C,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,kCAAkC;AAAA,EACtC,aAAa,CAAC,SAAuB,KAAK;AAC5C;AACA,MAAM,mCAA6E;AAAA,EACjF,aAAa,CAAC,SAAS,KAAK;AAC9B;AAEA,MAAM,qCAAqC;AAAA,EACzC,aAAa,CAAC,SAAuB,KAAK;AAC5C;AAEA,MAAM,uCAAuC;AAAA,EAC3C,aAAa,CAAC,SAAuB,KAAK;AAC5C;AAIA,MAAM,wBAAwB,MAAM;AAClC,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI,UAAoB,sCAAsC,gCAAgC;AAC9F,UAAQ,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AAC/C,eAAa,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AACtD,WAAS,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAClD,QAAM,QAAQ,QAAQ;AAEtB,QAAM,iBAAiB,QAAQ,cAAc;AAC7C,QAAM,OAAO,QAAQ,cAAc;AACnC,QAAM,UAAU,WAAW,cAAc;AACzC,QAAM,OAAO,QAAQ;AACrB,WAAS,gBAAgB,EAAE,UAAU,GAAG,QAAQ,eAAe,CAAC;AAChE,aAAW,cAAc;AACzB,cAAY,gBAAgB,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACnE,OAAK,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAC9C,cAAY,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAErD,QAAM,mBAAmB;AAAA,IACvB;AAAA,IACA;AAAA,EACF;AACA,QAAM,cAAc,UAAoB,qCAAqC,oCAAoC;AAEjH,QAAM,gBAAgB,UAAoB,gCAAgC,+BAA+B;AAEzG,SAAO;AACT;",
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */\nimport { useDSTree } from '../index.js';\nimport type { UseDSTreeT } from '../index.js';\n\n// for the sake of this API, it's important that the app devs can pass their own interface for the item\ntype AppItemT = {\n  dsId: string;\n  zipcode: number;\n  createdAt?: string;\n  likesIceCream?: boolean;\n};\n\n// test we expose the namespace and the namespace follows our deliverable conventions\ntype AppTypedItem = UseDSTreeT.TreeItem<AppItemT>;\n\nconst testPropsInferedFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n};\n\nconst testExplicitDefinitionFirstParameter: AppTypedItem = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n};\n\nconst testExplicitAsDefinitionFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444, createdAt: '2021-01-01', likesIceCream: true }],\n} as AppTypedItem;\n\nconst testDefinitionAsConstFirstParameter = {\n  dsId: '_root',\n  zipcode: 4444,\n  subitems: [{ dsId: 'sub_item_id1', zipcode: 4444 }],\n} as const;\n\nconst testPropsInferedSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n};\nconst testPropsExplicitSecondParameter: UseDSTreeT.SecondParameter<AppTypedItem> = {\n  getUniqueId: (item) => item.dsId,\n};\n\nconst testPropsExplicitAsSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n} as UseDSTreeT.SecondParameter<AppTypedItem>;\n\nconst testDefinitionAsConstSecondParameter = {\n  getUniqueId: (item: AppTypedItem) => item.dsId,\n} as const;\n\n// this is an helper to be able to check the type of the output of getPathIds\ntype IdsArrayTypeChecker = (string | number)[];\nconst ExampleUsageComponent = () => {\n  const {\n    addNode,\n    findAllNodes,\n    findNode,\n    flatten,\n    getNode,\n    getPath,\n    getPathIds,\n    getRoot,\n    hash,\n    moveNode,\n    removeNode,\n    replaceNode,\n    walk,\n    walkParents,\n  } = useDSTree<AppItemT>(testExplicitDefinitionFirstParameter, testPropsExplicitSecondParameter);\n  addNode({ dsId: 'sub_item_id2', zipcode: 4444 });\n  findAllNodes((node) => node.plainItem.zipcode === 4444);\n  findNode((node) => node.plainItem.zipcode === 4444);\n  const nodes = flatten() as UseDSTreeT.TreeNode<AppItemT>[];\n\n  const newlyAddedNode = getNode('sub_item_id2') as UseDSTreeT.TreeNode<AppItemT>;\n  const path = getPath('sub_item_id2') as UseDSTreeT.TreeNode<AppItemT>[];\n  const pathIds = getPathIds('sub_item_id2') as IdsArrayTypeChecker;\n  const root = getRoot() as UseDSTreeT.TreeNode<AppItemT>;\n  moveNode('sub_item_id1', { position: 0, parent: newlyAddedNode });\n  removeNode('sub_item_id1');\n  replaceNode('sub_item_id2', { dsId: 'sub_item_id2', zipcode: 4433 });\n  walk((node) => node.plainItem.zipcode === 4433);\n  walkParents((node) => node.plainItem.zipcode === 4433);\n\n  const outputExplicitAs = useDSTree<AppItemT>(\n    testExplicitAsDefinitionFirstParameter,\n    testPropsExplicitAsSecondParameter,\n  );\n  const outputConst = useDSTree<AppItemT>(testDefinitionAsConstFirstParameter, testDefinitionAsConstSecondParameter);\n\n  const outputInfered = useDSTree<AppItemT>(testPropsInferedFirstParameter, testPropsInferedSecondParameter);\n\n  return null;\n};\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACCvB,SAAS,iBAAiB;AAc1B,MAAM,iCAAiC;AAAA,EACrC,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,uCAAqD;AAAA,EACzD,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,yCAAyC;AAAA,EAC7C,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,MAAM,WAAW,cAAc,eAAe,KAAK,CAAC;AAClG;AAEA,MAAM,sCAAsC;AAAA,EAC1C,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU,CAAC,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACpD;AAEA,MAAM,kCAAkC;AAAA,EACtC,aAAa,CAAC,SAAuB,KAAK;AAC5C;AACA,MAAM,mCAA6E;AAAA,EACjF,aAAa,CAAC,SAAS,KAAK;AAC9B;AAEA,MAAM,qCAAqC;AAAA,EACzC,aAAa,CAAC,SAAuB,KAAK;AAC5C;AAEA,MAAM,uCAAuC;AAAA,EAC3C,aAAa,CAAC,SAAuB,KAAK;AAC5C;AAIA,MAAM,wBAAwB,MAAM;AAClC,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI,UAAoB,sCAAsC,gCAAgC;AAC9F,UAAQ,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AAC/C,eAAa,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AACtD,WAAS,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAClD,QAAM,QAAQ,QAAQ;AAEtB,QAAM,iBAAiB,QAAQ,cAAc;AAC7C,QAAM,OAAO,QAAQ,cAAc;AACnC,QAAM,UAAU,WAAW,cAAc;AACzC,QAAM,OAAO,QAAQ;AACrB,WAAS,gBAAgB,EAAE,UAAU,GAAG,QAAQ,eAAe,CAAC;AAChE,aAAW,cAAc;AACzB,cAAY,gBAAgB,EAAE,MAAM,gBAAgB,SAAS,KAAK,CAAC;AACnE,OAAK,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAC9C,cAAY,CAAC,SAAS,KAAK,UAAU,YAAY,IAAI;AAErD,QAAM,mBAAmB;AAAA,IACvB;AAAA,IACA;AAAA,EACF;AACA,QAAM,cAAc,UAAoB,qCAAqC,oCAAoC;AAEjH,QAAM,gBAAgB,UAAoB,gCAAgC,+BAA+B;AAEzG,SAAO;AACT;",
   "names": []
 }

package/dist/esm/useDSTree.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/useDSTree.ts"],
-  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import { describe } from '@elliemae/ds-props-helpers';\nimport { useCallback, useMemo, useState } from 'react';\nimport { DSTree } from './DSTree.js';\nimport type {\n  AddOptions,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions,\n  AnyObjectWithoutReservedKeys,\n  JSONThatCanContrusctATree,\n} from './types.js';\nimport { UseDSTreePropTypes, UseDSTreeReturnType, type UseDSTreeT } from './react-desc-prop-types.js';\n\nexport const useDSTree = <AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>>(\n  rootItem: JSONThatCanContrusctATree<AppInterface>,\n  opts: UseDSTreeT.SecondParameter<AppInterface>,\n) => {\n  const tree = useMemo(() => new DSTree<AppInterface>(rootItem, opts), [opts, rootItem]);\n  const [hash, setHash] = useState(tree.hash);\n\n  const addNode = useCallback(\n    (item: JSONThatCanContrusctATree<AppInterface>, options?: AddOptions<AppInterface>) => {\n      const cb: AddOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.addNode(item, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const removeNode = useCallback(\n    (id: string, options?: RemoveOptions<AppInterface>) => {\n      const cb: RemoveOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.removeNode(id, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const moveNode = useCallback(\n    (id: string, options?: MoveOptions<AppInterface>) => {\n      const cb: MoveOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.moveNode(id, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const replaceNode = useCallback(\n    (id: string, item: JSONThatCanContrusctATree<AppInterface>, options?: MutateOptions<AppInterface>) => {\n      const cb: MutateOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.replaceNode(id, item, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  return {\n    hash,\n    getRoot: tree.getRoot,\n    getNode: tree.getNode,\n    walk: tree.walk,\n    walkParents: tree.walkParents,\n    findNode: tree.findNode,\n    findAllNodes: tree.findAllNodes,\n    flatten: tree.flatten,\n    addNode,\n    removeNode,\n    moveNode,\n    replaceNode,\n    getPath: tree.getPath,\n    getPathIds: tree.getPathIds,\n  } as UseDSTreeT.OutputT<AppInterface>;\n};\n\nuseDSTree.displayName = 'useDSTree';\nexport const UseDSTreeWithSchema = describe(useDSTree);\nUseDSTreeWithSchema.propTypes = UseDSTreePropTypes;\nUseDSTreeWithSchema.returnType = UseDSTreeReturnType;\n"],
-  "mappings": "AAAA,YAAY,WAAW;ACAvB,SAAS,gBAAgB;AACzB,SAAS,aAAa,SAAS,gBAAgB;AAC/C,SAAS,cAAc;AASvB,SAAS,oBAAoB,2BAA4C;AAElE,MAAM,YAAY,CACvB,UACA,SACG;AACH,QAAM,OAAO,QAAQ,MAAM,IAAI,OAAqB,UAAU,IAAI,GAAG,CAAC,MAAM,QAAQ,CAAC;AACrF,QAAM,CAAC,MAAM,OAAO,IAAI,SAAS,KAAK,IAAI;AAE1C,QAAM,UAAU;AAAA,IACd,CAAC,MAA+C,YAAuC;AACrF,YAAM,KAA2C,CAAC,MAAM,WAAW;AACjE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,QAAQ,MAAM,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACxD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,aAAa;AAAA,IACjB,CAAC,IAAY,YAA0C;AACrD,YAAM,KAA8C,CAAC,MAAM,WAAW;AACpE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,WAAW,IAAI,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACzD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,WAAW;AAAA,IACf,CAAC,IAAY,YAAwC;AACnD,YAAM,KAA4C,CAAC,MAAM,WAAW;AAClE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,SAAS,IAAI,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACvD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,cAAc;AAAA,IAClB,CAAC,IAAY,MAA+C,YAA0C;AACpG,YAAM,KAA8C,CAAC,MAAM,WAAW;AACpE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,YAAY,IAAI,MAAM,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IAChE;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,SAAO;AAAA,IACL;AAAA,IACA,SAAS,KAAK;AAAA,IACd,SAAS,KAAK;AAAA,IACd,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,UAAU,KAAK;AAAA,IACf,cAAc,KAAK;AAAA,IACnB,SAAS,KAAK;AAAA,IACd;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS,KAAK;AAAA,IACd,YAAY,KAAK;AAAA,EACnB;AACF;AAEA,UAAU,cAAc;AACjB,MAAM,sBAAsB,SAAS,SAAS;AACrD,oBAAoB,YAAY;AAChC,oBAAoB,aAAa;",
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import { describe } from '@elliemae/ds-props-helpers';\nimport { useCallback, useMemo, useState } from 'react';\nimport { DSTree } from './DSTree.js';\nimport type {\n  AddOptions,\n  MoveOptions,\n  MutateOptions,\n  RemoveOptions,\n  AnyObjectWithoutReservedKeys,\n  Item,\n} from './types.js';\nimport { UseDSTreePropTypes, UseDSTreeReturnType, type UseDSTreeT } from './react-desc-prop-types.js';\n\nexport const useDSTree = <AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>>(\n  rootItem: Item<AppInterface>,\n  opts: UseDSTreeT.SecondParameter<AppInterface>,\n) => {\n  const tree = useMemo(() => new DSTree<AppInterface>(rootItem, opts), [opts, rootItem]);\n  const [hash, setHash] = useState(tree.hash);\n\n  const addNode = useCallback(\n    (item: Item<AppInterface>, options?: AddOptions<AppInterface>) => {\n      const cb: AddOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.addNode(item, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const removeNode = useCallback(\n    (id: string, options?: RemoveOptions<AppInterface>) => {\n      const cb: RemoveOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.removeNode(id, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const moveNode = useCallback(\n    (id: string, options?: MoveOptions<AppInterface>) => {\n      const cb: MoveOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.moveNode(id, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  const replaceNode = useCallback(\n    (id: string, item: Item<AppInterface>, options?: MutateOptions<AppInterface>) => {\n      const cb: MutateOptions<AppInterface>['callback'] = (node, treecb) => {\n        options?.callback?.(node, treecb);\n        setHash(treecb.hash);\n      };\n      return tree.replaceNode(id, item, { ...options, callback: cb });\n    },\n    [tree],\n  );\n\n  return {\n    hash,\n    getRoot: tree.getRoot,\n    getNode: tree.getNode,\n    walk: tree.walk,\n    walkParents: tree.walkParents,\n    findNode: tree.findNode,\n    findAllNodes: tree.findAllNodes,\n    flatten: tree.flatten,\n    addNode,\n    removeNode,\n    moveNode,\n    replaceNode,\n    getPath: tree.getPath,\n    getPathIds: tree.getPathIds,\n  } as UseDSTreeT.OutputT<AppInterface>;\n};\n\nuseDSTree.displayName = 'useDSTree';\nexport const UseDSTreeWithSchema = describe(useDSTree);\nUseDSTreeWithSchema.propTypes = UseDSTreePropTypes;\nUseDSTreeWithSchema.returnType = UseDSTreeReturnType;\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACAvB,SAAS,gBAAgB;AACzB,SAAS,aAAa,SAAS,gBAAgB;AAC/C,SAAS,cAAc;AASvB,SAAS,oBAAoB,2BAA4C;AAElE,MAAM,YAAY,CACvB,UACA,SACG;AACH,QAAM,OAAO,QAAQ,MAAM,IAAI,OAAqB,UAAU,IAAI,GAAG,CAAC,MAAM,QAAQ,CAAC;AACrF,QAAM,CAAC,MAAM,OAAO,IAAI,SAAS,KAAK,IAAI;AAE1C,QAAM,UAAU;AAAA,IACd,CAAC,MAA0B,YAAuC;AAChE,YAAM,KAA2C,CAAC,MAAM,WAAW;AACjE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,QAAQ,MAAM,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACxD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,aAAa;AAAA,IACjB,CAAC,IAAY,YAA0C;AACrD,YAAM,KAA8C,CAAC,MAAM,WAAW;AACpE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,WAAW,IAAI,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACzD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,WAAW;AAAA,IACf,CAAC,IAAY,YAAwC;AACnD,YAAM,KAA4C,CAAC,MAAM,WAAW;AAClE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,SAAS,IAAI,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IACvD;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,QAAM,cAAc;AAAA,IAClB,CAAC,IAAY,MAA0B,YAA0C;AAC/E,YAAM,KAA8C,CAAC,MAAM,WAAW;AACpE,iBAAS,WAAW,MAAM,MAAM;AAChC,gBAAQ,OAAO,IAAI;AAAA,MACrB;AACA,aAAO,KAAK,YAAY,IAAI,MAAM,EAAE,GAAG,SAAS,UAAU,GAAG,CAAC;AAAA,IAChE;AAAA,IACA,CAAC,IAAI;AAAA,EACP;AAEA,SAAO;AAAA,IACL;AAAA,IACA,SAAS,KAAK;AAAA,IACd,SAAS,KAAK;AAAA,IACd,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,UAAU,KAAK;AAAA,IACf,cAAc,KAAK;AAAA,IACnB,SAAS,KAAK;AAAA,IACd;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS,KAAK;AAAA,IACd,YAAY,KAAK;AAAA,EACnB;AACF;AAEA,UAAU,cAAc;AACjB,MAAM,sBAAsB,SAAS,SAAS;AACrD,oBAAoB,YAAY;AAChC,oBAAoB,aAAa;",
   "names": []
 }

package/dist/types/DSTree.d.ts

@@ -1,11 +1,11 @@
-import type { AddOptions, AnyObjectWithoutReservedKeys, MoveOptions, MutateOptions, RemoveOptions, JSONThatCanContrusctATree, Item } from './types.js';
+import type { AddOptions, AnyObjectWithoutReservedKeys, MoveOptions, MutateOptions, RemoveOptions, Item } from './types.js';
 import { Node } from './Node.js';
 export declare class DSTree<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {
     private root;
     private _hash;
     private nodes;
     getUniqueId: (item: Item<AppInterface>) => string | number;
-    constructor(item: JSONThatCanContrusctATree<AppInterface>, options: {
+    constructor(item: Item<AppInterface>, options: {
         getUniqueId: (item: Item<AppInterface>) => string | number;
     });
     addNodeToNodesDictionary(node: Node<AppInterface>): void;
@@ -19,10 +19,10 @@ export declare class DSTree<AppInterface extends AnyObjectWithoutReservedKeys =
     findNode: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface> | null;
     findAllNodes: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface>[];
     flatten: () => Node<AppInterface>[];
-    addNode: (item: JSONThatCanContrusctATree<AppInterface>, options?: AddOptions<AppInterface>) => Node<AppInterface>;
+    addNode: (item: Item<AppInterface>, options?: AddOptions<AppInterface>) => Node<AppInterface>;
     removeNode: (id: string | number, options?: RemoveOptions<AppInterface>) => Node<AppInterface>;
     moveNode: (id: string | number, options?: MoveOptions<AppInterface>) => Node<AppInterface>;
-    replaceNode: (id: string | number, item: JSONThatCanContrusctATree<AppInterface>, options?: MutateOptions<AppInterface>) => Node<AppInterface>;
+    replaceNode: (id: string | number, item: Item<AppInterface>, options?: MutateOptions<AppInterface>) => Node<AppInterface>;
     getPath: (id: string | number) => Node<AppInterface>[];
     getPathIds: (id: string | number) => (string | number)[];
 }

package/dist/types/Node.d.ts

@@ -1,16 +1,17 @@
-import type { NodeConstructorOptions, AnyObjectWithoutReservedKeys, JSONThatCanContrusctATree, Item } from './types.js';
+import type { NodeConstructorOptions, AnyObjectWithoutReservedKeys, Item } from './types.js';
 export declare class Node<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {
     dsId: string | number;
     childIndex: number;
     depth: number;
-    plainItem: Omit<Item<AppInterface>, 'subitems'>;
+    plainItem: AppInterface;
+    plainChildren: AppInterface[];
     parent: Node<AppInterface> | null;
     children: Node<AppInterface>[];
     private tree;
     private _hash;
-    constructor(item: JSONThatCanContrusctATree<AppInterface>, { childIndex, depth, parent, tree }: NodeConstructorOptions<AppInterface>);
+    constructor(item: Item<AppInterface>, { childIndex, depth, parent, tree }: NodeConstructorOptions<AppInterface>);
     fixChildIndexes: () => void;
-    getCleanItem: (item: Item<AppInterface>) => Omit<Item<AppInterface>, 'subitems'>;
+    getCleanItem: (item: Item<AppInterface>) => AppInterface;
     get hash(): number;
     walk: (callback: (node: Node<AppInterface>) => boolean) => void;
     walkParents: (callback: (node: Node<AppInterface>) => boolean) => void;
@@ -19,7 +20,7 @@ export declare class Node<AppInterface extends AnyObjectWithoutReservedKeys = Re
     flatten: () => Node<AppInterface>[];
     getPath: (id: string | number) => Node<AppInterface>[];
     getPathIds: (id: string | number) => (string | number)[];
-    getJson: () => JSONThatCanContrusctATree<AppInterface>;
+    getJson: () => Item<AppInterface>;
     addNode: (node: Node<AppInterface>) => void;
     removeNode: () => void;
 }

package/dist/types/react-desc-prop-types.d.ts

@@ -1,14 +1,16 @@
 import { type ValidationMap } from '@elliemae/ds-props-helpers';
 import type { Node } from './Node.js';
-import type { AddOptions, MoveOptions, MutateOptions, RemoveOptions, Item, AnyObjectWithoutReservedKeys, JSONThatCanContrusctATree } from './types.js';
+import type { AddOptions, AnyObjectWithoutReservedKeys as AnyObjectWithoutReservedKeysToRexport, Item as ItemToRexport, MoveOptions, MutateOptions, RemoveOptions } from './types.js';
 export declare namespace UseDSTreeT {
-    type TreeNode<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = Node<AppInterface>;
-    type TreeItem<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = Item<AppInterface>;
-    type FirstParameter<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = TreeItem<AppInterface>;
-    type SecondParameter<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = {
+    type AnyObjectWithoutReservedKeys = AnyObjectWithoutReservedKeysToRexport;
+    type Item<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = ItemToRexport<AppInterface>;
+    type TreeNode<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> = Node<AppInterface>;
+    type TreeItem<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> = Item<AppInterface>;
+    type FirstParameter<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> = TreeItem<AppInterface>;
+    type SecondParameter<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> = {
         getUniqueId: (item: TreeItem<AppInterface>) => string | number;
     };
-    interface OutputT<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {
+    interface OutputT<AppInterface extends AnyObjectWithoutReservedKeysToRexport = Record<string, unknown>> {
         hash: number;
         getRoot: () => Node<AppInterface>;
         getNode: (id: string | number) => Node<AppInterface>;
@@ -17,10 +19,10 @@ export declare namespace UseDSTreeT {
         findNode: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface> | null;
         findAllNodes: (callback: (node: Node<AppInterface>) => boolean) => Node<AppInterface>[];
         flatten: () => Node<AppInterface>[];
-        addNode: (item: JSONThatCanContrusctATree<AppInterface>, options?: AddOptions<AppInterface>) => Node<AppInterface>;
+        addNode: (item: ItemToRexport<AppInterface>, options?: AddOptions<AppInterface>) => Node<AppInterface>;
         removeNode: (id: string | number, options?: RemoveOptions<AppInterface>) => Node<AppInterface>;
         moveNode: (id: string | number, options?: MoveOptions<AppInterface>) => Node<AppInterface>;
-        replaceNode: (id: string | number, item: JSONThatCanContrusctATree<AppInterface>, options?: MutateOptions<AppInterface>) => Node<AppInterface>;
+        replaceNode: (id: string | number, item: ItemToRexport<AppInterface>, options?: MutateOptions<AppInterface>) => Node<AppInterface>;
         getPath: (id: string | number) => Node<AppInterface>[];
         getPathIds: (id: string | number) => (string | number)[];
     }

package/dist/types/types.d.ts

@@ -1,12 +1,7 @@
 import type { DSTree } from './DSTree.js';
 import type { Node } from './Node.js';
-export type AnyObjectWithoutReservedKeys = Omit<Record<string, unknown>, 'dsId' | 'subitems'>;
-export type JSONThatCanContrusctATree<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = AppInterface & {
-    dsId: string | number;
-    subitems?: JSONThatCanContrusctATree<AppInterface>[] | ReadonlyArray<JSONThatCanContrusctATree<AppInterface>>;
-};
-export type Item<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = Omit<AppInterface, 'dsId' | 'subitems'> & {
-    dsId: string | number;
+export type AnyObjectWithoutReservedKeys = Omit<Record<string, unknown>, 'subitems'>;
+export type Item<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> = AppInterface & {
     subitems?: Item<AppInterface>[] | ReadonlyArray<Item<AppInterface>>;
 };
 export interface NodeConstructorOptions<AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>> {

package/dist/types/useDSTree.d.ts

@@ -1,7 +1,7 @@
-import type { AnyObjectWithoutReservedKeys, JSONThatCanContrusctATree } from './types.js';
+import type { AnyObjectWithoutReservedKeys, Item } from './types.js';
 import { type UseDSTreeT } from './react-desc-prop-types.js';
 export declare const useDSTree: {
-    <AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>>(rootItem: JSONThatCanContrusctATree<AppInterface>, opts: UseDSTreeT.SecondParameter<AppInterface>): UseDSTreeT.OutputT<AppInterface>;
+    <AppInterface extends AnyObjectWithoutReservedKeys = Record<string, unknown>>(rootItem: Item<AppInterface>, opts: UseDSTreeT.SecondParameter<AppInterface>): UseDSTreeT.OutputT<AppInterface>;
     displayName: string;
 };
-export declare const UseDSTreeWithSchema: import("@elliemae/ds-props-helpers/dist/types/propTypes/types.js").DocumentedReactComponent<JSONThatCanContrusctATree<AnyObjectWithoutReservedKeys>>;
+export declare const UseDSTreeWithSchema: import("@elliemae/ds-props-helpers/dist/types/propTypes/types.js").DocumentedReactComponent<Item<AnyObjectWithoutReservedKeys>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-tree-model",
-  "version": "3.45.0-rc.0",
+  "version": "3.45.0-rc.2",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Tree Model",
   "files": [
@@ -40,11 +40,11 @@
     "typeSafety": true
   },
   "dependencies": {
-    "@elliemae/ds-props-helpers": "3.45.0-rc.0"
+    "@elliemae/ds-props-helpers": "3.45.0-rc.2"
   },
   "devDependencies": {
     "@elliemae/pui-cli": "9.0.0-next.50",
-    "@elliemae/ds-monorepo-devops": "3.45.0-rc.0"
+    "@elliemae/ds-monorepo-devops": "3.45.0-rc.2"
   },
   "peerDependencies": {
     "lodash": "^4.17.21",