@syncfusion/ej2-navigations 25.2.6 → 26.1.35-750253

package/src/treeview/treeview.d.ts

@@ -545,6 +545,7 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private isInteracted;
     private isRightClick;
     private mouseDownStatus;
+    private isDropIn;
     /**
      * Indicates whether the TreeView allows drag and drop of nodes. To drag and drop a node in
      * desktop, hold the mouse on the node, drag it to the target node and drop the node by releasing
@@ -609,6 +610,7 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * });
      * treeObj.appendTo('#tree');
      * ```
+     *
      * @default []
      */
     checkedNodes: string[];
@@ -632,6 +634,7 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * padding: 10px 0;
      * }
      * ```
+     *
      * @default ''
      */
     cssClass: string;
@@ -661,6 +664,7 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * margin-left: 100px;
      * }
      * ```
+     *
      * @default null
      */
     dragArea: HTMLElement | string;
@@ -677,6 +681,7 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * });
      * treeObj.appendTo('#tree');
      * ```
+     *
      * @default true
      */
     enableHtmlSanitizer: boolean;
@@ -704,6 +709,7 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * treeObj.appendTo('#tree');
      * </script>
      * ```
+     *
      * @default []
      */
     expandedNodes: string[];
@@ -725,6 +731,7 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * });
      * treeObj.appendTo('#tree');
      * ```
+     *
      * @default 'Auto'
      */
     expandOn: ExpandOnSettings;
@@ -790,6 +797,7 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * });
      * treeObj.appendTo('#tree');
      * ```
+     *
      * @default []
      */
     selectedNodes: string[];
@@ -826,135 +834,135 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     /**
      * Event callback that is raised while any TreeView action failed to fetch the desired results.
      *
-     * @event
+     * @event actionFailure
      */
     actionFailure: EmitType<FailureEventArgs>;
     /**
      * Event callback that is raised when the TreeView component is created successfully.
      *
-     * @event
+     * @event created
      */
     created: EmitType<Object>;
     /**
      * Event callback that is raised when data source is populated in the TreeView.
      *
-     * @event
+     * @event dataBound
      */
     dataBound: EmitType<DataBoundEventArgs>;
     /**
      * Event callback that is raised when data source is changed in the TreeView. The data source will be changed after performing some operation like
      * drag and drop, node editing, adding and removing node.
      *
-     * @event
+     * @event dataSourceChanged
      */
     dataSourceChanged: EmitType<DataSourceChangedEventArgs>;
     /**
      * Event callback that is raised before the TreeView node is appended to the TreeView element. It helps to customize specific nodes.
      *
-     * @event
+     * @event drawNode
      */
     drawNode: EmitType<DrawNodeEventArgs>;
     /**
      * Event callback that is raised when the TreeView control is destroyed successfully.
      *
-     * @event
+     * @event destroyed
      */
     destroyed: EmitType<Object>;
     /**
      * Event callback that is raised when key press is successful. It helps to customize the operations at key press.
      *
-     * @event
+     * @event keyPress
      */
     keyPress: EmitType<NodeKeyPressEventArgs>;
     /**
      * Event callback that is raised when the TreeView node is checked/unchecked successfully.
      *
-     * @event
+     * @event nodeChecked
      */
     nodeChecked: EmitType<NodeCheckEventArgs>;
     /**
      * Event callback that is raised before the TreeView node is to be checked/unchecked.
      *
-     * @event
+     * @event nodeChecking
      */
     nodeChecking: EmitType<NodeCheckEventArgs>;
     /**
      * Event callback that is raised when the TreeView node is clicked successfully.
      *
-     * @event
+     * @event nodeClicked
      */
     nodeClicked: EmitType<NodeClickEventArgs>;
     /**
      * Event callback that is raised when the TreeView node collapses successfully.
      *
-     * @event
+     * @event nodeCollapsed
      */
     nodeCollapsed: EmitType<NodeExpandEventArgs>;
     /**
      * Event callback that is raised before the TreeView node collapses.
      *
-     * @event
+     * @event nodeCollapsing
      */
     nodeCollapsing: EmitType<NodeExpandEventArgs>;
     /**
      * Event callback that is raised when the TreeView node is dragged (moved) continuously.
      *
 
-     * @event
+     * @event nodeDragging
      */
     nodeDragging: EmitType<DragAndDropEventArgs>;
     /**
      * Event callback that is raised when the TreeView node drag (move) starts.
      *
-     * @event
+     * @event nodeDragStart
      */
     nodeDragStart: EmitType<DragAndDropEventArgs>;
     /**
      * Event callback that is raised when the TreeView node drag (move) is stopped.
      *
-     * @event
+     * @event nodeDragStop
      */
     nodeDragStop: EmitType<DragAndDropEventArgs>;
     /**
      * Event callback that is raised when the TreeView node is dropped on target element successfully.
      *
-     * @event
+     * @event nodeDropped
      */
     nodeDropped: EmitType<DragAndDropEventArgs>;
     /**
      * Event callback that is raised when the TreeView node is renamed successfully.
      *
-     * @event
+     * @event nodeEdited
      */
     nodeEdited: EmitType<NodeEditEventArgs>;
     /**
      * Event callback that is raised before the TreeView node is renamed.
      *
-     * @event
+     * @event nodeEditing
      */
     nodeEditing: EmitType<NodeEditEventArgs>;
     /**
      * Event callback that is raised when the TreeView node expands successfully.
      *
-     * @event
+     * @event nodeExpanded
      */
     nodeExpanded: EmitType<NodeExpandEventArgs>;
     /**
      * Event callback that is raised before the TreeView node is to be expanded.
      *
-     * @event
+     * @event nodeExpanding
      */
     nodeExpanding: EmitType<NodeExpandEventArgs>;
     /**
      * Event callback that is raised when the TreeView node is selected/unselected successfully.
      *
-     * @event
+     * @event nodeSelected
      */
     nodeSelected: EmitType<NodeSelectEventArgs>;
     /**
      * Event callback that is raised before the TreeView node is selected/unselected.
      *
-     * @event
+     * @event nodeSelecting
      */
     nodeSelecting: EmitType<NodeSelectEventArgs>;
     constructor(options?: TreeViewModel, element?: string | HTMLElement);
