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

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

@@ -0,0 +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    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  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,IAAK,KAAK,OAAO,IAAI,KAAM;AACjC,QAAM,IAAI,KAAK,MAAM,IAAK,IAAI,IAAO;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;AAC5D,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;AAAQ;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;AAEA,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/adapters/arraish-tree/useArraishAsDSTree.js

@@ -0,0 +1,86 @@
+import * as React from "react";
+import { useCallback, useMemo, useState } from "react";
+import { fromDSTreeToTreeishArray } from "./fromDSTreeToTreeishArray.js";
+import { fromTreeishArrayToDSTree } from "./fromTreeishArrayToDSTree.js";
+const useArraishAsDSTree = (treeData, opts) => {
+  const tree = useMemo(
+    () => fromTreeishArrayToDSTree({
+      treeish: treeData,
+      opts
+    }),
+    [opts, treeData]
+  );
+  const [hash, setHash] = useState(tree.hash);
+  const addNode = useCallback(
+    (item, options) => {
+      const cb = (node, treecb) => {
+        options?.callback?.(node, treecb);
+        setHash(treecb.hash);
+      };
+      return tree.addNode(item, { ...options, callback: cb });
+    },
+    [tree]
+  );
+  const removeNode = useCallback(
+    (id, options) => {
+      const cb = (node, treecb) => {
+        options?.callback?.(node, treecb);
+        setHash(treecb.hash);
+      };
+      return tree.removeNode(id, { ...options, callback: cb });
+    },
+    [tree]
+  );
+  const moveNode = useCallback(
+    (id, options) => {
+      const cb = (node, treecb) => {
+        options?.callback?.(node, treecb);
+        setHash(treecb.hash);
+      };
+      return tree.moveNode(id, { ...options, callback: cb });
+    },
+    [tree]
+  );
+  const replaceNode = useCallback(
+    (id, item, options) => {
+      const cb = (node, treecb) => {
+        options?.callback?.(node, treecb);
+        setHash(treecb.hash);
+      };
+      return tree.replaceNode(id, item, { ...options, callback: cb });
+    },
+    [tree]
+  );
+  const getRestoredTree = useCallback(
+    () => fromDSTreeToTreeishArray({
+      tree,
+      opts
+    }),
+    [opts, tree]
+  );
+  return useMemo(
+    () => ({
+      hash,
+      tree,
+      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,
+      getRestoredTree
+    }),
+    [addNode, getRestoredTree, hash, moveNode, removeNode, replaceNode, tree]
+  );
+};
+export {
+  useArraishAsDSTree
+};
+//# sourceMappingURL=useArraishAsDSTree.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../scripts/build/transpile/react-shim.js", "../../../../src/adapters/arraish-tree/useArraishAsDSTree.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import { useCallback, useMemo, useState } from 'react';\nimport { fromDSTreeToTreeishArray } from './fromDSTreeToTreeishArray.js';\nimport { fromTreeishArrayToDSTree } from './fromTreeishArrayToDSTree.js';\nimport type { AddOptions, MoveOptions, MutateOptions, RemoveOptions, OverloadedItem } from '../../types.js';\n\nexport const useArraishAsDSTree = <T extends object = object>(\n  treeData: T[],\n  opts: {\n    getChildrenKey: (node: T) => keyof T;\n    getUniqueId: (node: T) => string;\n  },\n) => {\n  const tree = useMemo(\n    () =>\n      fromTreeishArrayToDSTree<T>({\n        treeish: treeData,\n        opts,\n      }),\n    [opts, treeData],\n  );\n  const [hash, setHash] = useState(tree.hash);\n\n  const addNode = useCallback(\n    (item: OverloadedItem<T>, options?: AddOptions<OverloadedItem<T>>) => {\n      const cb: AddOptions<OverloadedItem<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<OverloadedItem<T>>) => {\n      const cb: RemoveOptions<OverloadedItem<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<OverloadedItem<T>>) => {\n      const cb: MoveOptions<OverloadedItem<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: OverloadedItem<T>, options?: MutateOptions<OverloadedItem<T>>) => {\n      const cb: MutateOptions<OverloadedItem<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  const getRestoredTree = useCallback(\n    () =>\n      fromDSTreeToTreeishArray({\n        tree,\n        opts,\n      }),\n    [opts, tree],\n  );\n\n  return useMemo(\n    () => ({\n      hash,\n      tree,\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      getRestoredTree,\n    }),\n    [addNode, getRestoredTree, hash, moveNode, removeNode, replaceNode, tree],\n  );\n};\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACAvB,SAAS,aAAa,SAAS,gBAAgB;AAC/C,SAAS,gCAAgC;AACzC,SAAS,gCAAgC;AAGlC,MAAM,qBAAqB,CAChC,UACA,SAIG;AACH,QAAM,OAAO;AAAA,IACX,MACE,yBAA4B;AAAA,MAC1B,SAAS;AAAA,MACT;AAAA,IACF,CAAC;AAAA,IACH,CAAC,MAAM,QAAQ;AAAA,EACjB;AACA,QAAM,CAAC,MAAM,OAAO,IAAI,SAAS,KAAK,IAAI;AAE1C,QAAM,UAAU;AAAA,IACd,CAAC,MAAyB,YAA4C;AACpE,YAAM,KAAgD,CAAC,MAAM,WAAW;AACtE,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,YAA+C;AAC1D,YAAM,KAAmD,CAAC,MAAM,WAAW;AACzE,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,YAA6C;AACxD,YAAM,KAAiD,CAAC,MAAM,WAAW;AACvE,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,MAAyB,YAA+C;AACnF,YAAM,KAAmD,CAAC,MAAM,WAAW;AACzE,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,QAAM,kBAAkB;AAAA,IACtB,MACE,yBAAyB;AAAA,MACvB;AAAA,MACA;AAAA,IACF,CAAC;AAAA,IACH,CAAC,MAAM,IAAI;AAAA,EACb;AAEA,SAAO;AAAA,IACL,OAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,SAAS,KAAK;AAAA,MACd,SAAS,KAAK;AAAA,MACd,MAAM,KAAK;AAAA,MACX,aAAa,KAAK;AAAA,MAClB,UAAU,KAAK;AAAA,MACf,cAAc,KAAK;AAAA,MACnB,SAAS,KAAK;AAAA,MACd;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS,KAAK;AAAA,MACd,YAAY,KAAK;AAAA,MACjB;AAAA,IACF;AAAA,IACA,CAAC,SAAS,iBAAiB,MAAM,UAAU,YAAY,aAAa,IAAI;AAAA,EAC1E;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { useMemo } from "react";
+import { useArraishAsDSTree } from "../arraish-tree/useArraishAsDSTree.js";
+const useTreeviewAsDSTree = (treeData) => {
+  const opts = useMemo(
+    () => ({
+      getChildrenKey: () => "children",
+      getUniqueId: (node) => `${node.id}`
+    }),
+    []
+  );
+  return useArraishAsDSTree(treeData, opts);
+};
+export {
+  useTreeviewAsDSTree
+};
+//# sourceMappingURL=useTreeviewAsDSTree.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../scripts/build/transpile/react-shim.js", "../../../../src/adapters/treeview/useTreeviewAsDSTree.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "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"],
+  "mappings": "AAAA,YAAY,WAAW;ACAvB,SAAS,eAAe;AACxB,SAAS,0BAA0B;AAO5B,MAAM,sBAAsB,CAAwD,aAAkB;AAC3G,QAAM,OAAO;AAAA,IACX,OAAO;AAAA,MACL,gBAAgB,MAAM;AAAA,MACtB,aAAa,CAAC,SAAY,GAAG,KAAK;AAAA,IACpC;AAAA,IACA,CAAC;AAAA,EACH;AACA,SAAO,mBAAmB,UAAU,IAAI;AAC1C;",
+  "names": []
+}

