@elliemae/ds-legacy-tree-model 1.0.0-rc.1

package/dist/cjs/adapters/treeview/useTreeviewAsDSTree.js

@@ -0,0 +1,47 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useTreeviewAsDSTree_exports = {};
+__export(useTreeviewAsDSTree_exports, {
+  useTreeviewAsDSTree: () => useTreeviewAsDSTree
+});
+module.exports = __toCommonJS(useTreeviewAsDSTree_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_useArraishAsDSTree = require("../arraish-tree/useArraishAsDSTree.js");
+const useTreeviewAsDSTree = (treeData) => {
+  const opts = (0, import_react.useMemo)(
+    () => ({
+      getChildrenKey: () => "children",
+      getUniqueId: (node) => `${node.id}`
+    }),
+    []
+  );
+  return (0, import_useArraishAsDSTree.useArraishAsDSTree)(treeData, opts);
+};
+//# sourceMappingURL=useTreeviewAsDSTree.js.map

package/dist/cjs/adapters/treeview/useTreeviewAsDSTree.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/adapters/treeview/useTreeviewAsDSTree.ts", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useMemo } from 'react';\nimport { useArraishAsDSTree } from '../arraish-tree/useArraishAsDSTree.js';\n\ntype TreeviewItem<T extends object = object> = T & {\n  id: string | number;\n  children?: TreeviewItem[];\n};\n\nexport const useTreeviewAsDSTree = <T extends TreeviewItem<object> = TreeviewItem<object>>(treeData: T[]) => {\n  const opts = useMemo(\n    () => ({\n      getChildrenKey: () => 'children',\n      getUniqueId: (node: T) => `${node.id}`,\n    }),\n    [],\n  );\n  return useArraishAsDSTree(treeData, opts);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAwB;AACxB,gCAAmC;AAO5B,MAAM,sBAAsB,CAAwD,aAAkB;AAC3G,QAAM,WAAO;AAAA,IACX,OAAO;AAAA,MACL,gBAAgB,MAAM;AAAA,MACtB,aAAa,CAAC,SAAY,GAAG,KAAK;AAAA,IACpC;AAAA,IACA,CAAC;AAAA,EACH;AACA,aAAO,8CAAmB,UAAU,IAAI;AAC1C;",
+  "names": []
+}

package/dist/cjs/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  DSTree: () => import_DSTree.DSTree,
+  fromDSTreeToTreeishArray: () => import_fromDSTreeToTreeishArray.fromDSTreeToTreeishArray,
+  fromTreeishArrayToDSTree: () => import_fromTreeishArrayToDSTree.fromTreeishArrayToDSTree,
+  useArraishAsDSTree: () => import_useArraishAsDSTree.useArraishAsDSTree,
+  useDSTree: () => import_useDSTree.useDSTree,
+  useTreeviewAsDSTree: () => import_useTreeviewAsDSTree.useTreeviewAsDSTree
+});
+module.exports = __toCommonJS(src_exports);
+var React = __toESM(require("react"));
+var import_DSTree = require("./DSTree.js");
+var import_useDSTree = require("./useDSTree.js");
+var import_fromTreeishArrayToDSTree = require("./adapters/arraish-tree/fromTreeishArrayToDSTree.js");
+var import_fromDSTreeToTreeishArray = require("./adapters/arraish-tree/fromDSTreeToTreeishArray.js");
+var import_useArraishAsDSTree = require("./adapters/arraish-tree/useArraishAsDSTree.js");
+var import_useTreeviewAsDSTree = require("./adapters/treeview/useTreeviewAsDSTree.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export type { Item } from './types.js';\nexport type { Node } from './Node.js';\nexport { DSTree } from './DSTree.js';\nexport { useDSTree } from './useDSTree.js';\nexport { fromTreeishArrayToDSTree } from './adapters/arraish-tree/fromTreeishArrayToDSTree.js';\nexport { fromDSTreeToTreeishArray } from './adapters/arraish-tree/fromDSTreeToTreeishArray.js';\nexport { useArraishAsDSTree } from './adapters/arraish-tree/useArraishAsDSTree.js';\nexport { useTreeviewAsDSTree } from './adapters/treeview/useTreeviewAsDSTree.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADEvB,oBAAuB;AACvB,uBAA0B;AAC1B,sCAAyC;AACzC,sCAAyC;AACzC,gCAAmC;AACnC,iCAAoC;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,7 @@
+{
+  "type": "commonjs",
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ]
+}

package/dist/cjs/types.js

