@edifice.io/react 2.0.0-develop-rc.13 → 2.0.0-develop-rc.15

package/dist/components/Tree/components/Tree.js

@@ -0,0 +1,86 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { forwardRef, createElement } from "react";
+import clsx from "clsx";
+import { useTranslation } from "react-i18next";
+import SvgIconFolder from "../../../modules/icons/components/IconFolder.js";
+import SvgIconRafterRight from "../../../modules/icons/components/IconRafterRight.js";
+import { useTree } from "../hooks/useTree.js";
+const Tree = ({
+  nodes,
+  selectedNodeId: externalSelectedNodeId,
+  showIcon = !1,
+  shouldExpandAllNodes = !1,
+  draggedNode,
+  renderNode,
+  onTreeItemFold,
+  onTreeItemUnfold,
+  onTreeItemClick
+}) => {
+  const {
+    selectedNodeId,
+    expandedNodes,
+    siblingsNodes,
+    handleItemClick,
+    handleFoldUnfold
+  } = useTree({
+    data: nodes,
+    externalSelectedNodeId,
+    draggedNode,
+    shouldExpandAllNodes,
+    onTreeItemClick,
+    onTreeItemFold,
+    onTreeItemUnfold
+  });
+  return /* @__PURE__ */ jsx("div", { className: "treeview", children: /* @__PURE__ */ jsx("ul", { role: "tree", className: "m-0 p-0", children: Array.isArray(nodes) ? nodes.map((node) => /* @__PURE__ */ jsx(TreeNode, { node, showIcon, selectedNodeId, expandedNodes, siblingsNodes, onTreeItemClick: handleItemClick, onToggleNode: handleFoldUnfold, renderNode }, node.id)) : /* @__PURE__ */ jsx(TreeNode, { node: nodes, selectedNodeId, expandedNodes, siblingsNodes, showIcon, onTreeItemClick: handleItemClick, onToggleNode: handleFoldUnfold }) }) });
+}, TreeNode = /* @__PURE__ */ forwardRef(({
+  node,
+  selectedNodeId,
+  showIcon = !1,
+  expandedNodes,
+  focused,
+  isChild,
+  renderNode,
+  onTreeItemClick,
+  onToggleNode,
+  ...restProps
+}, ref) => {
+  var _a;
+  const {
+    t
+  } = useTranslation(), selected = selectedNodeId === node.id, expanded = expandedNodes.has(node.id), treeItemClasses = {
+    action: clsx("action-container d-flex align-items-center gap-8 px-2", {
+      "drag-focus": focused,
+      "py-4": !node.section
+    }),
+    arrow: clsx({
+      "py-4": !node.section,
+      "py-8": node.section,
+      invisible: !Array.isArray(node.children) || node.children.length === 0
+    }),
+    button: clsx("flex-fill d-flex align-items-center text-truncate gap-8", {
+      "py-8": node.section
+    })
+  }, handleItemKeyDown = (event) => {
+    (event.code === "Enter" || event.code === "Space") && (event.preventDefault(), event.stopPropagation(), onTreeItemClick == null || onTreeItemClick(node.id));
+  }, handleItemToggleKeyDown = (event) => {
+    (event.code === "Enter" || event.code === "Space") && (event.preventDefault(), event.stopPropagation(), onToggleNode == null || onToggleNode(node.id));
+  };
+  return /* @__PURE__ */ createElement("li", { ...restProps, ref, key: node.id, id: `treeitem-${node.id}`, role: "treeitem", "aria-selected": selected, "aria-expanded": expanded }, /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsxs("div", { className: treeItemClasses.action, children: [
+      node.children && node.children.length > 0 ? /* @__PURE__ */ jsx("div", { className: treeItemClasses.arrow, tabIndex: 0, role: "button", onClick: () => onToggleNode == null ? void 0 : onToggleNode(node.id), onKeyDown: handleItemToggleKeyDown, "aria-label": t("foldUnfold"), children: /* @__PURE__ */ jsx(SvgIconRafterRight, { width: 16, style: {
+        transform: expanded ? "rotate(90deg)" : ""
+      } }) }) : /* @__PURE__ */ jsx("div", { className: "py-8 invisible" }),
+      node.children && showIcon ? /* @__PURE__ */ jsx(SvgIconFolder, { title: "folder", width: 20, height: 20 }) : null,
+      /* @__PURE__ */ jsx("div", { tabIndex: 0, role: "button", className: treeItemClasses.button, onClick: () => onTreeItemClick(node.id), onKeyDown: handleItemKeyDown, children: renderNode ? renderNode({
+        node,
+        hasChildren: Array.isArray(node.children) && !!node.children.length,
+        isChild
+      }) : /* @__PURE__ */ jsx("div", { className: "text-truncate", children: node.name }) })
+    ] }),
+    expanded && node.children && !!node.children.length && /* @__PURE__ */ jsx("ul", { role: "group", children: (_a = node.children) == null ? void 0 : _a.map((node2) => /* @__PURE__ */ createElement(TreeNode, { ...restProps, ref, node: node2, key: node2.id, showIcon, selectedNodeId, expandedNodes, onTreeItemClick, onToggleNode, renderNode, isChild: !0 })) })
+  ] }));
+});
+export {
+  TreeNode,
+  Tree as default
+};

