react-native-tree-multi-select 2.0.13 → 3.0.0-beta.2

package/src/helpers/moveTreeNode.helper.ts

@@ -0,0 +1,105 @@
+import type { TreeNode } from "../types/treeView.types";
+import type { DropPosition } from "../types/dragDrop.types";
+
+/**
+ * Move a node within a tree structure. Returns a new tree (no mutation).
+ *
+ * @param data - The current tree data
+ * @param draggedNodeId - The ID of the node to move
+ * @param targetNodeId - The ID of the target node
+ * @param position - Where to place relative to target: "above", "below", or "inside"
+ * @returns New tree data with the node moved, or the original data if the move is invalid
+ */
+export function moveTreeNode<ID>(
+    data: TreeNode<ID>[],
+    draggedNodeId: ID,
+    targetNodeId: ID,
+    position: DropPosition
+): TreeNode<ID>[] {
+    if (draggedNodeId === targetNodeId) return data;
+
+    // Step 1: Deep clone the tree
+    const cloned = deepCloneTree(data);
+
+    // Step 2: Remove the dragged node
+    const removedNode = removeNodeById(cloned, draggedNodeId);
+    if (!removedNode) return data;
+
+    // Step 3: Insert at the new position
+    const inserted = insertNode(cloned, removedNode, targetNodeId, position);
+    if (!inserted) return data;
+
+    return cloned;
+}
+
+function deepCloneTree<ID>(nodes: TreeNode<ID>[]): TreeNode<ID>[] {
+    return nodes.map(node => ({
+        ...node,
+        children: node.children ? deepCloneTree(node.children) : undefined,
+    }));
+}
+
+/**
+ * Remove a node by ID from the tree. Mutates the cloned tree in-place.
+ * Returns the removed node, or null if not found.
+ */
+function removeNodeById<ID>(
+    nodes: TreeNode<ID>[],
+    nodeId: ID,
+): TreeNode<ID> | null {
+    for (let i = 0; i < nodes.length; i++) {
+        if (nodes[i]!.id === nodeId) {
+            const [removed] = nodes.splice(i, 1);
+            return removed!;
+        }
+        const children = nodes[i]!.children;
+        if (children) {
+            const removed = removeNodeById(children, nodeId);
+            if (removed) {
+                // Clean up empty children arrays
+                if (children.length === 0) {
+                    nodes[i] = { ...nodes[i]!, children: undefined };
+                }
+                return removed;
+            }
+        }
+    }
+    return null;
+}
+
+/**
+ * Insert a node relative to a target node. Mutates the cloned tree in-place.
+ * Returns true if insertion was successful.
+ */
+function insertNode<ID>(
+    nodes: TreeNode<ID>[],
+    nodeToInsert: TreeNode<ID>,
+    targetId: ID,
+    position: DropPosition,
+): boolean {
+    for (let i = 0; i < nodes.length; i++) {
+        if (nodes[i]!.id === targetId) {
+            if (position === "above") {
+                nodes.splice(i, 0, nodeToInsert);
+            } else if (position === "below") {
+                nodes.splice(i + 1, 0, nodeToInsert);
+            } else {
+                // "inside" - add as first child
+                const target = nodes[i]!;
+                if (target.children) {
+                    target.children.unshift(nodeToInsert);
+                } else {
+                    nodes[i] = { ...target, children: [nodeToInsert] };
+                }
+            }
+            return true;
+        }
+        const children = nodes[i]!.children;
+        if (children) {
+            if (insertNode(children, nodeToInsert, targetId, position)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/src/helpers/toggleCheckbox.helper.ts

@@ -200,3 +200,99 @@ export function toggleCheckboxes<ID>(
     updateChecked(tempChecked);
     updateIndeterminate(tempIndeterminate);
 }
+
+/**
+ * Recalculates checked/indeterminate state for all parent nodes bottom-up.
+ * Should be called after tree structure changes (e.g., drag-drop moves) to ensure
+ * parent states correctly reflect their children's checked states.
+ */
+export function recalculateCheckedStates<ID>(storeId: string) {
+    const treeViewStore = getTreeViewStore<ID>(storeId);
+    const {
+        checked,
+        updateChecked,
+        indeterminate,
+        updateIndeterminate,
+        nodeMap,
+        childToParentMap,
+        selectionPropagation,
+    } = treeViewStore.getState();
+
+    // Only recalculate if parent propagation is enabled
+    if (!selectionPropagation.toParents) return;
+
+    const tempChecked = new Set(checked);
+    const tempIndeterminate = new Set(indeterminate);
+
+    // Collect parent nodes and clean up leaf nodes that shouldn't be indeterminate.
+    // A leaf node (no children) can never be indeterminate — this can happen when
+    // all children of a formerly-indeterminate parent are dragged away.
+    const parentNodes: ID[] = [];
+    for (const [id, node] of nodeMap) {
+        if (node.children && node.children.length > 0) {
+            parentNodes.push(id);
+        } else {
+            tempIndeterminate.delete(id);
+        }
+    }
+
+    // Sort by depth descending (deepest first) for correct bottom-up propagation
+    const nodeDepths = new Map<ID, number>();
+    function getDepth(nodeId: ID): number {
+        if (nodeDepths.has(nodeId)) return nodeDepths.get(nodeId)!;
+        let depth = 0;
+        let currentId: ID | undefined = nodeId;
+        while (currentId) {
+            const parentId = childToParentMap.get(currentId);
+            if (parentId) {
+                depth++;
+                currentId = parentId;
+            } else {
+                break;
+            }
+        }
+        nodeDepths.set(nodeId, depth);
+        return depth;
+    }
+
+    parentNodes.sort((a, b) => getDepth(b) - getDepth(a));
+
+    // Update each parent based on its children's current state
+    for (const parentId of parentNodes) {
+        const node = nodeMap.get(parentId);
+        if (!node?.children?.length) continue;
+
+        let allChecked = true;
+        let anyCheckedOrIndeterminate = false;
+
+        for (const child of node.children) {
+            const isChecked = tempChecked.has(child.id);
+            const isIndeterminate = tempIndeterminate.has(child.id);
+
+            if (isChecked) {
+                anyCheckedOrIndeterminate = true;
+            } else if (isIndeterminate) {
+                anyCheckedOrIndeterminate = true;
+                allChecked = false;
+            } else {
+                allChecked = false;
+            }
+
+            if (!allChecked && anyCheckedOrIndeterminate) break;
+        }
+
+        if (allChecked) {
+            tempChecked.add(parentId);
+            tempIndeterminate.delete(parentId);
+        } else if (anyCheckedOrIndeterminate) {
+            tempChecked.delete(parentId);
+            tempIndeterminate.add(parentId);
+        } else {
+            tempChecked.delete(parentId);
+            tempIndeterminate.delete(parentId);
+        }
+    }
+
+    updateChecked(tempChecked);
+    updateIndeterminate(tempIndeterminate);
+}