@@ -0,0 +1,28 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+var React = __toESM(require("react"));
+//# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -0,0 +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 interface Item {\n  subitems?: Item[];\n  [key: string]: unknown;\n}\n\nexport interface NodeConstructorOptions<T extends Item> {\n  childIndex: number;\n  depth: number;\n  tree: DSTree<T>;\n  parent?: Node<T> | null;\n}\n\nexport interface AddOptions<T extends Item> {\n  position?: number;\n  parent?: Node<T> | null;\n  callback?: (node: Node<T>, tree: DSTree<T>) => void;\n}\n\nexport interface RemoveOptions<T extends Item> {\n  callback?: (node: Node<T>, tree: DSTree<T>) => void;\n}\n\nexport interface MoveOptions<T extends Item> {\n  position?: number;\n  parent?: Node<T>;\n  callback?: (node: Node<T>, tree: DSTree<T>) => void;\n}\n\nexport interface MutateOptions<T extends Item> {\n  callback?: (node: Node<T>, tree: DSTree<T>) => void;\n}\nexport interface OverloadedItem<T extends object = object> extends Item {\n  id: string;\n  subitems: OverloadedItem<T>[];\n  originalNodeData: T;\n}\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;ACAA,YAAuB;",
+  "names": []
+}

package/dist/cjs/useDSTree.js

@@ -0,0 +1,97 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useDSTree_exports = {};
+__export(useDSTree_exports, {
+  useDSTree: () => useDSTree
+});
+module.exports = __toCommonJS(useDSTree_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_DSTree = require("./DSTree.js");
+const useDSTree = (rootItem, opts) => {
+  const tree = (0, import_react.useMemo)(() => new import_DSTree.DSTree(rootItem, opts), [opts, rootItem]);
+  const [hash, setHash] = (0, import_react.useState)(tree.hash);
+  const addNode = (0, import_react.useCallback)(
+    (item, options) => {
+      const cb = (node, treecb) => {
+        options?.callback?.(node, treecb);
+        setHash(treecb.hash);
+      };
+      return tree.addNode(item, { ...options, callback: cb });
+    },
+    [tree]
+  );
+  const removeNode = (0, import_react.useCallback)(
+    (id, options) => {
+      const cb = (node, treecb) => {
+        options?.callback?.(node, treecb);
+        setHash(treecb.hash);
+      };
+      return tree.removeNode(id, { ...options, callback: cb });
+    },
+    [tree]
+  );
+  const moveNode = (0, import_react.useCallback)(
+    (id, options) => {
+      const cb = (node, treecb) => {
+        options?.callback?.(node, treecb);
+        setHash(treecb.hash);
+      };
+      return tree.moveNode(id, { ...options, callback: cb });
+    },
+    [tree]
+  );
+  const replaceNode = (0, import_react.useCallback)(
+    (id, item, options) => {
+      const cb = (node, treecb) => {
+        options?.callback?.(node, treecb);
+        setHash(treecb.hash);
+      };
+      return tree.replaceNode(id, item, { ...options, callback: cb });
+    },
+    [tree]
+  );
+  return {
+    hash,
+    getRoot: tree.getRoot,
+    getNode: tree.getNode,
+    walk: tree.walk,
+    walkParents: tree.walkParents,
+    findNode: tree.findNode,
+    findAllNodes: tree.findAllNodes,
+    flatten: tree.flatten,
+    addNode,
+    removeNode,
+    moveNode,
+    replaceNode,
+    getPath: tree.getPath,
+    getPathIds: tree.getPathIds
+  };
+};
+//# sourceMappingURL=useDSTree.js.map

package/dist/cjs/useDSTree.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/useDSTree.ts", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useCallback, useMemo, useState } from 'react';\nimport { DSTree } from './DSTree.js';\nimport type { AddOptions, Item, MoveOptions, MutateOptions, RemoveOptions } from './types.js';\n\nexport const useDSTree = <T extends Item>(rootItem: T, opts: { getUniqueId: (item: T) => string }) => {\n  const tree = useMemo(() => new DSTree(rootItem, opts), [opts, rootItem]);\n  const [hash, setHash] = useState(tree.hash);\n\n  const addNode = useCallback(\n    (item: T, options?: AddOptions<T>) => {\n      const cb: AddOptions<T>['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<T>) => {\n      const cb: RemoveOptions<T>['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<T>) => {\n      const cb: MoveOptions<T>['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: T, options?: MutateOptions<T>) => {\n      const cb: MutateOptions<T>['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  };\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA+C;AAC/C,oBAAuB;AAGhB,MAAM,YAAY,CAAiB,UAAa,SAA+C;AACpG,QAAM,WAAO,sBAAQ,MAAM,IAAI,qBAAO,UAAU,IAAI,GAAG,CAAC,MAAM,QAAQ,CAAC;AACvE,QAAM,CAAC,MAAM,OAAO,QAAI,uBAAS,KAAK,IAAI;AAE1C,QAAM,cAAU;AAAA,IACd,CAAC,MAAS,YAA4B;AACpC,YAAM,KAAgC,CAAC,MAAM,WAAW;AACtD,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,YAA+B;AAC1C,YAAM,KAAmC,CAAC,MAAM,WAAW;AACzD,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,YAA6B;AACxC,YAAM,KAAiC,CAAC,MAAM,WAAW;AACvD,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,MAAS,YAA+B;AACnD,YAAM,KAAmC,CAAC,MAAM,WAAW;AACzD,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;",
+  "names": []
+}