package/dist/components/Tree/hooks/useTree.d.ts

@@ -0,0 +1,31 @@
+import { TreeItem } from '../types';
+export declare const useTree: ({ data, externalSelectedNodeId, draggedNode, shouldExpandAllNodes, onTreeItemUnfold, onTreeItemFold, onTreeItemClick, }: {
+    data: TreeItem | TreeItem[];
+    externalSelectedNodeId?: string | null;
+    draggedNode?: {
+        isOver: boolean;
+        overId: string | undefined;
+        isTreeview: boolean;
+    };
+    shouldExpandAllNodes?: boolean;
+    /**
+     * Callback function to provide unfolded item to parent component
+     */
+    onTreeItemUnfold?: (nodeId: string) => void;
+    /**
+     * Callback function to provide folded item to parent component
+     */
+    onTreeItemFold?: (nodeId: string) => void;
+    /**
+     * Callback function to provide selected item to parent component
+     */
+    onTreeItemClick?: (nodeId: string) => void;
+}) => {
+    selectedNodeId: string | null | undefined;
+    expandedNodes: Set<string>;
+    siblingsNodes: import('react').MutableRefObject<Set<string>>;
+    draggedNodeId: string | undefined;
+    handleItemClick: (nodeId: string) => void;
+    handleFoldUnfold: (nodeId: string) => void;
+    collapseAllNodes: () => void;
+};

package/dist/components/Tree/hooks/useTree.js