package/dist/esm/index.js

@@ -0,0 +1,16 @@
+import * as React from "react";
+import { DSTree } from "./DSTree.js";
+import { useDSTree } from "./useDSTree.js";
+import { fromTreeishArrayToDSTree } from "./adapters/arraish-tree/fromTreeishArrayToDSTree.js";
+import { fromDSTreeToTreeishArray } from "./adapters/arraish-tree/fromDSTreeToTreeishArray.js";
+import { useArraishAsDSTree } from "./adapters/arraish-tree/useArraishAsDSTree.js";
+import { useTreeviewAsDSTree } from "./adapters/treeview/useTreeviewAsDSTree.js";
+export {
+  DSTree,
+  fromDSTreeToTreeishArray,
+  fromTreeishArrayToDSTree,
+  useArraishAsDSTree,
+  useDSTree,
+  useTreeviewAsDSTree
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/index.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "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"],
+  "mappings": "AAAA,YAAY,WAAW;ACEvB,SAAS,cAAc;AACvB,SAAS,iBAAiB;AAC1B,SAAS,gCAAgC;AACzC,SAAS,gCAAgC;AACzC,SAAS,0BAA0B;AACnC,SAAS,2BAA2B;",
+  "names": []
+}

package/dist/esm/package.json

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

package/dist/esm/types.js