package/dist/esm/DSTree.js

@@ -0,0 +1,81 @@
+import * as React from "react";
+import { Node } from "./Node.js";
+class DSTree {
+  constructor(item, options) {
+    this.getRoot = () => this.root;
+    this.getNode = (id) => this.nodes[id];
+    this.getNodes = () => this.nodes;
+    this.walk = (callback) => {
+      this.root.walk(callback);
+    };
+    this.walkParents = (callback) => {
+      this.root.walkParents(callback);
+    };
+    this.findNode = (callback) => this.root.findNode(callback);
+    this.findAllNodes = (callback) => this.root.findAllNodes(callback);
+    this.flatten = () => this.root.flatten();
+    this.addNode = (item, options = {}) => {
+      const { position, parent, callback } = options;
+      const parentDefault = parent || this.root;
+      const positionDefault = position ?? parentDefault.children.length;
+      const node = new Node(item, {
+        childIndex: positionDefault,
+        depth: parentDefault.depth + 1,
+        parent: parentDefault,
+        tree: this
+      });
+      this.getNode(parentDefault.dsId).addNode(node);
+      this._hash += 1;
+      callback?.(node, this);
+      return node;
+    };
+    this.removeNode = (id, options = {}) => {
+      const node = this.getNode(id);
+      if (!node)
+        throw new Error(`Node with id ${id} not found`);
+      node.removeNode();
+      this._hash += 1;
+      options.callback?.(node, this);
+      return node;
+    };
+    this.moveNode = (id, options = {}) => {
+      const removedNode = this.removeNode(id);
+      const node = this.addNode(removedNode.getJson(), options);
+      this._hash += 1;
+      return node;
+    };
+    this.replaceNode = (id, item, options = {}) => {
+      const removedNode = this.removeNode(id);
+      const node = this.addNode(item, { parent: removedNode.parent, position: removedNode.childIndex });
+      this._hash += 1;
+      options.callback?.(node, this);
+      return node;
+    };
+    this.getPath = (id) => this.getRoot().getPath(id);
+    this.getPathIds = (id) => this.getRoot().getPathIds(id);
+    this.getUniqueId = options.getUniqueId;
+    this.root = new Node(item, { childIndex: 0, depth: 0, tree: this });
+    this.nodes = {};
+    this._hash = 0;
+    this.root.walk((node) => {
+      this.nodes[node.dsId] = node;
+      return true;
+    });
+  }
+  addNodeToNodesDictionary(node) {
+    if (this.nodes[node.dsId]) {
+      throw new Error(`DSTree: repeated dsId ${node.dsId}`);
+    }
+    this.nodes[node.dsId] = node;
+  }
+  removeNodeFromNodesDictionary(node) {
+    delete this.nodes[node.dsId];
+  }
+  get hash() {
+    return this._hash;
+  }
+}
+export {
+  DSTree
+};
+//# sourceMappingURL=DSTree.js.map