@@ -0,0 +1,87 @@
+import { useState, useRef, useEffect } from "react";
+import { findNodeById, findPathById } from "../utilities/tree.js";
+const useTree = ({
+  data,
+  externalSelectedNodeId,
+  draggedNode,
+  shouldExpandAllNodes,
+  onTreeItemUnfold,
+  onTreeItemFold,
+  onTreeItemClick
+}) => {
+  const [internalSelectedNodeId, setInternalSelectedNodeId] = useState(void 0), [expandedNodes, setExpandedNodes] = useState(/* @__PURE__ */ new Set()), siblingsNodes = useRef(/* @__PURE__ */ new Set()), [draggedNodeId, setDraggedNodeId] = useState(void 0), selectedNodeId = internalSelectedNodeId ?? externalSelectedNodeId;
+  function addNodesWithSiblingHavingChildren(data2) {
+    var _a;
+    Array.isArray(data2) ? data2.forEach((node) => {
+      const resultSet = new Set(siblingsNodes.current);
+      data2.filter(({
+        id
+      }) => id !== node.id).some((sibling) => sibling.children && sibling.children.length > 0) && resultSet.add(node.id), node.children && node.children.length > 0 && node.children.forEach((child) => {
+        var _a2;
+        const childSiblings = (_a2 = node.children) == null ? void 0 : _a2.filter(({
+          id
+        }) => id !== child.id);
+        (childSiblings == null ? void 0 : childSiblings.some((sibling) => sibling.children && sibling.children.length > 0)) && resultSet.add(child.id), addNodesWithSiblingHavingChildren(child);
+      });
+    }) : (_a = data2.children) == null || _a.forEach((child) => {
+      var _a2;
+      const resultSet = new Set(siblingsNodes.current), siblings = (_a2 = data2.children) == null ? void 0 : _a2.filter((c) => c.id !== child.id);
+      (siblings == null ? void 0 : siblings.some((sibling) => sibling.children && sibling.children.length > 0)) && (resultSet.add(child.id), siblingsNodes.current = resultSet), addNodesWithSiblingHavingChildren(child);
+    });
+  }
+  const expandAllNodes = (shouldExpandAllNodes2) => {
+    const initExpandedNodes = new Set("");
+    data && Array.isArray(data) && shouldExpandAllNodes2 && (data.forEach((node) => initExpandedNodes.add(node.id)), setExpandedNodes(initExpandedNodes));
+  };
+  useEffect(() => {
+    data && addNodesWithSiblingHavingChildren(data);
+  }, [data]), useEffect(() => {
+    draggedNode != null && draggedNode.isOver && draggedNode.isTreeview ? (draggedNode.overId && handleItemDrag(draggedNode.overId), setDraggedNodeId(draggedNode.overId)) : setDraggedNodeId(void 0);
+  }, [draggedNode]), useEffect(() => {
+    shouldExpandAllNodes && expandAllNodes(shouldExpandAllNodes);
+  }, [data, shouldExpandAllNodes]), useEffect(() => {
+    externalSelectedNodeId && !shouldExpandAllNodes ? (handleExternalSelectedNodeId(externalSelectedNodeId), setInternalSelectedNodeId(externalSelectedNodeId)) : setInternalSelectedNodeId(void 0);
+  }, [externalSelectedNodeId]);
+  const handleExternalSelectedNodeId = (nodeId) => {
+    if (!findNodeById(data, selectedNodeId)) {
+      setInternalSelectedNodeId(void 0);
+      return;
+    }
+    if (externalSelectedNodeId === "default") {
+      expandedNodes.forEach((node) => onTreeItemUnfold == null ? void 0 : onTreeItemUnfold(node));
+      return;
+    }
+    handleExpandNode(nodeId);
+  }, handleExpandNode = (nodeId) => {
+    const updatedExpandedNodes = new Set(expandedNodes), parents = findPathById(data, nodeId), arrayOrder = Array.from(updatedExpandedNodes);
+    parents.forEach((parent) => {
+      const index = arrayOrder.indexOf(parent);
+      index > -1 && arrayOrder.splice(index, 1), arrayOrder.push(parent);
+    }), updatedExpandedNodes.clear(), arrayOrder.forEach((node) => updatedExpandedNodes.add(node)), updatedExpandedNodes.forEach((node) => onTreeItemUnfold == null ? void 0 : onTreeItemUnfold(node)), setExpandedNodes(updatedExpandedNodes);
+  }, handleCollapseNode = (nodeId) => {
+    const updatedExpandedNodes = new Set(expandedNodes);
+    updatedExpandedNodes.delete(nodeId), updatedExpandedNodes.forEach((node) => onTreeItemFold == null ? void 0 : onTreeItemFold(node)), setExpandedNodes(updatedExpandedNodes);
+  }, handleToggleNode = (nodeId) => {
+    expandedNodes.has(nodeId) ? handleCollapseNode(nodeId) : handleExpandNode(nodeId);
+  }, handleSelectedItem = (nodeId) => {
+    selectedNodeId !== nodeId && setInternalSelectedNodeId(nodeId);
+  }, handleItemClick = (nodeId) => {
+    handleSelectedItem(nodeId), handleExpandNode(nodeId), onTreeItemClick == null || onTreeItemClick(nodeId);
+  }, handleFoldUnfold = (nodeId) => handleToggleNode(nodeId), handleItemDrag = (nodeId) => {
+    findNodeById(data, externalSelectedNodeId) && handleCollapseNode(nodeId);
+  };
+  return {
+    selectedNodeId,
+    expandedNodes,
+    siblingsNodes,
+    draggedNodeId,
+    handleItemClick,
+    handleFoldUnfold,
+    collapseAllNodes: () => {
+      setExpandedNodes(/* @__PURE__ */ new Set());
+    }
+  };
+};
+export {
+  useTree
+};

