ezux 1.0.0

package/dist/components/EzTreeView/EzTreeView.types.d.ts

@@ -0,0 +1,395 @@
+import { SharedBaseProps } from '../../shared/types/BaseProps';
+import { TreeNode as SharedTreeNode } from '../../shared/types/commonTypes';
+import { IService } from '../../shared/services/ServiceRegistry';
+/**
+ * Represents a node in the tree structure.
+ * @group Models
+ */
+export interface TreeNode extends SharedTreeNode {
+}
+/**
+ * Component Injection (IoC) slots for customizing tree elements.
+ * @group Subcomponents
+ */
+export interface EzTreeViewComponents {
+    /**
+     * Custom renderer for the tree node.
+     * @param props.node The node data.
+     * @param props.level Current nesting level (0-based).
+     * @param props.isExpanded If the node is currently expanded.
+     * @param props.isSelected If the node is currently selected.
+     * @param props.isChecked If the node is checked (checkbox mode).
+     * @param props.isIndeterminate If the node is partially checked.
+     * @param props.onToggleExpand Callback to toggle expansion.
+     * @param props.onToggleSelect Callback to toggle selection.
+     * @param props.onToggleCheck Callback to toggle check state.
+     * @group Subcomponents
+     */
+    node?: React.ComponentType<{
+        node: TreeNode;
+        level: number;
+        isExpanded: boolean;
+        isSelected: boolean;
+        isChecked?: boolean;
+        isIndeterminate?: boolean;
+        onToggleExpand: () => void;
+        onToggleSelect: () => void;
+        onToggleCheck?: () => void;
+    }>;
+    /**
+     * Custom expand/collapse icon.
+     * @group Subcomponents
+     */
+    expandIcon?: React.ReactNode | React.ComponentType<{
+        isExpanded: boolean;
+        isLoading?: boolean;
+    }>;
+    /**
+     * Custom checkbox component.
+     * @group Subcomponents
+     */
+    checkbox?: React.ComponentType<{
+        checked: boolean;
+        indeterminate: boolean;
+        onChange: () => void;
+    }>;
+}
+export type EzTreeViewRef = EzTreeViewApi;
+/**
+ * Imperative API for EzTreeView.
+ * @group Methods
+ */
+export interface EzTreeViewApi {
+    /** Expand all nodes in the tree. @group Methods */
+    expandAll: () => void;
+    /** Collapse all nodes in the tree. @group Methods */
+    collapseAll: () => void;
+    /** Check all nodes (only in checkbox mode). @group Methods */
+    checkAll: () => void;
+    /** Uncheck all nodes. @group Methods */
+    uncheckAll: () => void;
+    /** Select a specific node by ID. @group Methods */
+    selectNode: (id: string) => void;
+    /** Expand or collapse a specific node. @group Methods */
+    expandNode: (id: string, expand?: boolean) => void;
+    /** Check or uncheck a specific node. @group Methods */
+    checkNode: (id: string, check?: boolean) => void;
+    /** Returns a flat list of visible nodes with their nesting level. @group Methods */
+    getFlattenedNodes: () => {
+        node: TreeNode;
+        level: number;
+    }[];
+    /** Adds new nodes to the tree at a specific target. @group Methods */
+    addNodes: (nodes: TreeNode[], target?: string, index?: number) => void;
+    /** Deletes nodes by their IDs. @group Methods */
+    removeNodes: (ids: string[]) => void;
+    /** Updates properties of an existing node. @group Methods */
+    updateNode: (id: string, updates: Partial<TreeNode>) => void;
+    /** Moves nodes to a new parent location. @group Methods */
+    moveNodes: (ids: string[], target: string, index?: number) => void;
+    /** Fetches a node object by ID. @group Methods */
+    getNode: (id: string) => TreeNode | undefined;
+    /** Returns the full tree data structure. @group Methods */
+    getTreeData: () => TreeNode[];
+    /** Scrolls and expands parents to make a node visible. @group Methods */
+    ensureVisible: (id: string) => void;
+    /** Switches a node into its editing state. @group Methods */
+    beginEdit: (id: string) => void;
+    /** Disables specified nodes. @group Methods */
+    disableNodes: (ids: string[], disable?: boolean) => void;
+    /** Enables specified nodes. @group Methods */
+    enableNodes: (ids: string[], enable?: boolean) => void;
+    /** Returns IDs of all checked nodes. @group Methods */
+    getAllCheckedNodes: () => string[];
+    /** Returns IDs of all disabled nodes. @group Methods */
+    getDisabledNodes: () => string[];
+}
+/**
+ * Service interface for tree data operations.
+ * @group Services
+ */
+export interface ITreeService extends IService {
+    /** Loads child nodes for a given parent (or root). @group Methods */
+    loadNodes(parentId?: string): Promise<TreeNode[]>;
+    /** Backend call to move a node. @group Methods */
+    moveNode(id: string, targetParentId: string, index?: number): Promise<void>;
+    /** Backend call to rename a node. @group Methods */
+    renameNode(id: string, newName: string): Promise<void>;
+    /** Backend call to delete a node. @group Methods */
+    deleteNode(id: string): Promise<void>;
+    /** Backend call to add a new node. @group Methods */
+    addNode(parentId: string, node: Partial<TreeNode>): Promise<TreeNode>;
+}
+/**
+ * Props for the EzTreeView component, extending shared base props.
+ * @group Properties
+ */
+export interface EzTreeViewProps extends SharedBaseProps {
+    /** The hierarchical tree data. @group Data */
+    data: TreeNode[];
+    /**
+     * Custom subcomponents (Slots) to override default rendering.
+     * Allows fully custom rendering of nodes, icons, and checkboxes.
+     * @group Subcomponents
+     */
+    components?: EzTreeViewComponents;
+    /**
+     * Selection mode for the tree.
+     * @group Properties
+     */
+    selectionMode?: 'single' | 'multiple';
+    /**
+     * Whether to show checkboxes for tri-state selection.
+     * @group Properties
+     */
+    showCheckboxes?: boolean;
+    /**
+     * Whether to enable inline label editing.
+     * @group Properties
+     */
+    allowEditing?: boolean;
+    /**
+     * Search term for real-time filtering and highlighting.
+     * @group Properties
+     */
+    searchTerm?: string;
+    /**
+     * Whether to allow drag-and-drop node reordering.
+     * @group Properties
+     */
+    allowDragAndDrop?: boolean;
+    /**
+     * Whether to allow selecting multiple nodes (if selectionMode is multiple).
+     * @group Properties
+     */
+    allowMultiSelection?: boolean;
+    /**
+     * Whether to allow node labels to wrap to multiple lines.
+     * @group Properties
+     */
+    allowTextWrap?: boolean;
+    /**
+     * Animation configuration for expansion/collapse.
+     * @group Properties
+     */
+    animation?: boolean | {
+        expand?: boolean;
+        collapse?: boolean;
+    };
+    /**
+     * Whether to automatically check child nodes when parent is checked.
+     * @group Properties
+     */
+    autoCheck?: boolean;
+    /**
+     * Whether to allow checking nodes that are disabled.
+     * @group Properties
+     */
+    checkDisabledChildren?: boolean;
+    /**
+     * Whether to toggle check state when a node is clicked.
+     * @group Properties
+     */
+    checkOnClick?: boolean;
+    /**
+     * List of IDs for nodes that should be checked (controlled mode).
+     * @group Properties
+     */
+    checkedNodes?: string[];
+    /**
+     * List of IDs for nodes that should be expanded (controlled mode).
+     * @group Properties
+     */
+    expandedNodes?: string[];
+    /**
+     * List of IDs for nodes that should be selected (controlled mode).
+     * @group Properties
+     */
+    selectedNodes?: string[];
+    /**
+     * Field mapping for custom data structures.
+     * @group Properties
+     */
+    fields?: {
+        id?: string;
+        text?: string;
+        children?: string;
+        hasChildren?: string;
+        expanded?: string;
+        selected?: string;
+        isChecked?: string;
+        icon?: string;
+        tooltip?: string;
+    };
+    /**
+     * Whether the full row should be navigable via keyboard.
+     * @group Properties
+     */
+    fullRowNavigable?: boolean;
+    /**
+     * Whether the full row should be triggers selection on click.
+     * @group Properties
+     */
+    fullRowSelect?: boolean;
+    /**
+     * Sorting order for tree nodes.
+     * @group Properties
+     */
+    sortOrder?: 'None' | 'Ascending' | 'Descending';
+    /**
+     * Callback triggered when selection changes.
+     * @group Events
+     */
+    onSelectionChange?: (selectedIds: string[]) => void;
+    /**
+     * Callback triggered when check states change.
+     * @group Events
+     */
+    onCheckedChange?: (checkedIds: string[]) => void;
+    /**
+     * Callback triggered when a node is expanded or collapsed.
+     * @group Events
+     */
+    onNodeExpand?: (nodeId: string, isExpanded: boolean) => void;
+    /**
+     * Callback for lazy loading children.
+     * @group Events
+     */
+    onLoadChildren?: (nodeId: string) => Promise<TreeNode[]>;
+    /**
+     * Callback triggered when a node is dropped during D&D.
+     * @group Events
+     */
+    onNodeDrop?: (dragged: TreeNode, target: TreeNode, pos: 'inside' | 'before' | 'after') => void;
+    /**
+     * Callback triggered when a node is renamed via inline editing.
+     * @group Events
+     */
+    onNodeRename?: (nodeId: string, newLabel: string) => void;
+    /**
+     * Callback triggered when an operation fails.
+     * @group Events
+     */
+    onActionFailure?: (error: Error) => void;
+    /**
+     * Callback triggered when the component is created.
+     * @group Events
+     */
+    onCreated?: () => void;
+    /**
+     * Callback triggered after data is bound to the tree.
+     * @group Events
+     */
+    onDataBound?: () => void;
+    /**
+     * Callback triggered when the data source is changed.
+     * @group Events
+     */
+    onDataSourceChanged?: () => void;
+    /**
+     * Callback triggered when the component is destroyed.
+     * @group Events
+     */
+    onDestroyed?: () => void;
+    /**
+     * Callback before rendering each node, allowing for custom logic.
+     * @group Events
+     */
+    onDrawNode?: (node: TreeNode) => void;
+    /**
+     * Callback on key press within the tree.
+     * @group Events
+     */
+    onKeyPress?: (event: React.KeyboardEvent) => void;
+    /**
+     * Callback triggered when a node is checked.
+     * @group Events
+     */
+    onNodeChecked?: (nodeId: string, isChecked: boolean) => void;
+    /**
+     * Callback triggered before checking a node (cancellable).
+     * @group Events
+     */
+    onNodeChecking?: (nodeId: string, isChecked: boolean) => boolean | void;
+    /**
+     * Callback triggered when a node is clicked.
+     * @group Events
+     */
+    onNodeClicked?: (nodeId: string) => void;
+    /**
+     * Callback triggered when a node is collapsed.
+     * @group Events
+     */
+    onNodeCollapsed?: (nodeId: string) => void;
+    /**
+     * Callback triggered before collapsing a node (cancellable).
+     * @group Events
+     */
+    onNodeCollapsing?: (nodeId: string) => boolean | void;
+    /**
+     * Callback triggered when node dragging starts (cancellable).
+     * @group Events
+     */
+    onNodeDragStart?: (event: any) => boolean | void;
+    /**
+     * Callback triggered when node dragging stops.
+     * @group Events
+     */
+    onNodeDragStop?: (event: any) => void;
+    /**
+     * Callback triggered during node dragging.
+     * @group Events
+     */
+    onNodeDragging?: (event: any) => void;
+    /**
+     * Callback triggered when a node is selected.
+     * @group Events
+     */
+    onNodeSelected?: (nodeId: string) => void;
+    /**
+     * Callback triggered before selecting a node (cancellable).
+     * @group Events
+     */
+    onNodeSelecting?: (nodeId: string) => boolean | void;
+    /**
+     * Callback triggered when a node label has been expanded.
+     * @group Events
+     */
+    onNodeExpanded?: (nodeId: string) => void;
+    /**
+     * Callback triggered before expanding a node (cancellable).
+     * @group Events
+     */
+    onNodeExpanding?: (nodeId: string) => boolean | void;
+    /**
+     * Callback triggered before entering node editing mode (cancellable).
+     * @group Events
+     */
+    onNodeEditing?: (nodeId: string) => boolean | void;
+    /**
+     * Reference to access the imperative API of the tree.
+     * @group Properties
+     */
+    apiRef?: React.RefObject<EzTreeViewApi | null>;
+    /**
+     * Advanced internal configuration options.
+     * @group Properties
+     */
+    config?: {
+        dragDropEnabled?: boolean;
+        multiSelectEnabled?: boolean;
+        virtualizationThreshold?: number;
+        collisionPolicy?: string;
+        rtl?: boolean;
+    };
+    /**
+     * Custom data service instance for the tree.
+     * @group Services
+     */
+    service?: ITreeService;
+    /**
+     * Name of the global service to use for data operations.
+     * @group Services
+     */
+    serviceName?: string;
+}