@@ -1000,22 +1008,41 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private renderItems;
     /**
      * Update the checkedNodes from datasource at initial rendering
+     *
+     * @returns {void}
      */
     private updateCheckedStateFromDS;
     /**
      * To check whether the list data has sub child and to change the parent check state accordingly
+     *
+     * @param {FieldsSettingsModel} mapper - The mapper object containing field settings.
+     * @param {Object[]} checkNodes - The array of checked nodes.
+     * @returns {void}
+     * @private
      */
     private getCheckedNodeDetails;
     /**
      * Update the checkedNodes and parent state when all the child Nodes are in checkedstate at initial rendering
+     *
+     * @returns {void}
+     * @private
      */
     private updateParentCheckState;
     /**
      * Change the parent to indeterminate state whenever the child is in checked state which is not rendered in DOM
+     *
+     * @param {Object} data - The data object to check for indeterminate state.
+     * @returns {void}
+     * @private
      */
     private checkIndeterminateState;
     /**
      * Update the checkedNodes for child and subchild from datasource (hierarchical datasource) at initial rendering
+     *
+     * @param {Object[]} childItems - The array of child items to update the checked state.
+     * @param {Object} treeData - The tree data object containing field values.
+     * @returns {void}
+     * @private
      */
     private updateChildCheckState;
     private beforeNodeCreate;
@@ -1033,14 +1060,32 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private updateFieldChecked;
     /**
      * Changes the parent and child  check state while changing the checkedNodes via setmodel
+     *
+     * @param {string} node - The unique identifier of the node.
+     * @param {boolean} doCheck - A boolean value indicating whether to check or uncheck the node.
+     * @returns {void}
+     * @private
      */
     private dynamicCheckState;
     /**
      * updates the parent and child  check state while changing the checkedNodes via setmodel for listData
+     *
+     * @param {string} node - The unique identifier of the node.
+     * @param {boolean} doCheck - A boolean value indicating whether to check or uncheck the node.
+     * @returns {void}
+     * @private
      */
     private updateIndeterminate;
     /**
      * updates the parent and child  check state while changing the checkedNodes via setmodel for hierarchical data
+     *
+     * @param {Object[]} subChild - Array of child nodes
+     * @param {string} parent - Parent identifier
+     * @param {string} node - Current node identifier
+     * @param {boolean} doCheck - Boolean indicating whether to perform a check
+     * @param {string} [child] - Optional child identifier
+     * @returns {void}
+     * @private
      */
     private updateChildIndeterminate;
     private changeState;
@@ -1076,6 +1121,9 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private disableTreeNodes;
     /**
      * Sets the child Item in selectedState while rendering the child node
+     *
+     * @param {Object[]} nodes - Array of nodes
+     * @returns {void}
      */
     private setSelectionForChildNodes;
     private ensureCheckNode;