package/dist/components/Tree/hooks/useTreeSortable.d.ts

@@ -0,0 +1,38 @@
+import { Announcements, DragEndEvent, DragMoveEvent, DragOverEvent, DragStartEvent, MeasuringStrategy, Modifier, UniqueIdentifier } from '@dnd-kit/core';
+import { FlattenedItem, TreeItem, UpdateTreeData } from '../types';
+export declare const useTreeSortable: ({ nodes, onSortable, collapseAllNodes, }: {
+    nodes: TreeItem[];
+    onSortable: (updateArray: UpdateTreeData[]) => void;
+    collapseAllNodes: () => void;
+}) => {
+    handleDragStart: (event: DragStartEvent) => void;
+    handleDragMove: ({ delta }: DragMoveEvent) => void;
+    handleDragOver: (event: DragOverEvent) => void;
+    handleDragEnd: (event: DragEndEvent) => void;
+    adjustTranslate: Modifier;
+    sortedIds: string[];
+    indicator: boolean;
+    activationConstraint: {
+        delay: number;
+        tolerance: number;
+    };
+    projected: {
+        depth: number;
+        parentId: string | null;
+        activeId: UniqueIdentifier;
+        previousItem: FlattenedItem;
+    } | null;
+    announcements: Announcements;
+    activeId: string | null;
+    indentationWidth: number;
+    activeItem: FlattenedItem | null | undefined;
+    dropAnimationConfig: import('@dnd-kit/core/dist/components/DragOverlay/hooks/useDropAnimation').DropAnimationOptions;
+    measuring: {
+        droppable: {
+            strategy: MeasuringStrategy;
+        };
+    };
+    sensors: import('@dnd-kit/core').SensorDescriptor<import('@dnd-kit/core').SensorOptions>[];
+    items: TreeItem[];
+    flattenedTree: FlattenedItem[];
+};

package/dist/components/Tree/hooks/useTreeSortable.js