package/dist/components/EzTreeView/EzTreeViewItem.d.ts

@@ -0,0 +1,77 @@
+import { default as React } from 'react';
+import { TreeNode, EzTreeViewComponents } from './EzTreeView.types';
+/**
+ * Props for the EzTreeViewItem component.
+ * @group Properties
+ */
+interface EzTreeViewItemProps {
+    /** The node data to render. @group Data */
+    node: TreeNode;
+    /** The nesting level of the node (0-based). @group Data */
+    level: number;
+    /** Whether the node is currently expanded. @group State */
+    isExpanded: boolean;
+    /** Whether the node is currently selected. @group State */
+    isSelected: boolean;
+    /** Whether the node is checked. @group State */
+    isChecked: boolean;
+    /** Whether the node has an indeterminate check state. @group State */
+    isIndeterminate: boolean;
+    /** Whether the node is currently loading children. @group State */
+    isLoading: boolean;
+    /** Whether the node has children (visible or potentially lazy-loaded). @group Data */
+    hasChildren: boolean;
+    /** Callback to toggle expansion state. @group Events */
+    onToggleExpand: (id: string) => void;
+    /** Callback to toggle selection state. @group Events */
+    onToggleSelect: (id: string) => void;
+    /** Callback to toggle check state. @group Events */
+    onToggleCheck: (id: string) => void;
+    /** Callback triggered when the node is renamed. @group Events */
+    onRename: (id: string, newLabel: string) => void;
+    /** Whether to show checkboxes. @group Appearance */
+    showCheckboxes?: boolean;
+    /** Whether inline editing is allowed. @group Appearance */
+    allowEditing?: boolean;
+    /** Current search term for highlighting. @group Data */
+    searchTerm?: string;
+    /** Virtualized style object. @group Appearance */
+    style: React.CSSProperties;
+    /** Keyboard event handler. @group Events */
+    onKeyDown: (e: React.KeyboardEvent, id: string) => void;
+    /** Tab index for keyboard navigation. @group Properties */
+    tabIndex: number;
+    /** Whether to automatically focus this item when mounted. @group Properties */
+    autoFocus?: boolean;
+    /** Custom subcomponent slots. @group Subcomponents */
+    components?: EzTreeViewComponents;
+    /** Whether text wrapping is allowed. @group Appearance */
+    allowTextWrap?: boolean;
+    /** Animation configuration. @group Appearance */
+    animation?: boolean | {
+        expand?: boolean;
+        collapse?: boolean;
+    };
+    /** Whether to check on click. @group Properties */
+    checkOnClick?: boolean;
+    /** Whether full row selection is enabled. @group Appearance */
+    fullRowSelect?: boolean;
+    /** Whether full row navigation is enabled. @group Appearance */
+    fullRowNavigable?: boolean;
+    /** Callback triggered when the node is clicked. @group Events */
+    onNodeClicked?: (nodeId: string) => void;
+    /** Callback triggered before drawing the node. @group Events */
+    onDrawNode?: (node: TreeNode) => void;
+    /** Whether the node is currently in editing mode. @group State */
+    isEditing?: boolean;
+    /** Callback triggered when editing mode changes. @group Events */
+    onEditingChange?: (editing: boolean) => void;
+    /** Text direction. @group Appearance */
+    dir?: 'ltr' | 'rtl' | 'auto';
+}
+/**
+ * Renders a single row in the tree with support for expansion, checkbox, icons, and inline editing.
+ * @group Components
+ */
+export declare const EzTreeViewItem: React.MemoExoticComponent<({ node, level, isExpanded, isSelected, isChecked, isIndeterminate, isLoading, hasChildren, onToggleExpand, onToggleSelect, onToggleCheck, onRename, showCheckboxes, allowEditing, searchTerm, style, onKeyDown, tabIndex, autoFocus, components, allowTextWrap, animation, checkOnClick, fullRowSelect: _fullRowSelect, fullRowNavigable: _fullRowNavigable, onNodeClicked, onDrawNode, isEditing: externalIsEditing, onEditingChange, dir }: EzTreeViewItemProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/EzTreeView/EzVirtualTree.d.ts

@@ -0,0 +1,72 @@
+import { default as React } from 'react';
+import { TreeNode, EzTreeViewComponents } from './EzTreeView.types';
+/**
+ * Props for the EzVirtualTree component.
+ * @group Properties
+ */
+interface EzVirtualTreeProps {
+    /** Flattened list of visible nodes and their nesting levels. @group Data */
+    items: {
+        node: TreeNode;
+        level: number;
+    }[];
+    /** Set of IDs for currently expanded nodes. @group State */
+    expandedNodes: Set<string>;
+    /** Set of IDs for currently selected nodes. @group State */
+    selectedNodes: Set<string>;
+    /** Set of IDs for currently checked nodes. @group State */
+    checkedNodes: Set<string>;
+    /** Set of IDs for nodes in an indeterminate state. @group State */
+    indeterminateNodes: Set<string>;
+    /** Set of IDs for nodes currently loading data. @group State */
+    loadingNodes: Set<string>;
+    /** Callback to toggle expansion state of a node. @group Events */
+    onToggleExpand: (nodeId: string) => void;
+    /** Callback to toggle selection state of a node. @group Events */
+    onToggleSelect: (nodeId: string) => void;
+    /** Callback to toggle check state of a node. @group Events */
+    onToggleCheck: (nodeId: string) => void;
+    /** Callback triggered when a node label is renamed. @group Events */
+    onNodeRename: (nodeId: string, newLabel: string) => void;
+    /** Custom class name for the tree container. @group Appearance */
+    className?: string;
+    /** Text direction. @group Appearance */
+    dir?: 'ltr' | 'rtl' | 'auto';
+    /** Whether to show checkboxes. @group Appearance */
+    showCheckboxes?: boolean;
+    /** Whether inline editing is allowed. @group Appearance */
+    allowEditing?: boolean;
+    /** Current search query for highlighting. @group Data */
+    searchTerm?: string;
+    /** Custom subcomponent slots. @group Subcomponents */
+    components?: EzTreeViewComponents;
+    /** Whether text wrapping is allowed. @group Appearance */
+    allowTextWrap?: boolean;
+    /** Animation configuration. @group Appearance */
+    animation?: boolean | {
+        expand?: boolean;
+        collapse?: boolean;
+    };
+    /** Whether to check on click. @group Properties */
+    checkOnClick?: boolean;
+    /** Whether full row selection is enabled. @group Appearance */
+    fullRowSelect?: boolean;
+    /** Whether full row navigation is enabled. @group Appearance */
+    fullRowNavigable?: boolean;
+    /** Keyboard event handler for the tree. @group Events */
+    onKeyPress?: (event: React.KeyboardEvent) => void;
+    /** Callback triggered when a node is clicked. @group Events */
+    onNodeClicked?: (nodeId: string) => void;
+    /** Callback triggered before drawing a node. @group Events */
+    onDrawNode?: (node: TreeNode) => void;
+    /** ID of the node currently being edited. @group State */
+    editingNodeId: string | null;
+    /** Handler to set the editing node. @group Methods */
+    setEditingNodeId: (id: string | null) => void;
+}
+/**
+ * Internal virtualized tree renderer that handles keyboard navigation and efficient row rendering.
+ * @group Components
+ */
+export declare const EzVirtualTree: React.MemoExoticComponent<({ items, expandedNodes, selectedNodes, checkedNodes, indeterminateNodes, loadingNodes, onToggleExpand, onToggleSelect, onToggleCheck, onNodeRename, className, dir, showCheckboxes, allowEditing, searchTerm, components, allowTextWrap, animation, checkOnClick, fullRowSelect, fullRowNavigable, onKeyPress, onNodeClicked, onDrawNode, editingNodeId, setEditingNodeId, }: EzVirtualTreeProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/EzTreeView/components/EzTreeViewLoadingSpinner.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const EzTreeViewLoadingSpinner: React.FC;

package/dist/components/EzTreeView/hooks/useTreeDragDrop.d.ts

@@ -0,0 +1,31 @@
+import { DragEndEvent, DragStartEvent } from '@dnd-kit/core';
+import { TreeNode } from '../EzTreeView.types';
+interface UseTreeDragDropProps {
+    onDragEnd: (node: TreeNode, targetNode: TreeNode, position: 'before' | 'after' | 'inside') => void;
+    onDragStart?: (node: TreeNode) => void;
+}
+/**
+ * Hook for managing tree-specific drag-and-drop logic using @dnd-kit.
+ *
+ * Handles drag start, over (calculating drop position), and end events.
+ *
+ * @param props Configuration and callbacks for drag-and-drop operations.
+ * @group Hooks
+ */
+export declare const useTreeDragDrop: ({ onDragEnd, onDragStart }: UseTreeDragDropProps) => {
+    /** Sensors for dnd-kit interaction. @group Properties */
+    sensors: import('@dnd-kit/core').SensorDescriptor<import('@dnd-kit/core').SensorOptions>[];
+    /** The node currently being dragged. @group State */
+    activeNode: TreeNode | null;
+    /** The node currently being dragged over. @group State */
+    dragOverNode: TreeNode | null;
+    /** The relative drop position (before/after/inside). @group State */
+    dragPosition: "before" | "after" | "inside";
+    /** Internal handler for drag start. @group Events */
+    handleDragStart: (event: DragStartEvent) => void;
+    /** Internal handler for drag over. @group Events */
+    handleDragOver: (event: any) => void;
+    /** Internal handler for drag end. @group Events */
+    handleDragEnd: (event: DragEndEvent) => void;
+};
+export {};

package/dist/components/EzTreeView/hooks/useTreeExpansion.d.ts

@@ -0,0 +1,21 @@
+import { EzTreeViewProps, TreeNode, ITreeService } from '../EzTreeView.types';
+/**
+ * Hook for managing tree expansion state and lazy loading of child nodes.
+ *
+ * Handles optimistic updates and triggers "expanding/expanded" events.
+ *
+ * @param props Props for the EzTreeView component.
+ * @param treeData The current tree data.
+ * @param updateNode Callback to update a node's data.
+ * @param setLoadingNodes Callback to manage loading state.
+ * @param service Optional data service for lazy loading.
+ * @group Hooks
+ */
+export declare const useTreeExpansion: (props: EzTreeViewProps, treeData: TreeNode[], updateNode: (id: string, updates: Partial<TreeNode>) => void, setLoadingNodes: React.Dispatch<React.SetStateAction<Set<string>>>, service?: ITreeService | null) => {
+    /** Set of IDs for currently expanded nodes. @group State */
+    expandedNodes: Set<string>;
+    /** Manually set the set of expanded node IDs. @group Methods */
+    setInternalExpandedNodes: import('react').Dispatch<import('react').SetStateAction<Set<string>>>;
+    /** Toggle the expansion state of a specific node. @group Methods */
+    toggleExpand: (nodeId: string) => Promise<void>;
+};

package/dist/components/EzTreeView/hooks/useTreeImperative.d.ts

@@ -0,0 +1,28 @@
+import { EzTreeViewProps, TreeNode, EzTreeViewApi } from '../EzTreeView.types';
+import { HierarchyService } from '../../../shared/services/HierarchyService';
+/**
+ * Hook for building and exposing the imperative API for EzTreeView.
+ *
+ * Agregates all tree operations into a single API object and registers it with the component's ref.
+ *
+ * @param props Props for the EzTreeView component.
+ * @param treeData The current tree data.
+ * @param setTreeData Callback to update the tree data.
+ * @param expandedNodes The current expansion state.
+ * @param setExpandedNodes Callback to update expansion state.
+ * @param checkedNodes The current checked state.
+ * @param setCheckedNodes Callback to update checked state.
+ * @param setSelectedNodes Callback to update selection state.
+ * @param setIndeterminateNodes Callback to update indeterminate state.
+ * @param updateCheckState Core check state logic.
+ * @param flattenedNodes The current visible list of nodes.
+ * @param hierarchyService Service for tree structure operations.
+ * @param setEditingNodeId Callback to enter node editing mode.
+ * @param ref The ref to attach the API to.
+ * @param baseApi Optional base API methods.
+ * @group Hooks
+ */
+export declare const useTreeImperative: (props: EzTreeViewProps, treeData: TreeNode[], setTreeData: React.Dispatch<React.SetStateAction<TreeNode[]>>, expandedNodes: Set<string>, setExpandedNodes: React.Dispatch<React.SetStateAction<Set<string>>>, checkedNodes: Set<string>, setCheckedNodes: React.Dispatch<React.SetStateAction<Set<string>>>, setSelectedNodes: React.Dispatch<React.SetStateAction<Set<string>>>, setIndeterminateNodes: React.Dispatch<React.SetStateAction<Set<string>>>, updateCheckState: (id: string, check: boolean) => void, flattenedNodes: {
+    node: TreeNode;
+    level: number;
+}[], hierarchyService: HierarchyService, setEditingNodeId: (id: string | null) => void, ref: React.Ref<EzTreeViewApi>, baseApi?: any) => void;

package/dist/components/EzTreeView/hooks/useTreeSelection.d.ts

@@ -0,0 +1,31 @@
+import { EzTreeViewProps } from '../EzTreeView.types';
+import { HierarchyService } from '../../../shared/services/HierarchyService';
+/**
+ * Hook for managing tree selection (single/multiple) and tri-state check states.
+ *
+ * Handles propagation of check states to ancestors and descendants when autoCheck is enabled.
+ *
+ * @param props Props for the EzTreeView component.
+ * @param hierarchyService Service providing structural information about the tree.
+ * @group Hooks
+ */
+export declare const useTreeSelection: (props: EzTreeViewProps, hierarchyService: HierarchyService) => {
+    /** Set of IDs for currently selected nodes. @group State */
+    selectedNodes: Set<string>;
+    /** Manually set the set of selected node IDs. @group Methods */
+    setInternalSelectedNodes: import('react').Dispatch<import('react').SetStateAction<Set<string>>>;
+    /** Toggle selection state of a node. @group Methods */
+    toggleSelect: (nodeId: string) => void;
+    /** Set of IDs for currently checked nodes. @group State */
+    checkedNodes: Set<string>;
+    /** Manually set the set of checked node IDs. @group Methods */
+    setInternalCheckedNodes: import('react').Dispatch<import('react').SetStateAction<Set<string>>>;
+    /** Set of IDs for nodes with indeterminate check state. @group State */
+    indeterminateNodes: Set<string>;
+    /** Manually set the set of indeterminate node IDs. @group Methods */
+    setIndeterminateNodes: import('react').Dispatch<import('react').SetStateAction<Set<string>>>;
+    /** Toggle check state of a node. @group Methods */
+    toggleCheck: (nodeId: string) => void;
+    /** Core logic to update check state and propagate changes. @group Methods */
+    updateCheckState: (nodeId: string, isChecked: boolean) => void;
+};