@@ -0,0 +1,2 @@
+import * as React from "react";
+//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n"],
+  "mappings": "AAAA,YAAY,WAAW;",
+  "names": []
+}

package/dist/esm/useDSTree.js

@@ -0,0 +1,67 @@
+import * as React from "react";
+import { useCallback, useMemo, useState } from "react";
+import { DSTree } from "./DSTree.js";
+const useDSTree = (rootItem, opts) => {
+  const tree = useMemo(() => new DSTree(rootItem, opts), [opts, rootItem]);
+  const [hash, setHash] = useState(tree.hash);
+  const addNode = useCallback(
+    (item, options) => {
+      const cb = (node, treecb) => {
+        options?.callback?.(node, treecb);
+        setHash(treecb.hash);
+      };
+      return tree.addNode(item, { ...options, callback: cb });
+    },
+    [tree]
+  );
+  const removeNode = useCallback(
+    (id, options) => {
+      const cb = (node, treecb) => {
+        options?.callback?.(node, treecb);
+        setHash(treecb.hash);
+      };
+      return tree.removeNode(id, { ...options, callback: cb });
+    },
+    [tree]
+  );
+  const moveNode = useCallback(
+    (id, options) => {
+      const cb = (node, treecb) => {
+        options?.callback?.(node, treecb);
+        setHash(treecb.hash);
+      };
+      return tree.moveNode(id, { ...options, callback: cb });
+    },
+    [tree]
+  );
+  const replaceNode = 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
+  };
+};
+export {
+  useDSTree
+};
+//# sourceMappingURL=useDSTree.js.map

package/dist/esm/useDSTree.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/useDSTree.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "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"],
+  "mappings": "AAAA,YAAY,WAAW;ACAvB,SAAS,aAAa,SAAS,gBAAgB;AAC/C,SAAS,cAAc;AAGhB,MAAM,YAAY,CAAiB,UAAa,SAA+C;AACpG,QAAM,OAAO,QAAQ,MAAM,IAAI,OAAO,UAAU,IAAI,GAAG,CAAC,MAAM,QAAQ,CAAC;AACvE,QAAM,CAAC,MAAM,OAAO,IAAI,SAAS,KAAK,IAAI;AAE1C,QAAM,UAAU;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,aAAa;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,WAAW;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,cAAc;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/types/DSTree.d.ts

@@ -0,0 +1,28 @@
+import type { AddOptions, Item, MoveOptions, MutateOptions, RemoveOptions } from './types.js';
+import { Node } from './Node.js';
+export declare class DSTree<T extends Item> {
+    private root;
+    private _hash;
+    private nodes;
+    getUniqueId: (item: T) => string;
+    constructor(item: T, options: {
+        getUniqueId: (item: T) => string;
+    });
+    addNodeToNodesDictionary(node: Node<T>): void;
+    removeNodeFromNodesDictionary(node: Node<T>): void;
+    get hash(): number;
+    getRoot: () => Node<T>;
+    getNode: (id: string) => Node<T>;
+    getNodes: () => Record<string, Node<T>>;
+    walk: (callback: (node: Node<T>) => boolean) => void;
+    walkParents: (callback: (node: Node<T>) => boolean) => void;
+    findNode: (callback: (node: Node<T>) => boolean) => Node<T> | null;
+    findAllNodes: (callback: (node: Node<T>) => boolean) => Node<T>[];
+    flatten: () => Node<T>[];
+    addNode: (item: T, options?: AddOptions<T>) => Node<T>;
+    removeNode: (id: string, options?: RemoveOptions<T>) => Node<T>;
+    moveNode: (id: string, options?: MoveOptions<T>) => Node<T>;
+    replaceNode: (id: string, item: T, options?: MutateOptions<T>) => Node<T>;
+    getPath: (id: string) => Node<T>[];
+    getPathIds: (id: string) => string[];
+}