@@ -0,0 +1,202 @@
+import { MeasuringStrategy, useSensors, useSensor, PointerSensor, KeyboardSensor, defaultDropAnimation } from "@dnd-kit/core";
+import { sortableKeyboardCoordinates, arrayMove } from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import { useState, useEffect, useMemo } from "react";
+import { flattenTree, getProjection, getActiveAndOverNodes, determineNewParentId, getIndicesToUpdate, updateParentIds, buildTree, generateUpdateData } from "../utilities/tree-sortable.js";
+const useTreeSortable = ({
+  nodes,
+  onSortable,
+  collapseAllNodes
+}) => {
+  const [items, setItems] = useState(() => nodes), [activeId, setActiveId] = useState(null), [overId, setOverId] = useState(null), [offsetLeft, setOffsetLeft] = useState(0), [currentPosition, setCurrentPosition] = useState(null);
+  useEffect(() => {
+    setItems(nodes);
+  }, [nodes]);
+  const activationConstraint = {
+    delay: 200,
+    tolerance: 5
+  }, indicator = !1, indentationWidth = 64, flattenedTree = useMemo(
+    () => flattenTree(items, null),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [items]
+  ), activeItem = activeId ? flattenedTree.find(({
+    id
+  }) => id === activeId) : null, projected = activeId && overId ? getProjection(flattenedTree, activeId, overId, offsetLeft, indentationWidth) : null;
+  function handleDragStart(event) {
+    const {
+      active
+    } = event, {
+      activeNode
+    } = getActiveAndOverNodes(flattenedTree, active.id);
+    activeNode.parentId || collapseAllNodes(), setActiveId(active.id), setOverId(active.id);
+    const activeItem2 = flattenedTree.find(({
+      id
+    }) => id === activeId);
+    activeItem2 && setCurrentPosition({
+      parentId: activeItem2.parentId,
+      overId: activeId
+    });
+  }
+  function handleDragMove({
+    delta
+  }) {
+    setOffsetLeft(delta.x);
+  }
+  function handleDragOver(event) {
+    const {
+      over
+    } = event;
+    setOverId(over == null ? void 0 : over.id);
+  }
+  function handleDragEnd(event) {
+    const {
+      active,
+      over
+    } = event, {
+      activeNode,
+      activeNodeIndex,
+      overNode,
+      overNodeIndex
+    } = getActiveAndOverNodes(flattenedTree, active.id, over == null ? void 0 : over.id), newParentId = determineNewParentId(active, over, activeNode, overNode, projected), indicesToUpdate = getIndicesToUpdate(activeNode, activeNodeIndex, flattenedTree, projected);
+    updateParentIds(flattenedTree, indicesToUpdate, newParentId);
+    const updatedFlattenedTree = arrayMove(flattenedTree, activeNodeIndex, overNodeIndex), updatedTree = buildTree(updatedFlattenedTree), {
+      updateArray
+    } = generateUpdateData(updatedFlattenedTree, updatedTree);
+    setItems(updatedTree), setActiveId(null), setOverId(null), onSortable(updateArray);
+  }
+  const sortedIds = useMemo(() => flattenedTree.map(({
+    id
+  }) => id), [flattenedTree]);
+  function getMovementAnnouncement(eventName, activeId2, overId2) {
+    if (overId2 && projected) {
+      if (eventName !== "onDragEnd") {
+        if (currentPosition && projected.parentId === currentPosition.parentId && overId2 === currentPosition.overId)
+          return;
+        setCurrentPosition({
+          parentId: projected.parentId,
+          overId: overId2
+        });
+      }
+      const clonedItems = JSON.parse(JSON.stringify(flattenTree(items, null, 0))), overIndex = clonedItems.findIndex(({
+        id
+      }) => id === overId2), activeIndex = clonedItems.findIndex(({
+        id
+      }) => id === activeId2), sortedItems = arrayMove(clonedItems, activeIndex, overIndex), previousItem = sortedItems[overIndex - 1];
+      let announcement;
+      const movedVerb = eventName === "onDragEnd" ? "dropped" : "moved", nestedVerb = eventName === "onDragEnd" ? "dropped" : "nested";
+      if (previousItem)
+        if (projected.depth > previousItem.depth)
+          announcement = `${activeId2} was ${nestedVerb} under ${previousItem.id}.`;
+        else {
+          let previousSibling = previousItem;
+          for (; previousSibling && projected.depth < previousSibling.depth; ) {
+            const parentId = previousSibling.parentId;
+            previousSibling = sortedItems.find(({
+              id
+            }) => id === parentId);
+          }
+          previousSibling && (announcement = `${activeId2} was ${movedVerb} after ${previousSibling.id}.`);
+        }
+      else {
+        const nextItem = sortedItems[overIndex + 1];
+        nextItem ? announcement = `${activeId2} was ${movedVerb} before ${nextItem.id}.` : announcement = `${activeId2} was ${movedVerb} as the only item in the list.`;
+      }
+      return announcement;
+    }
+  }
+  const announcements = {
+    onDragStart({
+      active
+    }) {
+      return `Picked up ${active.id}.`;
+    },
+    onDragMove({
+      active,
+      over
+    }) {
+      return getMovementAnnouncement("onDragMove", active.id, over == null ? void 0 : over.id);
+    },
+    onDragOver({
+      active,
+      over
+    }) {
+      return getMovementAnnouncement("onDragOver", active.id, over == null ? void 0 : over.id);
+    },
+    onDragEnd({
+      active,
+      over
+    }) {
+      return getMovementAnnouncement("onDragEnd", active.id, over == null ? void 0 : over.id);
+    },
+    onDragCancel({
+      active
+    }) {
+      return `Moving was cancelled. ${active.id} was dropped in its original position.`;
+    }
+  }, dropAnimationConfig = {
+    keyframes({
+      transform
+    }) {
+      return [{
+        opacity: 1,
+        transform: CSS.Transform.toString(transform.initial)
+      }, {
+        opacity: 0,
+        transform: CSS.Transform.toString({
+          ...transform.final,
+          x: transform.final.x + 5,
+          y: transform.final.y + 5
+        })
+      }];
+    },
+    easing: "ease-out",
+    sideEffects({
+      active
+    }) {
+      active.node.animate([{
+        opacity: 0
+      }, {
+        opacity: 1
+      }], {
+        duration: defaultDropAnimation.duration,
+        easing: defaultDropAnimation.easing
+      });
+    }
+  }, adjustTranslate = ({
+    transform
+  }) => ({
+    ...transform,
+    y: transform.y - 25
+  }), measuring = {
+    droppable: {
+      strategy: MeasuringStrategy.Always
+    }
+  }, sensors = useSensors(useSensor(PointerSensor, {
+    activationConstraint
+  }), useSensor(KeyboardSensor, {
+    coordinateGetter: sortableKeyboardCoordinates
+  }));
+  return {
+    handleDragStart,
+    handleDragMove,
+    handleDragOver,
+    handleDragEnd,
+    adjustTranslate,
+    sortedIds,
+    indicator,
+    activationConstraint,
+    projected,
+    announcements,
+    activeId,
+    indentationWidth,
+    activeItem,
+    dropAnimationConfig,
+    measuring,
+    sensors,
+    items,
+    flattenedTree
+  };
+};
+export {
+  useTreeSortable
+};