@@ -1111,11 +1159,21 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private nodeCheckingAction;
     /**
      * Update checkedNodes when UI interaction happens before the child node renders in DOM
+     *
+     * @param {Element} li - The list item element
+     * @param {boolean} [doCheck] - Optional parameter to specify whether to perform a check
+     * @returns {void}
      */
     private ensureStateChange;
     private getChildItems;
     /**
      * Update checkedNodes when UI interaction happens before the child node renders in DOM for hierarchical DS
+     *
+     * @param {Object[]} childItems - Array of child items
+     * @param {string} parent - Parent identifier
+     * @param {Element} childElement - Child DOM element
+     * @param {boolean} [doCheck] - Optional parameter to specify whether to perform a check
+     * @returns {void}
      */
     private childStateChange;
     private allCheckNode;
@@ -1222,10 +1280,20 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private setCheckedNodes;
     /**
      * Checks whether the checkedNodes entered are valid and sets the valid checkedNodes while changing via setmodel
+     *
+     * @param {string} node - The unique identifier of the node.
+     * @returns {void}
+     * @private
      */
     private setValidCheckedNode;
     /**
      * Checks whether the checkedNodes entered are valid and sets the valid checkedNodes while changing via setmodel(for hierarchical DS)
+     *
+     * @param {Object[]} childItems - The child items to check.
+     * @param {string} node - The node to set the check state for.
+     * @param {Object} [treeData] - The optional tree data.
+     * @returns {void}
+     * @private
      */
     private setChildCheckState;
     private setIndeterminate;