package/dist/types/Node.d.ts

@@ -0,0 +1,25 @@
+import type { Item, NodeConstructorOptions } from './types.js';
+export declare class Node<T extends Item> {
+    dsId: string;
+    plainItem: T;
+    childIndex: number;
+    depth: number;
+    parent: Node<T> | null;
+    children: Node<T>[];
+    private tree;
+    private _hash;
+    constructor(item: T, { childIndex, depth, parent, tree }: NodeConstructorOptions<T>);
+    fixChildIndexes: () => void;
+    getCleanItem: (item: T) => T;
+    get hash(): number;
+    walk: (callback: (node: Node<T>) => boolean) => void;
+    walkParents: (callback: (node: Node<T>) => boolean) => void;
+    findNode: (callback: (node: Node<T>) => boolean) => Node<T> | null;
+    findAllNodes: (callback: (node: Node<T>) => boolean) => Node<T>[];
+    flatten: () => Node<T>[];
+    getPath: (id: string) => Node<T>[];
+    getPathIds: (id: string) => string[];
+    getJson: () => T;
+    addNode: (node: Node<T>) => void;
+    removeNode: () => void;
+}

package/dist/types/adapters/arraish-tree/fromDSTreeToTreeishArray.d.ts

@@ -0,0 +1,9 @@
+import type { DSTree } from '../../DSTree.js';
+import type { OverloadedItem } from '../../types.js';
+export declare const fromDSTreeToTreeishArray: <T extends object = object>(args: {
+    tree: DSTree<OverloadedItem<T>>;
+    opts: {
+        getChildrenKey: (node: T) => keyof T;
+        getUniqueId: (node: T) => string;
+    };
+}) => T[];

package/dist/types/adapters/arraish-tree/fromTreeishArrayToDSTree.d.ts

@@ -0,0 +1,9 @@
+import { DSTree } from '../../DSTree.js';
+import type { OverloadedItem } from '../../types.js';
+export declare const fromTreeishArrayToDSTree: <T extends object = object>(args: {
+    treeish: T[];
+    opts: {
+        getChildrenKey: (node: T) => keyof T;
+        getUniqueId: (item: T) => string;
+    };
+}) => DSTree<OverloadedItem<T>>;

package/dist/types/adapters/arraish-tree/useArraishAsDSTree.d.ts

@@ -0,0 +1,22 @@
+import type { AddOptions, MoveOptions, MutateOptions, RemoveOptions, OverloadedItem } from '../../types.js';
+export declare const useArraishAsDSTree: <T extends object = object>(treeData: T[], opts: {
+    getChildrenKey: (node: T) => keyof T;
+    getUniqueId: (node: T) => string;
+}) => {
+    hash: number;
+    tree: import("../../DSTree.js").DSTree<OverloadedItem<T>>;
+    getRoot: () => import("../../Node.js").Node<OverloadedItem<T>>;
+    getNode: (id: string) => import("../../Node.js").Node<OverloadedItem<T>>;
+    walk: (callback: (node: import("../../Node.js").Node<OverloadedItem<T>>) => boolean) => void;
+    walkParents: (callback: (node: import("../../Node.js").Node<OverloadedItem<T>>) => boolean) => void;
+    findNode: (callback: (node: import("../../Node.js").Node<OverloadedItem<T>>) => boolean) => import("../../Node.js").Node<OverloadedItem<T>> | null;
+    findAllNodes: (callback: (node: import("../../Node.js").Node<OverloadedItem<T>>) => boolean) => import("../../Node.js").Node<OverloadedItem<T>>[];
+    flatten: () => import("../../Node.js").Node<OverloadedItem<T>>[];
+    addNode: (item: OverloadedItem<T>, options?: AddOptions<OverloadedItem<T>> | undefined) => import("../../Node.js").Node<OverloadedItem<T>>;
+    removeNode: (id: string, options?: RemoveOptions<OverloadedItem<T>> | undefined) => import("../../Node.js").Node<OverloadedItem<T>>;
+    moveNode: (id: string, options?: MoveOptions<OverloadedItem<T>> | undefined) => import("../../Node.js").Node<OverloadedItem<T>>;
+    replaceNode: (id: string, item: OverloadedItem<T>, options?: MutateOptions<OverloadedItem<T>> | undefined) => import("../../Node.js").Node<OverloadedItem<T>>;
+    getPath: (id: string) => import("../../Node.js").Node<OverloadedItem<T>>[];
+    getPathIds: (id: string) => string[];
+    getRestoredTree: () => T[];
+};