package/dist/components/Tree/index.d.ts

@@ -0,0 +1,6 @@
+export { default as SortableTree } from './components/SortableTree';
+export { default as DndTree } from './components/DndTree';
+export { default as Tree } from './components/Tree';
+export * from './hooks/useTreeSortable';
+export * from './types';
+export * from './utilities/tree-sortable';

package/dist/components/Tree/types/index.d.ts

@@ -0,0 +1,170 @@
+import { UniqueIdentifier } from '@dnd-kit/core';
+import { ComponentPropsWithRef } from 'react';
+export type TreeItem = {
+    id: string;
+    name: string;
+    position?: number;
+    section?: boolean;
+    children?: TreeItem[];
+    isVisible?: boolean;
+    [index: string]: any;
+};
+export type Projected = {
+    depth: number;
+    parentId: string | null;
+    activeId: UniqueIdentifier;
+} | null;
+export interface TreeProps extends SharedTreeProps {
+    /**
+     * Tree data
+     */
+    nodes: TreeItem | TreeItem[];
+    /**
+     * Expand all nodes
+     */
+    shouldExpandAllNodes?: boolean;
+    /**
+     * Pass draggeNode when you drag an element from another context (resource / folder)
+     */
+    draggedNode?: {
+        isOver: boolean;
+        overId: string | undefined;
+        isTreeview: boolean;
+    };
+    /**
+     * Callback function to provide folded item to parent component
+     */
+    onTreeItemFold?: (nodeId: string) => void;
+    /**
+     * Callback function to provide unfolded item to parent component
+     */
+    onTreeItemUnfold?: (nodeId: string) => void;
+    /**
+     * Callback function to secondary action
+     */
+    onTreeItemAction?: (nodeId: string) => void;
+}
+export interface DndTreeProps extends TreeProps {
+    /**
+     * Pass draggeNode when you drag an element from another context (resource / folder)
+     */
+    draggedNode?: {
+        isOver: boolean;
+        overId: string | undefined;
+        isTreeview: boolean;
+    };
+}
+export interface SortableTreeProps extends TreeProps {
+    /**
+     *
+     * @param id
+     * @returns disable a specific node or the whole tree
+     * disable a specific node: (nodeId) => disabledIds.includes(nodeId)
+     * disable sorting: () => true
+     */
+    isDisabled?: (id: UniqueIdentifier) => boolean;
+    /**
+     *
+     * @param nodeId dropped node
+     * @param parentId current parentId or new parentId if move inside a new item
+     * @returns gets nodeId and parentId to update via a service
+     */
+    onSortable: (updateArray: UpdateTreeData[]) => void;
+}
+export interface SharedTreeProps {
+    /**
+     * Customize the JSX we render inside a node
+     */
+    renderNode?: (payload: {
+        node: TreeItem;
+        hasChildren?: boolean;
+        isChild?: boolean;
+    }) => React.ReactNode;
+    /**
+     * Show Section Icon
+     */
+    showIcon?: boolean;
+    /**
+     * Node ID used for synchronization
+     */
+    selectedNodeId?: string | null;
+    /**
+     * Callback function to provide selected item to parent component
+     */
+    onTreeItemClick: (nodeId: string) => void;
+}
+export interface TreeNodeProps extends ComponentPropsWithRef<"li">, SharedTreeProps {
+    /**
+     * Node data
+     */
+    node: TreeItem;
+    /**
+     * Is dragging element
+     */
+    focused?: boolean;
+    /**
+     * Use to disable sorting, check SortableTreeProps
+     */
+    disabled?: boolean;
+    /**
+     * Id of draggable node
+     */
+    draggedNodeId?: string | undefined;
+    /**
+     * Nodes expanded (opened)
+     */
+    expandedNodes: Set<string>;
+    /**
+     * Siblings nodes
+     */
+    siblingsNodes?: React.MutableRefObject<Set<string>>;
+    /**
+     * Node is a child
+     */
+    isChild?: boolean;
+    /**
+     * Function to fold / unfold node
+     */
+    onToggleNode?: (nodeId: string) => void;
+}
+export interface DndTreeNodeProps extends TreeNodeProps {
+    /**
+     * Id of draggable node
+     */
+    draggedNodeId?: string | undefined;
+}
+export interface SortableTreeNodeProps extends TreeNodeProps {
+    /**
+     * Use to disable sorting, check SortableTreeProps
+     */
+    disabled?: boolean;
+    /**
+     * Node spacing value
+     */
+    indentationWidth: number;
+    /**
+     * Depth.
+     */
+    depth: number;
+    /**
+     * Node identifier as parent or child
+     */
+    isChild?: boolean;
+    /**
+     *  Projected node before dragging it
+     */
+    projected?: Projected;
+}
+export interface FlattenedItem extends TreeItem {
+    parentId: string | null;
+    depth: number;
+}
+export interface TreeViewHandlers {
+    unselect: () => void;
+    select: (nodeId: string) => void;
+}
+export interface UpdateTreeData {
+    _id: string;
+    parentId: string;
+    position: number | null;
+}