@@ -1241,23 +1309,28 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private getHierarchicalParentId;
     /**
      * Called internally if any of the property value changed.
-     * @param  {TreeView} newProp
-     * @param  {TreeView} oldProp
-     * @returns void
+     *
+     * @param {TreeViewModel} newProp - The new property value.
+     * @param {TreeViewModel} oldProp - The old property value.
+     * @returns {void}
      * @private
      */
     onPropertyChanged(newProp: TreeViewModel, oldProp: TreeViewModel): void;
     /**
      * Removes the component from the DOM and detaches all its related event handlers. It also removes the attributes and classes.
+     *
+     * @returns {void}
      */
     destroy(): void;
     /**
      * Adds the collection of TreeView nodes based on target and index position. If target node is not specified,
      * then the nodes are added as children of the given parentID or in the root level of TreeView.
-     * @param  { { [key: string]: Object }[] } nodes - Specifies the array of JSON data that has to be added.
+     *
+     * @param  { object } nodes - Specifies the array of JSON data that has to be added.
      * @param  { string | Element } target - Specifies ID of TreeView node/TreeView node as target element.
      * @param  { number } index - Specifies the index to place the newly added nodes in the target element.
      * @param { boolean } preventTargetExpand - If set to true, the target parent node will be prevented from auto expanding.
+     * @returns {void}
      */
     addNodes(nodes: {
         [key: string]: Object;
@@ -1266,61 +1339,81 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * Editing can also be enabled by using the `beginEdit` property, instead of clicking on the
      * TreeView node. On passing the node ID or element through this property, the edit textBox
      * will be created for the particular node thus allowing us to edit it.
+     *
      * @param  {string | Element} node - Specifies ID of TreeView node/TreeView node.
+     * @returns {void}
      */
     beginEdit(node: string | Element): void;
     /**
      * Checks all the unchecked nodes. You can also check specific nodes by passing array of unchecked nodes
      * as argument to this method.
+     *
      * @param  {string[] | Element[]} nodes - Specifies the array of TreeView nodes ID/array of TreeView node.
+     * @returns {void}
      */
     checkAll(nodes?: string[] | Element[]): void;
     /**
      * Collapses all the expanded TreeView nodes. You can collapse specific nodes by passing array of nodes as argument to this method.
      * You can also collapse all the nodes excluding the hidden nodes by setting **excludeHiddenNodes** to true. If you want to collapse
      * a specific level of nodes, set **level** as argument to collapseAll method.
+     *
      * @param  {string[] | Element[]} nodes - Specifies the array of TreeView nodes ID/ array of TreeView node.
      * @param  {number} level - TreeView nodes will collapse up to the given level.
      * @param  {boolean} excludeHiddenNodes - Whether or not to exclude hidden nodes of TreeView when collapsing all nodes.
+     * @returns {void}
      */
     collapseAll(nodes?: string[] | Element[], level?: number, excludeHiddenNodes?: boolean): void;
     /**
      * Disables the collection of nodes by passing the ID of nodes or node elements in the array.
+     *
      * @param  {string[] | Element[]} nodes - Specifies the array of TreeView nodes ID/array of TreeView nodes.
+     * @returns {void}
      */
     disableNodes(nodes: string[] | Element[]): void;
     /**
      * Enables the collection of disabled nodes by passing the ID of nodes or node elements in the array.
+     *
      * @param  {string[] | Element[]} nodes - Specifies the array of TreeView nodes ID/array of TreeView nodes.
+     * @returns {void}
      */
     enableNodes(nodes: string[] | Element[]): void;
     /**
      * Ensures visibility of the TreeView node by using node ID or node element.
      * When many TreeView nodes are present and we need to find a particular node, `ensureVisible` property
      * helps bring the node to visibility by expanding the TreeView and scrolling to the specific node.
+     *
      * @param  {string | Element} node - Specifies ID of TreeView node/TreeView nodes.
+     * @returns {void}
      */
     ensureVisible(node: string | Element): void;
     /**
      * Expands all the collapsed TreeView nodes. You can expand the specific nodes by passing the array of collapsed nodes
      * as argument to this method. You can also expand all the collapsed nodes by excluding the hidden nodes by setting
      * **excludeHiddenNodes** to true to this method. To expand a specific level of nodes, set **level** as argument to expandAll method.
+     *
      * @param  {string[] | Element[]} nodes - Specifies the array of TreeView nodes ID/array of TreeView nodes.
      * @param  {number} level - TreeView nodes will expand up to the given level.
      * @param  {boolean} excludeHiddenNodes - Whether or not to exclude hidden nodes when expanding all nodes.
+     * @returns {void}
      */
     expandAll(nodes?: string[] | Element[], level?: number, excludeHiddenNodes?: boolean): void;
     /**
      * Gets all the checked nodes including child, whether it is loaded or not.
+     *
+     * @returns {string[]} - An array of strings representing the unique identifiers of checked nodes.
      */
     getAllCheckedNodes(): string[];
     /**
-    * Gets all the disabled nodes including child, whether it is loaded or not.
-    */
+     * Gets all the disabled nodes including child, whether it is loaded or not.
+     *
+     * @returns {string[]} An array of strings representing the unique identifiers of disabled nodes.
+     */
     getDisabledNodes(): string[];
     /**
      * Gets the node's data such as id, text, parentID, selected, isChecked, and expanded by passing the node element or it's ID.
+     *
      * @param  {string | Element} node - Specifies ID of TreeView node/TreeView node.
+     * @returns {Object} - The data associated with the specified node.
      */
     getNode(node: string | Element): {
         [key: string]: Object;
@@ -1331,43 +1424,55 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
      * * If you pass the ID of TreeView node as arguments for this method then it will return the updated data source
      * of the corresponding node otherwise it will return the entire updated data source of TreeView.
      * * The updated data source also contains custom attributes if you specified in data source.
+     *
      * @param  {string | Element} node - Specifies ID of TreeView node/TreeView node.
      * @isGenericType true
+     * @returns {Object} - The tree data associated with the specified node or element.
      */
     getTreeData(node?: string | Element): {
         [key: string]: Object;
     }[];
     /**
      * Moves the collection of nodes within the same TreeView based on target or its index position.
+     *
      * @param  {string[] | Element[]} sourceNodes - Specifies the array of TreeView nodes ID/array of TreeView node.
      * @param  {string | Element} target - Specifies ID of TreeView node/TreeView node as target element.
      * @param  {number} index - Specifies the index to place the moved nodes in the target element.
      * @param { boolean } preventTargetExpand - If set to true, the target parent node will be prevented from auto expanding.
+     * @returns {void}
      */
     moveNodes(sourceNodes: string[] | Element[], target: string | Element, index: number, preventTargetExpand?: boolean): void;
     /**
      * Refreshes a particular node of the TreeView.
+     *
      * @param  {string | Element} target - Specifies the ID of TreeView node or TreeView node as target element.
-     * @param  {{ [key: string]: Object }[]} newData - Specifies the new data of TreeView node.
+     * @param  {Object[]} newData - Specifies the new data of TreeView node.
+     * @returns {void}
      */
     refreshNode(target: string | Element, newData: {
         [key: string]: Object;
     }[]): void;
     /**
      * Removes the collection of TreeView nodes by passing the array of node details as argument to this method.
+     *
      * @param  {string[] | Element[]} nodes - Specifies the array of TreeView nodes ID/array of TreeView node.
+     * @returns {void}
      */
     removeNodes(nodes: string[] | Element[]): void;
     /**
      * Replaces the text of the TreeView node with the given text.
+     *
      * @param  {string | Element} target - Specifies ID of TreeView node/TreeView node as target element.
      * @param  {string} newText - Specifies the new text of TreeView node.
+     * @returns {void}
      */
     updateNode(target: string | Element, newText: string): void;
     /**
      * Unchecks all the checked nodes. You can also uncheck the specific nodes by passing array of checked nodes
      * as argument to this method.
+     *
      * @param  {string[] | Element[]} nodes - Specifies the array of TreeView nodes ID/array of TreeView node.
+     * @returns {void}
      */
     uncheckAll(nodes?: string[] | Element[]): void;
 }