@syncfusion/ej2-navigations 34.2.3 → 34.2.5

package/dist/global/index.d.ts

@@ -1,12 +1,3 @@
-/*!
-*  filename: index.d.ts
-*  version : 34.2.3
-*  Copyright Syncfusion Inc. 2001 - 2025. All rights reserved.
-*  Use of this code is subject to the terms of our license.
-*  A copy of the current license can be obtained at any time by e-mailing
-*  licensing@syncfusion.com. Any infringement will be prosecuted under
-*  applicable laws. 
-*/
 import * as _navigations from '@syncfusion/ej2-navigations';
 
 export declare namespace ej {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncfusion/ej2-navigations",
-  "version": "34.2.3",
+  "version": "34.2.5",
   "description": "A package of Essential JS 2 navigation components such as Tree-view, Tab, Toolbar, Context-menu, and Accordion which is used to navigate from one page to another",
   "author": "Syncfusion Inc.",
   "license": "SEE LICENSE IN license",
@@ -8,13 +8,13 @@
   "module": "./index.js",
   "es2015": "./dist/es6/ej2-navigations.es5.js",
   "dependencies": {
-    "@syncfusion/ej2-base": "~34.2.2",
+    "@syncfusion/ej2-base": "~34.2.5",
     "@syncfusion/ej2-buttons": "~34.2.2",
     "@syncfusion/ej2-data": "~34.2.2",
     "@syncfusion/ej2-inputs": "~34.2.2",
     "@syncfusion/ej2-lists": "~34.2.2",
     "@syncfusion/ej2-notifications": "~34.2.2",
-    "@syncfusion/ej2-popups": "~34.2.3"
+    "@syncfusion/ej2-popups": "~34.2.4"
   },
   "devDependencies": {},
   "keywords": [

package/src/toolbar/toolbar.d.ts

@@ -270,6 +270,8 @@ export declare class Toolbar extends Component<HTMLElement> implements INotifyPr
     private scrollEvent;
     private resizeContext;
     private orientationChangeContext;
+    private resizeObserver;
+    private lastObservedWidth;
     /**
      * Contains the keyboard configuration of the Toolbar.
      */

package/src/toolbar/toolbar.js

@@ -155,6 +155,7 @@ var Toolbar = /** @class */ (function (_super) {
         var _this = _super.call(this, options, element) || this;
         _this.resizeContext = _this.resize.bind(_this);
         _this.orientationChangeContext = _this.orientationChange.bind(_this);
+        _this.lastObservedWidth = 0;
         /**
          * Contains the keyboard configuration of the Toolbar.
          */
@@ -188,6 +189,10 @@ var Toolbar = /** @class */ (function (_super) {
             }
         });
         this.unwireEvents();
+        this.lastObservedWidth = 0;
+        if (this.resizeObserver && this.element.closest('.e-splitter')) {
+            this.resizeObserver.disconnect();
+        }
         this.tempId.forEach(function (ele) {
             if (!isNOU(_this.element.querySelector(ele))) {
                 document.body.appendChild(_this.element.querySelector(ele)).style.display = 'none';
@@ -772,6 +777,17 @@ var Toolbar = /** @class */ (function (_super) {
         this.scrollEvent = this.docEvent.bind(this);
         this.renderControl();
         this.wireEvents();
+        if (this.element.closest('.e-splitter')) {
+            this.lastObservedWidth = this.element.offsetWidth;
+            this.resizeObserver = new window.ResizeObserver(function () {
+                if (_this.element.offsetWidth === _this.lastObservedWidth) {
+                    return;
+                }
+                _this.lastObservedWidth = _this.element.offsetWidth;
+                _this.refreshOverflow();
+            });
+            this.resizeObserver.observe(this.element);
+        }
         this.renderComplete();
         if (this.isReact && this.portals && this.portals.length > 0) {
             this.renderReactTemplates(function () {

package/src/treeview/treeview.d.ts

@@ -553,54 +553,27 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private OldCheckedData;
     private isHiddenItem;
     private nodeIndex;
-    /** Flat ordered list of all currently-visible (non-collapsed) tree nodes. */
     private virtualFlatNodes;
-    /** Maps node id → index in virtualFlatNodes for O(1) lookups. */
     private virtualNodeMap;
-    /** Set of expanded node IDs for O(1) lookup performance during flattening (avoids array indexOf). */
     private virtualExpandedNodesSet;
-    /** Set of checked node IDs for O(1) lookup performance during flattening. */
     private virtualCheckedNodesSet;
-    /** Set of indeterminate node IDs — persists across flattenVisibleNodes() rebuilds. */
     private virtualIndeterminateNodesSet;
-    /** Set of selected node IDs for O(1) lookup performance during flattening. */
     private virtualSelectedNodesSet;
-    /** Row height in pixels, measured from the first rendered item or set to 40 as a default. */
     private virtualItemHeight;
-    /** Height of the scrollable container in pixels. */
     private virtualViewportHeight;
-    /** scrollTop captured during the previous scroll handler invocation. */
     private virtualPrevScrollTop;
-    /** Index of the first rendered row in the current window. */
     private virtualStartIndex;
-    /** Index one past the last rendered row in the current window. */
     private virtualEndIndex;
-    /** Extra rows rendered above and below the visible window to smooth scrolling. */
     private virtualOverscanCount;
-    /** RequestAnimationFrame handle used for throttling scroll events. */
     private virtualScrollRAF;
-    /** The `.e-mask-parent` overlay element shown during fast scroll. */
     private virtualMaskElement;
-    /** Bound scroll handler stored for later removeEventListener. */
     private virtualScrollBound;
-    /** Skeleton component instances inside the mask overlay. */
     private skeletonInstances;
-    /** Set to true whenever the flat node list must be rebuilt on next render. */
     private virtualTreeDirty;
-    /** The data-uid of the currently keyboard-focused node in virtual mode (persists across re-renders). */
     private virtualFocusedId;
-    /**
-     * Set to true by the document-level `keydown` handler when the user presses
-     * the Tab key.  The browser will auto-scroll the focused element into view
-     * immediately after focus, which fires a `scroll` event on the TreeView
-     * container.  We want to skip the re-render that the virtual scroll handler
-     * would otherwise trigger, because the element being focused is already
-     * rendered (it is the single `<li tabindex="0">` of the current window) and
-     * re-rendering would tear down the DOM element that is currently holding
-     * focus.  The flag is consumed (reset to `false`) inside `onVirtualScroll`
-     * after the auto-scroll has been handled.
-     */
     private virtualSkipNextScrollRender;
+    private filterCheckedNodes;
+    private filterIndeterminateNodes;
     /**
      * 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
@@ -1108,6 +1081,7 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private getType;
     private setRootData;
     private isChildObject;
+    private isRemoteDataLoadOnDemand;
     private renderItems;
     /**
      * Update the checkedNodes from datasource at initial rendering
@@ -1347,6 +1321,8 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private appendIndicator;
     private dropAction;
     private appendNode;
+    private virtualMoveAsSibling;
+    private virtualMoveAsChild;
     private dropAsSiblingNode;
     private dropAsChildNode;
     private moveData;
@@ -1437,223 +1413,34 @@ export declare class TreeView extends Component<HTMLElement> implements INotifyP
     private dmFailure;
     private updatePreviousText;
     private getHierarchicalParentId;
-    /**
-     * Parses the `height` property (string like '400px' or number) to a pixel value.
-     * Returns 0 if the value cannot be determined.
-     *
-     * @returns {number} Pixel height.
-     * @private
-     */
     private parseHeightToPixels;
-    /**
-     * Measures the height of the first rendered list item so subsequent calculations
-     * use real layout values.  Falls back to the stored `virtualItemHeight` default (40).
-     *
-     * @returns {number} Row height in pixels.
-     * @private
-     */
     private measureVirtualItemHeight;
-    /**
-     * Rebuilds the cached Sets for checked/selected nodes to enable O(1) lookup
-     * during the flatten operation instead of O(n) array indexOf calls.
-     *
-     * @returns {void}
-     * @private
-     */
     private rebuildVirtualCheckCache;
-    /**
-     * Recursively walks the treeData (or groupedData for flat lists) and builds
-     * `virtualFlatNodes` — an ordered list of every node that is currently visible
-     * (i.e. its ancestors are all expanded). Uses cached Sets for O(1) state lookups.
-     *
-     * @returns {VirtualNodeData[]} Ordered flat list of visible nodes.
-     * @private
-     */
     private flattenVisibleNodes;
-    /**
-     * Recursive helper for `flattenVisibleNodes`.
-     *
-     * @param {Object[]} nodes - Array of raw data objects at this level.
-     * @param {number} level - 1-based depth level.
-     * @param {string | null} parentId - The parent node id, or null for root.
-     * @param {VirtualNodeData[]} result - Accumulator array.
-     * @returns {void}
-     * @private
-     */
     private flattenNodeRecursive;
-    /**
-     * Checks whether a raw datasource node has child records.
-     *
-     * @param {Object} raw - Raw datasource object.
-     * @returns {boolean} True if children exist.
-     * @private
-     */
-    private hasChildRecords;
-    /**
-     * Rebuilds `virtualNodeMap` (id → index) from the current `virtualFlatNodes`.
-     *
-     * @returns {void}
-     * @private
-     */
     private rebuildVirtualNodeMap;
     private getVirtualWindow;
     private getVirtualWindowAt;
     private getVirtualPadding;
-    /**
-     * Renders the virtual window into a **nested** `<ul>/<li>` hierarchy identical to
-     * the non-virtualized DOM structure.
-     *
-     * ## Scroll math
-     * The flat-index ↔ pixel mapping stays unchanged: every entry in
-     * `virtualFlatNodes` represents exactly one `itemHeight` row.
-     * `paddingTop = startIndex * itemHeight` and
-     * `paddingBottom = (total - endIndex) * itemHeight` keep the scrollbar
-     * thumb in the correct position.
-     *
-     * ## Ancestor injection
-     * When `startIndex` points at a child node whose ancestor(s) have already
-     * scrolled above the viewport (their flat indices are < startIndex), the
-     * ancestors would normally be missing from the DOM, forcing the children to
-     * fall back to the root `<ul>` as flat siblings — producing wrong HTML.
-     *
-     * To fix this, before rendering the window we walk the ancestor chain of the
-     * first visible node and collect every ancestor that lies **outside** the
-     * window.  Those ancestors are injected as real `<li>` containers at the
-     * very top of the root `<ul>`.  To compensate for their presence, `paddingTop`
-     * is reduced by `injectedCount * itemHeight` so the total scroll height
-     * remains the same.
-     *
-     * Once the ancestors are in the DOM they are registered in `renderedParentMap`
-     * so the normal window-rendering loop can nest children inside them exactly
-     * as it does when both parent and child are in the same window.
-     *
-     * @returns {void}
-     * @private
-     */
     private renderVirtualItems;
-    /**
-     * Creates a single `<li>` element for the virtual window representing `node`.
-     *
-     * @param {VirtualNodeData} node - The node data.
-     * @param {boolean} _isFirst - True if this is the first rendered item (unused here but kept for potential override).
-     * @returns {HTMLElement} The constructed `<li>` element.
-     * @private
-     */
     private createVirtualListItem;
-    /**
-     * Initialises the virtual-scrolling layout:
-     * 1. Adds the `e-virtualization` CSS class and applies a fixed `height` + `overflow-y`.
-     * 2. Flattens all visible nodes into `virtualFlatNodes`.
-     * 3. Measures item height and viewport height.
-     * 4. Computes the initial window and renders it.
-     * 5. Wires the scroll event handler.
-     *
-     * @returns {void}
-     * @private
-     */
     private initVirtualization;
-    /**
-     * Wires the scroll event listener on the TreeView element.
-     *
-     * @returns {void}
-     * @private
-     */
     private wireVirtualScrollEvents;
-    /**
-     * Removes the scroll event listener previously wired by `wireVirtualScrollEvents`.
-     *
-     * @returns {void}
-     * @private
-     */
     private unwireVirtualScrollEvents;
-    /**
-     * Scroll handler for the virtual TreeView.  Throttled via `requestAnimationFrame`.
-     * Shows the loading mask during fast scrolls, re-renders the window, then hides the mask.
-     *
-     * @returns {void}
-     * @private
-     */
     private onVirtualScroll;
-    /**
-     * Creates the skeleton mask overlay used to indicate loading during fast scrolls.
-     * Skeleton instances are stored in `skeletonInstances` for later disposal.
-     *
-     * @returns {void}
-     * @private
-     */
     private createVirtualMask;
-    /**
-     * Refreshes the mask position so it always overlays the TreeView's viewport.
-     * Called on every show / scroll, since `position:fixed` is relative to the
-     * page viewport, not to the TreeView scroll container.
-     *
-     * @returns {void}
-     * @private
-     */
     private updateMaskPosition;
-    /**
-     * Destroys all skeleton instances and removes the mask overlay from the DOM.
-     *
-     * @returns {void}
-     * @private
-     */
     private destroyVirtualMask;
-    /**
-     * Positions and shows the skeleton mask at the current `scrollTop` position.
-     *
-     * @param {number} _scrollTop - Current scrollTop of the container.
-     * @returns {void}
-     * @private
-     */
     private showVirtualMask;
-    /**
-     * Hides the skeleton mask overlay after the virtual window has been rendered.
-     *
-     * @returns {void}
-     * @private
-     */
     private hideVirtualMask;
-    /**
-     * Ensures the node identified by `id` is scrolled into view inside the virtual container.
-     * If the node falls outside the rendered window, the container's `scrollTop` is adjusted so
-     * that the node becomes visible, the window is re-computed and `renderVirtualItems` is called.
-     *
-     * @param {string} id - The `data-uid` of the target node.
-     * @returns {void}
-     * @private
-     */
     private ensureVirtualNodeVisible;
-    /**
-     * Recursively walks the treeData (and any nested `childFieldName` arrays) to
-     * find the node whose `idFieldName` matches the given `id` (compared as
-     * strings).  Used by the virtual-mode expand/collapse handlers so they can
-     * locate nodes at any depth — not just the root level — before writing the
-     * `expanded` flag back to the datasource.
-     *
-     * @param {string} id - The id (as a string) of the node to locate.
-     * @returns {Object | null} The matching raw datasource node, or null if not found.
-     * @private
-     */
     private findNodeInTreeData;
+    private getNodeLevel;
     private handleVirtualExpand;
+    private loadVirtualChildData;
+    private completeVirtualExpand;
     private handleVirtualCollapse;
-    /**
-     * Updates the selected state of a node in `virtualFlatNodes` and re-renders the window.
-     *
-     * @param {string} id - The `data-uid` of the target node.
-     * @param {boolean} selected - Whether the node is now selected.
-     * @returns {void}
-     * @private
-     */
     private updateVirtualNodeSelection;
-    /**
-     * Updates the checkbox state of a node in `virtualFlatNodes` and re-renders the window.
-     *
-     * @param {string} id - The `data-uid` of the target node.
-     * @param {'check' | 'uncheck' | 'indeterminate'} state - The new check state.
-     * @returns {void}
-     * @private
-     */
     private updateVirtualNodeCheckState;
     /**
      * Called internally if any of the property value changed.