package/dist/types/adapters/treeview/useTreeviewAsDSTree.d.ts

@@ -0,0 +1,23 @@
+type TreeviewItem<T extends object = object> = T & {
+    id: string | number;
+    children?: TreeviewItem[];
+};
+export declare const useTreeviewAsDSTree: <T extends TreeviewItem<object> = TreeviewItem<object>>(treeData: T[]) => {
+    hash: number;
+    tree: import("../../DSTree.js").DSTree<import("../../types.js").OverloadedItem<T>>;
+    getRoot: () => import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>;
+    getNode: (id: string) => import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>;
+    walk: (callback: (node: import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>) => boolean) => void;
+    walkParents: (callback: (node: import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>) => boolean) => void;
+    findNode: (callback: (node: import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>) => boolean) => import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>> | null;
+    findAllNodes: (callback: (node: import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>) => boolean) => import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>[];
+    flatten: () => import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>[];
+    addNode: (item: import("../../types.js").OverloadedItem<T>, options?: import("../../types.js").AddOptions<import("../../types.js").OverloadedItem<T>> | undefined) => import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>;
+    removeNode: (id: string, options?: import("../../types.js").RemoveOptions<import("../../types.js").OverloadedItem<T>> | undefined) => import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>;
+    moveNode: (id: string, options?: import("../../types.js").MoveOptions<import("../../types.js").OverloadedItem<T>> | undefined) => import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>;
+    replaceNode: (id: string, item: import("../../types.js").OverloadedItem<T>, options?: import("../../types.js").MutateOptions<import("../../types.js").OverloadedItem<T>> | undefined) => import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>;
+    getPath: (id: string) => import("../../Node.js").Node<import("../../types.js").OverloadedItem<T>>[];
+    getPathIds: (id: string) => string[];
+    getRestoredTree: () => T[];
+};
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export type { Item } from './types.js';
+export type { Node } from './Node.js';
+export { DSTree } from './DSTree.js';
+export { useDSTree } from './useDSTree.js';
+export { fromTreeishArrayToDSTree } from './adapters/arraish-tree/fromTreeishArrayToDSTree.js';
+export { fromDSTreeToTreeishArray } from './adapters/arraish-tree/fromDSTreeToTreeishArray.js';
+export { useArraishAsDSTree } from './adapters/arraish-tree/useArraishAsDSTree.js';
+export { useTreeviewAsDSTree } from './adapters/treeview/useTreeviewAsDSTree.js';

package/dist/types/tests/adapters/arraish-tree/fromDSTreeToTreeishArray.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/adapters/arraish-tree/fromTreeishArrayToDSTree.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/model.read.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/model.write.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/tree.read.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/tree.write.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types.d.ts

