ezux 1.1.13 → 1.1.18

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

@@ -0,0 +1,4 @@
+export * from './EzTableProps';
+export * from './EzTableColumn.types';
+export * from './EzTableFilter.types';
+export * from './EzTableEdit.types';

package/dist/components/EzTable/useEzTable.d.ts

@@ -0,0 +1,17 @@
+import { EzTableProps, EzTableRef } from './EzTable.types';
+/**
+ * Main hook for EzTable that coordinates specialized sub-hooks.
+ * Centrally managed via useBaseComponent and modular sub-hooks.
+ *
+ * Responsibilities:
+ * - Data fetching and synchronization
+ * - State management (pagination, sorting, filtering)
+ * - History tracking (undo/redo)
+ * - Editing state and validation
+ * - Virtualization setup
+ *
+ * @param props - Table properties
+ * @param ref - Forwarded ref for imperative API
+ * @param extraApi - Additional imperative methods
+ */
+export declare const useEzTable: <TData extends object>(props: EzTableProps<TData>, ref?: React.Ref<EzTableRef<TData>>, extraApi?: any) => any;

package/dist/components/EzTable/utils/SizingUtils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Systemic column width calculator for EzTable.
+ * Accounts for font metrics, padding, and interactive library icons.
+ */
+export declare const calculateColWidth: (text: string, options?: {
+    fontSize?: string;
+    fontWeight?: string;
+    fontFamily?: string;
+    padding?: number;
+    hasIcons?: boolean;
+}) => number;

package/dist/components/EzTable/utils/TextMeasurer.d.ts

@@ -0,0 +1 @@
+export declare const getTextWidth: (text: string, font?: string) => number;

package/dist/components/EzTable/utils/TruncatedTooltip.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface TruncatedTooltipProps {
+    children: React.ReactNode;
+    text?: string;
+}
+export declare const TruncatedTooltip: ({ children, text }: TruncatedTooltipProps) => React.JSX.Element;
+export {};

package/dist/components/EzTable/utils/columnTypeDetector.d.ts

@@ -0,0 +1,5 @@
+export type ColumnType = 'text' | 'longtext' | 'number' | 'boolean' | 'date' | 'datetime' | 'select' | 'multiselect' | 'chart';
+/**
+ * detectColumnType - Utility to infer column type from a sample of data
+ */
+export declare function detectColumnType(values: any[]): ColumnType;

package/dist/components/EzTable/utils/filterTypeGuards.d.ts

@@ -0,0 +1,3 @@
+import { FilterGroup, FilterRule } from '../EzTable.types';
+export declare const isFilterGroup: (item: any) => item is FilterGroup;
+export declare const isFilterRule: (item: any) => item is FilterRule;

package/dist/components/EzTable/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './columnTypeDetector';

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

@@ -0,0 +1,364 @@
+import { SharedBaseProps } from '../../shared/types/BaseProps';
+import { TreeNode as SharedTreeNode } from '../../shared/types/common';
+import { IService } from '../../shared/services/ServiceRegistry';
+/**
+ * Represents a node in the tree structure.
+ * @group Models
+ */
+export interface TreeNode extends SharedTreeNode {
+}
+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[];
+    /**
+     * Component slots for custom rendering override.
+     * @group Extensibility
+     */
+    slots?: {
+        node?: React.ComponentType<unknown>;
+        expandIcon?: React.ComponentType<unknown>;
+        checkbox?: React.ComponentType<unknown>;
+        dragHandle?: React.ComponentType<unknown>;
+        [key: string]: React.ComponentType<unknown> | undefined;
+    };
+    /**
+     * Props to pass to custom slots.
+     * @group Extensibility
+     */
+    slotProps?: {
+        node?: Record<string, unknown>;
+        expandIcon?: Record<string, unknown>;
+        checkbox?: Record<string, unknown>;
+        dragHandle?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    /**
+     * 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: React.DragEvent | unknown) => boolean | void;
+    /**
+     * Callback triggered when node dragging stops.
+     * @group Events
+     */
+    onNodeDragStop?: (event: React.DragEvent | unknown) => void;
+    /**
+     * Callback triggered during node dragging.
+     * @group Events
+     */
+    onNodeDragging?: (event: React.DragEvent | unknown) => 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,89 @@
+import { default as React } from 'react';
+import { TreeNode } 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;
+    /** Slots for modular composition. @group Extensibility */
+    slots?: {
+        node?: React.ComponentType<unknown>;
+        expandIcon?: React.ComponentType<unknown>;
+        checkbox?: React.ComponentType<unknown>;
+        dragHandle?: React.ComponentType<unknown>;
+    };
+    /** Props for slots. @group Extensibility */
+    slotProps?: {
+        node?: Record<string, unknown>;
+        expandIcon?: Record<string, unknown>;
+        checkbox?: Record<string, unknown>;
+        dragHandle?: Record<string, unknown>;
+    };
+    /** 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, onToggleExpand, onToggleSelect, onToggleCheck, onRename, showCheckboxes, allowEditing, searchTerm, style, onKeyDown, tabIndex, autoFocus, slots, slotProps, allowTextWrap, animation, checkOnClick, fullRowSelect: _fullRowSelect, fullRowNavigable: _fullRowNavigable, onNodeClicked, onDrawNode, isEditing: externalIsEditing, onEditingChange, dir: _dir }: EzTreeViewItemProps) => React.JSX.Element>;
+export {};

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

@@ -0,0 +1,84 @@
+import { default as React } from 'react';
+import { TreeNode } 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;
+    /** Slots for modular composition. @group Extensibility */
+    slots?: {
+        node?: React.ComponentType<unknown>;
+        expandIcon?: React.ComponentType<unknown>;
+        checkbox?: React.ComponentType<unknown>;
+        dragHandle?: React.ComponentType<unknown>;
+    };
+    /** Props for slots. @group Extensibility */
+    slotProps?: {
+        node?: Record<string, unknown>;
+        expandIcon?: Record<string, unknown>;
+        checkbox?: Record<string, unknown>;
+        dragHandle?: Record<string, unknown>;
+    };
+    /** 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, slots, slotProps, allowTextWrap, animation, checkOnClick, fullRowSelect, fullRowNavigable, onKeyPress, onNodeClicked, onDrawNode, editingNodeId, setEditingNodeId, }: EzVirtualTreeProps) => React.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>;
+};