package/dist/components/Tree/utilities/tree-sortable.d.ts

@@ -0,0 +1,29 @@
+import { Active, Over, UniqueIdentifier } from '@dnd-kit/core';
+import { FlattenedItem, Projected, TreeItem } from '../types';
+export declare function getDragDepth(offset: number, indentationWidth: number): number;
+export declare function determineNewParentId(active: Active, over: Over | null, activeNode: FlattenedItem, overNode: FlattenedItem | null, projected: Projected): string | null | undefined;
+export declare function getActiveAndOverNodes(tree: FlattenedItem[], activeId: UniqueIdentifier, overId?: UniqueIdentifier | undefined): {
+    activeNode: FlattenedItem;
+    activeNodeIndex: number;
+    overNode: FlattenedItem | null;
+    overNodeIndex: number;
+};
+export declare function getIndicesToUpdate(activeNode: FlattenedItem, activeNodeIndex: number, flattenedTree: FlattenedItem[], projected: Projected): number[];
+export declare function flattenTree(tree: TreeItem[], parentId: string | null, depth?: number): FlattenedItem[];
+export declare function updateParentIds(flattenedTree: any[], indices: number[], newParentId: string | null | undefined): void;
+export declare function findItemIndexInTree(tree: any[], itemId: string): number | null;
+export declare function generateUpdateData(updatedFlattenedTree: FlattenedItem[], tree: TreeItem[]): {
+    updateArray: {
+        _id: string;
+        position: number;
+        parentId?: string;
+    }[];
+    updatedTreeData: FlattenedItem[];
+};
+export declare const buildTree: (flatNodes: FlattenedItem[]) => TreeItem[];
+export declare function getProjection(items: FlattenedItem[], activeId: UniqueIdentifier, overId: UniqueIdentifier, dragOffset: number, indentationWidth: number): {
+    depth: number;
+    parentId: string | null;
+    activeId: UniqueIdentifier;
+    previousItem: FlattenedItem;
+};