@@ -0,0 +1,33 @@
+import type { DSTree } from './DSTree.js';
+import type { Node } from './Node.js';
+export interface Item {
+    subitems?: Item[];
+    [key: string]: unknown;
+}
+export interface NodeConstructorOptions<T extends Item> {
+    childIndex: number;
+    depth: number;
+    tree: DSTree<T>;
+    parent?: Node<T> | null;
+}
+export interface AddOptions<T extends Item> {
+    position?: number;
+    parent?: Node<T> | null;
+    callback?: (node: Node<T>, tree: DSTree<T>) => void;
+}
+export interface RemoveOptions<T extends Item> {
+    callback?: (node: Node<T>, tree: DSTree<T>) => void;
+}
+export interface MoveOptions<T extends Item> {
+    position?: number;
+    parent?: Node<T>;
+    callback?: (node: Node<T>, tree: DSTree<T>) => void;
+}
+export interface MutateOptions<T extends Item> {
+    callback?: (node: Node<T>, tree: DSTree<T>) => void;
+}
+export interface OverloadedItem<T extends object = object> extends Item {
+    id: string;
+    subitems: OverloadedItem<T>[];
+    originalNodeData: T;
+}

package/dist/types/useDSTree.d.ts

@@ -0,0 +1,19 @@
+import type { AddOptions, Item, MoveOptions, MutateOptions, RemoveOptions } from './types.js';
+export declare const useDSTree: <T extends Item>(rootItem: T, opts: {
+    getUniqueId: (item: T) => string;
+}) => {
+    hash: number;
+    getRoot: () => import("./Node.js").Node<T>;
+    getNode: (id: string) => import("./Node.js").Node<T>;
+    walk: (callback: (node: import("./Node.js").Node<T>) => boolean) => void;
+    walkParents: (callback: (node: import("./Node.js").Node<T>) => boolean) => void;
+    findNode: (callback: (node: import("./Node.js").Node<T>) => boolean) => import("./Node.js").Node<T> | null;
+    findAllNodes: (callback: (node: import("./Node.js").Node<T>) => boolean) => import("./Node.js").Node<T>[];
+    flatten: () => import("./Node.js").Node<T>[];
+    addNode: (item: T, options?: AddOptions<T> | undefined) => import("./Node.js").Node<T>;
+    removeNode: (id: string, options?: RemoveOptions<T> | undefined) => import("./Node.js").Node<T>;
+    moveNode: (id: string, options?: MoveOptions<T> | undefined) => import("./Node.js").Node<T>;
+    replaceNode: (id: string, item: T, options?: MutateOptions<T> | undefined) => import("./Node.js").Node<T>;
+    getPath: (id: string) => import("./Node.js").Node<T>[];
+    getPathIds: (id: string) => string[];
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@elliemae/ds-legacy-tree-model",
+  "version": "1.0.0-rc.1",
+  "license": "MIT",
+  "description": "ICE MT - Dimsum - Tree Model",
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/esm/index.js",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://git.elliemae.io/platform-ui/dimsum-legacy.git"
+  },
+  "engines": {
+    "pnpm": ">=6",
+    "node": ">=16"
+  },
+  "author": "ICE MT",
+  "jestSonar": {
+    "sonar56x": true,
+    "reportPath": "reports",
+    "reportFile": "tests.xml",
+    "indent": 4
+  },
+  "publishConfig": {
+    "access": "public",
+    "typeSafety": false
+  },
+  "devDependencies": {
+    "@elliemae/pui-cli": "~9.0.0-next.31",
+    "@elliemae/ds-legacy-monorepo-devops": "1.0.0-rc.1"
+  },
+  "peerDependencies": {
+    "lodash": "^4.17.21",
+    "react": "~17.0.2",
+    "react-dom": "^17.0.2"
+  },
+  "scripts": {
+    "test": "pui-cli test --passWithNoTests",
+    "lint": "node ../../../scripts/lint.mjs",
+    "eslint:fix": "eslint --ext='.js,.jsx,.test.js,.ts,.tsx' --fix --config='../../../.eslintrc.js' src/",
+    "dts": "node ../../../scripts/dts.mjs",
+    "build": "cross-env NODE_ENV=production node ../../../scripts/build/build.mjs",
+    "dev:build": "pnpm --filter {.}... build",
+    "dev:install": "pnpm --filter {.}... i --no-lockfile && pnpm run dev:build",
+    "checkDeps": "npm exec ../../util/ds-codemods -- check-missing-packages --projectFolderPath=\"./\" --ignorePackagesGlobPattern=\"\" --ignoreFilesGlobPattern=\"**/test-ables/*,**/tests/*\"",
+    "dev": "cross-env NODE_ENV=development node ../../../scripts/build/build.mjs --watch"
+  }
+}