package/dist/esm/DSTree.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/DSTree.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import type { AddOptions, Item, MoveOptions, MutateOptions, RemoveOptions } from './types.js';\nimport { Node } from './Node.js';\n\nexport class DSTree<T extends Item> {\n  private root: Node<T>;\n\n  private _hash: number;\n\n  private nodes: Record<string, Node<T>>;\n\n  getUniqueId: (item: T) => string;\n\n  constructor(item: T, options: { getUniqueId: (item: T) => string }) {\n    this.getUniqueId = options.getUniqueId;\n    this.root = new Node(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<T>): 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<T>): void {\n    delete this.nodes[node.dsId];\n  }\n\n  get hash(): number {\n    return this._hash;\n  }\n\n  getRoot = (): Node<T> => this.root;\n\n  getNode = (id: string): Node<T> => this.nodes[id];\n\n  getNodes = (): Record<string, Node<T>> => this.nodes;\n\n  walk = (callback: (node: Node<T>) => boolean): void => {\n    this.root.walk(callback);\n  };\n\n  walkParents = (callback: (node: Node<T>) => boolean): void => {\n    this.root.walkParents(callback);\n  };\n\n  findNode = (callback: (node: Node<T>) => boolean): Node<T> | null => this.root.findNode(callback);\n\n  findAllNodes = (callback: (node: Node<T>) => boolean): Node<T>[] => this.root.findAllNodes(callback);\n\n  flatten = (): Node<T>[] => this.root.flatten();\n\n  addNode = (item: T, options: AddOptions<T> = {}): Node<T> => {\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(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, options: RemoveOptions<T> = {}): Node<T> => {\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, options: MoveOptions<T> = {}): Node<T> => {\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 = (id: string, item: T, options: MutateOptions<T> = {}): Node<T> => {\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): Node<T>[] => this.getRoot().getPath(id);\n\n  getPathIds = (id: string): string[] => this.getRoot().getPathIds(id);\n}\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACCvB,SAAS,YAAY;AAEd,MAAM,OAAuB;AAAA,EASlC,YAAY,MAAS,SAA+C;AA+BpE,mBAAU,MAAe,KAAK;AAE9B,mBAAU,CAAC,OAAwB,KAAK,MAAM,EAAE;AAEhD,oBAAW,MAA+B,KAAK;AAE/C,gBAAO,CAAC,aAA+C;AACrD,WAAK,KAAK,KAAK,QAAQ;AAAA,IACzB;AAEA,uBAAc,CAAC,aAA+C;AAC5D,WAAK,KAAK,YAAY,QAAQ;AAAA,IAChC;AAEA,oBAAW,CAAC,aAAyD,KAAK,KAAK,SAAS,QAAQ;AAEhG,wBAAe,CAAC,aAAoD,KAAK,KAAK,aAAa,QAAQ;AAEnG,mBAAU,MAAiB,KAAK,KAAK,QAAQ;AAE7C,mBAAU,CAAC,MAAS,UAAyB,CAAC,MAAe;AAC3D,YAAM,EAAE,UAAU,QAAQ,SAAS,IAAI;AACvC,YAAM,gBAAgB,UAAU,KAAK;AACrC,YAAM,kBAAkB,YAAY,cAAc,SAAS;AAG3D,YAAM,OAAO,IAAI,KAAK,MAAM;AAAA,QAC1B,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,IAAY,UAA4B,CAAC,MAAe;AACpE,YAAM,OAAO,KAAK,QAAQ,EAAE;AAC5B,UAAI,CAAC;AAAM,cAAM,IAAI,MAAM,gBAAgB,cAAc;AAEzD,WAAK,WAAW;AAGhB,WAAK,SAAS;AAGd,cAAQ,WAAW,MAAM,IAAI;AAE7B,aAAO;AAAA,IACT;AAEA,oBAAW,CAAC,IAAY,UAA0B,CAAC,MAAe;AAChE,YAAM,cAAc,KAAK,WAAW,EAAE;AACtC,YAAM,OAAO,KAAK,QAAQ,YAAY,QAAQ,GAAG,OAAO;AAExD,WAAK,SAAS;AAEd,aAAO;AAAA,IACT;AAEA,uBAAc,CAAC,IAAY,MAAS,UAA4B,CAAC,MAAe;AAC9E,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,OAA0B,KAAK,QAAQ,EAAE,QAAQ,EAAE;AAE9D,sBAAa,CAAC,OAAyB,KAAK,QAAQ,EAAE,WAAW,EAAE;AA/GjE,SAAK,cAAc,QAAQ;AAC3B,SAAK,OAAO,IAAI,KAAK,MAAM,EAAE,YAAY,GAAG,OAAO,GAAG,MAAM,KAAK,CAAC;AAClE,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,MAAqB;AAE5C,QAAI,KAAK,MAAM,KAAK,IAAI,GAAG;AACzB,YAAM,IAAI,MAAM,yBAAyB,KAAK,MAAM;AAAA,IACtD;AAEA,SAAK,MAAM,KAAK,IAAI,IAAI;AAAA,EAC1B;AAAA,EAEA,8BAA8B,MAAqB;AACjD,WAAO,KAAK,MAAM,KAAK,IAAI;AAAA,EAC7B;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK;AAAA,EACd;AAoFF;",
+  "names": []
+}

package/dist/esm/Node.js

@@ -0,0 +1,124 @@
+import * as React from "react";
+import { cloneDeep, omit } from "lodash";
+class Node {
+  constructor(item, { childIndex, depth, parent, tree }) {
+    // ===========================================================================
+    // INTERNAL METHODS
+    // ===========================================================================
+    this.fixChildIndexes = () => {
+      for (let i = 0; i < this.children.length; i++) {
+        this.children[i].childIndex = i;
+      }
+      this._hash += 1;
+    };
+    this.getCleanItem = (item) => {
+      const plainItem = omit(item, ["subitems"]);
+      return cloneDeep(plainItem);
+    };
+    this.walk = (callback) => {
+      const shouldContinueWalking = callback(this);
+      if (shouldContinueWalking) {
+        for (const child of this.children) {
+          child.walk(callback);
+        }
+      }
+    };
+    this.walkParents = (callback) => {
+      const shouldContinueWalking = callback(this);
+      if (shouldContinueWalking && this.parent) {
+        this.parent.walkParents(callback);
+      }
+    };
+    this.findNode = (callback) => {
+      let found = null;
+      this.walk((node) => {
+        if (found)
+          return false;
+        if (callback(node))
+          found = node;
+        return !found;
+      });
+      return found;
+    };
+    this.findAllNodes = (callback) => {
+      const found = [];
+      this.walk((node) => {
+        if (callback(node))
+          found.push(node);
+        return true;
+      });
+      return found;
+    };
+    this.flatten = () => {
+      const flattened = [];
+      this.walk((node) => {
+        flattened.push(node);
+        return true;
+      });
+      return flattened;
+    };
+    this.getPath = (id) => {
+      const path = [];
+      const node = this.tree.getNode(id);
+      if (!node)
+        return path;
+      node.walkParents((parent) => {
+        path.push(parent);
+        return parent.dsId !== this.dsId;
+      });
+      return path.reverse();
+    };
+    this.getPathIds = (id) => this.getPath(id).map((node) => node.dsId);
+    this.getJson = () => ({
+      ...this.plainItem,
+      subitems: this.children.map((child) => child.getJson())
+    });
+    // ===========================================================================
+    // WRITE METHODS
+    // ===========================================================================
+    this.addNode = (node) => {
+      const position = node.childIndex;
+      if (position < 0 || position > this.children.length) {
+        throw new Error(`Invalid position ${position} for parent ${this.dsId} with item ${node.dsId}`);
+      }
+      this.children.splice(position, 0, node);
+      this.fixChildIndexes();
+      node.walk((child) => {
+        this.tree.addNodeToNodesDictionary(child);
+        return true;
+      });
+      this._hash += 1;
+    };
+    this.removeNode = () => {
+      if (!this.parent)
+        throw new Error(`Cannot remove root node with id ${this.dsId}`);
+      this.parent.children.splice(this.childIndex, 1);
+      this.parent.fixChildIndexes();
+      this.walk((child) => {
+        this.tree.removeNodeFromNodesDictionary(child);
+        return true;
+      });
+      this._hash += 1;
+    };
+    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(item);
+  }
+  // ===========================================================================
+  // READ METHODS
+  // ===========================================================================
+  get hash() {
+    return this._hash;
+  }
+}
+export {
+  Node
+};
+//# sourceMappingURL=Node.js.map

package/dist/esm/Node.js.map

@@ -0,0 +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-use-before-define */\n/* eslint-disable max-params */\nimport { cloneDeep, omit } from 'lodash';\nimport type { DSTree } from './DSTree.js';\nimport type { Item, NodeConstructorOptions } from './types.js';\n\nexport class Node<T extends Item> {\n  dsId: string;\n\n  plainItem: T;\n\n  childIndex: number;\n\n  depth: number;\n\n  parent: Node<T> | null;\n\n  children: Node<T>[];\n\n  private tree!: DSTree<T>;\n\n  private _hash: number;\n\n  constructor(item: T, { childIndex, depth, parent, tree }: NodeConstructorOptions<T>) {\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\n    this.children =\n      item.subitems?.map(\n        (subitem, index) => new Node(subitem as T, { childIndex: index, depth: depth + 1, parent: this, tree }),\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++) {\n      this.children[i].childIndex = i;\n    }\n    this._hash += 1;\n  };\n\n  getCleanItem = (item: T): T => {\n    const plainItem = omit(item, ['subitems']);\n    return cloneDeep(plainItem as T);\n  };\n\n  // ===========================================================================\n  // READ METHODS\n  // ===========================================================================\n\n  get hash(): number {\n    return this._hash;\n  }\n\n  walk = (callback: (node: Node<T>) => boolean): void => {\n    const shouldContinueWalking = callback(this);\n    if (shouldContinueWalking) {\n      for (const child of this.children) {\n        child.walk(callback);\n      }\n    }\n  };\n\n  walkParents = (callback: (node: Node<T>) => 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<T>) => boolean): Node<T> | null => {\n    // find first node using walk\n    let found: Node<T> | 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<T>) => boolean): Node<T>[] => {\n    const found: Node<T>[] = [];\n    this.walk((node) => {\n      if (callback(node)) found.push(node);\n      return true;\n    });\n    return found;\n  };\n\n  flatten = (): Node<T>[] => {\n    const flattened: Node<T>[] = [];\n    this.walk((node) => {\n      flattened.push(node);\n      return true;\n    });\n    return flattened;\n  };\n\n  getPath = (id: string): Node<T>[] => {\n    const path: Node<T>[] = [];\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): string[] => this.getPath(id).map((node) => node.dsId);\n\n  getJson = (): T => ({\n    ...this.plainItem,\n    subitems: this.children.map((child) => child.getJson()),\n  });\n\n  // ===========================================================================\n  // WRITE METHODS\n  // ===========================================================================\n\n  addNode = (node: Node<T>) => {\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/fromDSTreeToTreeishArray.js

@@ -0,0 +1,53 @@
+import * as React from "react";
+const fromDSTreeToTreeishArray = (args) => {
+  const { tree, opts } = args;
+  const { getChildrenKey, getUniqueId } = opts;
+  const root = tree.getRoot();
+  const restoredTreeish = [];
+  const callback = (node) => {
+    if (node.depth === 0)
+      return true;
+    const nodeJson = node.getJson();
+    const originalNode = structuredClone(nodeJson.originalNodeData);
+    const nodeChildrenKey = getChildrenKey(originalNode);
+    if (!Object.hasOwnProperty.call(originalNode, nodeChildrenKey)) {
+      Object.defineProperty(originalNode, nodeChildrenKey, {
+        value: [],
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+    if (node.depth === 1) {
+      restoredTreeish.push(originalNode);
+      return true;
+    }
+    const parents = root.getPathIds(node.dsId);
+    parents.shift();
+    parents.pop();
+    let parent = restoredTreeish.find((item) => `${getUniqueId(item)}` === parents[0]);
+    if (!parent)
+      throw new Error(
+        `Unable to find parent node with id ${parents[0]}, have you provided the correct getUniqueId function?`
+      );
+    let parentChildrenKey = getChildrenKey(parent);
+    for (let i = 1; i < parents.length; i++) {
+      const childrens = parent[parentChildrenKey];
+      if (!childrens)
+        throw new Error(
+          `Unable to children node with id ${parents[i]}, have you provided the correct getChildrenKey function?`
+        );
+      parent = childrens.find((item) => `${getUniqueId(item)}` === parents[i]);
+      parentChildrenKey = getChildrenKey(parent);
+    }
+    const parentChildrenArray = parent[parentChildrenKey];
+    parentChildrenArray.push(originalNode);
+    return true;
+  };
+  root.walk(callback);
+  return restoredTreeish;
+};
+export {
+  fromDSTreeToTreeishArray
+};
+//# sourceMappingURL=fromDSTreeToTreeishArray.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../scripts/build/transpile/react-shim.js", "../../../../src/adapters/arraish-tree/fromDSTreeToTreeishArray.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable max-statements */\nimport type { DSTree } from '../../DSTree.js';\nimport type { Node } from '../../Node.js';\nimport type { OverloadedItem } from '../../types.js';\n\n/*\n * a function that given a DSTree datastructure and some options returns a treeish array that compltely preserves the original data.\n * this is meant to revert the operation done by fromTreeishArrayToDSTree in a seamless way,\n *   as such makes, some assumptions:\n *    - the original data lives under the \"originalNodeData\" property of the node\n *    - the root node is a pseudoRoot node that will not be part of the final treeish array\n * NOTE:  This create a deep clone of the node original data, so it's not suitable for large trees and will not preserve any reference in the nodes original data\n * NOTE2: Nodes that have no children will be restored with an empty \"children\" array, this may be a data-loss, but this can't be easily avoided,\n *  if this is important for your use-case you should implement your own conversion function with your requirements\n * @param {DSTree} tree - a DSTree datastructure (generated with a structure exactly the same as the one resulting from invoking fromTreeishArrayToDSTree)\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 {Array} - a treeish array\n */\n\nexport const fromDSTreeToTreeishArray = <T extends object = object>(args: {\n  tree: DSTree<OverloadedItem<T>>;\n  opts: {\n    getChildrenKey: (node: T) => keyof T;\n    getUniqueId: (node: T) => string;\n  };\n}): T[] => {\n  const { tree, opts } = args;\n  const { getChildrenKey, getUniqueId } = opts;\n  const root = tree.getRoot();\n  const restoredTreeish: T[] = [];\n  const callback = (node: Node<OverloadedItem<T>>) => {\n    // everytime we step in a node we want to:\n    //  - understand if the node has a parent\n    //    - if it does, we want to find the parent in the restoredTreeish array and add the node to the parent's children\n    //        the \"children\" are stored under the key returned by the getChildrenKey function\n    //    - if it doesn't, we make the assumption that this is a \"first-level\" node and we add it to the restoredTreeish array\n    //  - what ends up in the restoredTreeish array are only value from the \"originalNodeData\" property of the node + childrens under the key returned by the getChildrenKey function\n    // we skip the root node\n    if (node.depth === 0) return true;\n    // we create the original node from the originalNodeData property of the node\n    const nodeJson = node.getJson();\n    const originalNode = structuredClone(nodeJson.originalNodeData);\n    const nodeChildrenKey = getChildrenKey(originalNode);\n    // we add a \"children\" array, creating it if doesn't exist\n    if (!Object.hasOwnProperty.call(originalNode, nodeChildrenKey)) {\n      Object.defineProperty(originalNode, nodeChildrenKey, {\n        value: [] as T[],\n        writable: true,\n        enumerable: true,\n        configurable: true,\n      });\n    }\n    // if depth is 1, we are dealing with a first-level node, so we add it to the restoredTreeish array as is\n    if (node.depth === 1) {\n      restoredTreeish.push(originalNode);\n      return true;\n    }\n    // if depth is > 1, we are dealing with a node that has a parent, so we need to find the parent in the restoredTreeish array\n    //  and add the node to the parent's children\n    const parents = root.getPathIds(node.dsId);\n    parents.shift(); // we added the pseudo-root, we skip it based on the assumption\n    parents.pop(); // getPathIds also include the current searched for at the end of the array, we don't need that\n\n    // we now find the parent in the restoredTreeish array\n    // if this find fails this is an unrecoverable error, something is wrong in the opts callbacks or at app-level\n    //  the only other alternative is that the \"walk\" method from DSTree changed the order of the nodes, which would be a breaking change\n    let parent = restoredTreeish.find((item: T) => `${getUniqueId(item)}` === parents[0]) as T;\n    if (!parent)\n      throw new Error(\n        `Unable to find parent node with id ${parents[0]}, have you provided the correct getUniqueId function?`,\n      );\n    let parentChildrenKey = getChildrenKey(parent);\n    // we now walk the parents array, skipping the first element (we already found the parent),\n    //  we must use the for loop to be sure that we are invoking code sequentially\n    for (let i = 1; i < parents.length; i++) {\n      // if this loop fails this is an unrecoverable error, something is wrong in the opts callbacks or at app-level\n      //  the only other alternative is that the \"walk\" method from DSTree changed the order of the nodes, which would be a breaking change\n      const childrens = parent[parentChildrenKey] as T[];\n      if (!childrens)\n        throw new Error(\n          `Unable to children node with id ${parents[i]}, have you provided the correct getChildrenKey function?`,\n        );\n      parent = childrens.find((item: T) => `${getUniqueId(item)}` === parents[i]) as T;\n      parentChildrenKey = getChildrenKey(parent);\n    }\n\n    const parentChildrenArray = parent[parentChildrenKey] as T[];\n    parentChildrenArray.push(originalNode);\n\n    return true; // we will walk all the nodes no matter what\n  };\n  root.walk(callback);\n\n  return restoredTreeish;\n};\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACqBhB,MAAM,2BAA2B,CAA4B,SAMzD;AACT,QAAM,EAAE,MAAM,KAAK,IAAI;AACvB,QAAM,EAAE,gBAAgB,YAAY,IAAI;AACxC,QAAM,OAAO,KAAK,QAAQ;AAC1B,QAAM,kBAAuB,CAAC;AAC9B,QAAM,WAAW,CAAC,SAAkC;AAQlD,QAAI,KAAK,UAAU;AAAG,aAAO;AAE7B,UAAM,WAAW,KAAK,QAAQ;AAC9B,UAAM,eAAe,gBAAgB,SAAS,gBAAgB;AAC9D,UAAM,kBAAkB,eAAe,YAAY;AAEnD,QAAI,CAAC,OAAO,eAAe,KAAK,cAAc,eAAe,GAAG;AAC9D,aAAO,eAAe,cAAc,iBAAiB;AAAA,QACnD,OAAO,CAAC;AAAA,QACR,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,cAAc;AAAA,MAChB,CAAC;AAAA,IACH;AAEA,QAAI,KAAK,UAAU,GAAG;AACpB,sBAAgB,KAAK,YAAY;AACjC,aAAO;AAAA,IACT;AAGA,UAAM,UAAU,KAAK,WAAW,KAAK,IAAI;AACzC,YAAQ,MAAM;AACd,YAAQ,IAAI;AAKZ,QAAI,SAAS,gBAAgB,KAAK,CAAC,SAAY,GAAG,YAAY,IAAI,QAAQ,QAAQ,CAAC,CAAC;AACpF,QAAI,CAAC;AACH,YAAM,IAAI;AAAA,QACR,sCAAsC,QAAQ,CAAC;AAAA,MACjD;AACF,QAAI,oBAAoB,eAAe,MAAM;AAG7C,aAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AAGvC,YAAM,YAAY,OAAO,iBAAiB;AAC1C,UAAI,CAAC;AACH,cAAM,IAAI;AAAA,UACR,mCAAmC,QAAQ,CAAC;AAAA,QAC9C;AACF,eAAS,UAAU,KAAK,CAAC,SAAY,GAAG,YAAY,IAAI,QAAQ,QAAQ,CAAC,CAAC;AAC1E,0BAAoB,eAAe,MAAM;AAAA,IAC3C;AAEA,UAAM,sBAAsB,OAAO,iBAAiB;AACpD,wBAAoB,KAAK,YAAY;AAErC,WAAO;AAAA,EACT;AACA,OAAK,KAAK,QAAQ;AAElB,SAAO;AACT;",
+  "names": []
+}

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

@@ -0,0 +1,52 @@
+import * as React from "react";
+import { DSTree } from "../../DSTree.js";
+const unsecureUuid = () => "xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+  const r = Math.random() * 16 | 0;
+  const v = c == "x" ? r : r & 3 | 8;
+  return v.toString(16);
+});
+const walkTreeish = ({
+  callback,
+  node,
+  opts
+}) => {
+  callback(node);
+  const children = opts?.getChildren(node);
+  if (Array.isArray(children) && children.length > 0) {
+    for (let i = 0; i < children.length; i += 1) {
+      walkTreeish({ callback, node: children[i], opts });
+    }
+  }
+};
+const fromTreeishArrayToDSTree = (args) => {
+  const rootId = `_autogenerated-ds-pseudoRoot-${unsecureUuid()}`;
+  const { opts, treeish } = args;
+  const { getUniqueId, getChildrenKey } = opts;
+  const pseudoRoot = {
+    id: rootId,
+    subitems: structuredClone(treeish),
+    originalNodeData: {}
+  };
+  const overloadedGetChildren = (node) => node.subitems;
+  const overloadedGetUniqueId = (node) => node.id;
+  const callback = (node) => {
+    if (node.id === rootId)
+      return;
+    const originalNodeData = structuredClone(node);
+    Object.keys(node).forEach((key) => {
+      delete node[key];
+    });
+    const overloadedNode = node;
+    const childrenKey = getChildrenKey(originalNodeData);
+    overloadedNode.id = getUniqueId(originalNodeData);
+    overloadedNode.subitems = originalNodeData[childrenKey];
+    delete originalNodeData[childrenKey];
+    overloadedNode.originalNodeData = originalNodeData;
+  };
+  walkTreeish({ callback, node: pseudoRoot, opts: { getChildren: overloadedGetChildren } });
+  return new DSTree(pseudoRoot, { getUniqueId: overloadedGetUniqueId });
+};
+export {
+  fromTreeishArrayToDSTree
+};
+//# sourceMappingURL=fromTreeishArrayToDSTree.js.map