@keenmate/svelte-treeview 5.0.0-rc07 → 5.0.0-rc08

package/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [5.0.0-rc08] - 2026-05-27
+
+### Added
+- **`{ silent: true }` option on highlight/selection methods**: `highlightNode`, `highlightNodes`, `clearHighlight`, `deselectAll` (and deprecated `selectNode`/`selectNodes`) now accept `{ silent: true }` to update state without firing `onNodeClick` / `onHighlightChange` / `onSelectionChange`. Intended for URL-restore flows (deep links loading form data from query params) where firing the change callback would re-trigger form loaders and clobber the data the URL just supplied. Silent mode also skips focusing the tree container so it doesn't steal focus from whatever the user is interacting with.
+- **Array variants on expand/collapse methods**: `expandNodes`, `collapseNodes`, `expandAll`, and `collapseAll` now accept `string | string[]`. Single emit per call regardless of array length.
+- **`{ exclusive: true }` option on `expandNodes` and `expandAll`**: Opens the target path(s) and collapses anything currently expanded that isn't on the union-of-spines (and, for `expandAll`, not under a target subtree). Equivalent to `collapseAll() + expandNodes(path)` but in a single pass with one emit — downstream listeners (transition animations, URL sync, virtualized renderers) don't see the intermediate fully-collapsed state. Non-collapsible nodes (`isCollapsible === false`) are never touched.
+- **`{ noEmit: true }` option on all four expand/collapse methods**: Skips the change emit, enabling batching multiple operations and emitting once at the end via `tree.refresh()`.
+- **`/examples/silent-highlight` demo page**: URL-restore scenario with loud vs. silent toggle showing how form data is preserved in silent mode.
+- **`/examples/expand-collapse` demo page**: Demonstrates array variants and exclusive focus mode.
+
 ## [5.0.0-rc07] - 2026-05-23
 
 ### Added

package/README.md

@@ -6,38 +6,19 @@ A high-performance, feature-rich hierarchical tree view component for Svelte 5 w
 
 Browse interactive code examples and the full API reference at **[svelte-treeview.keenmate.dev](https://svelte-treeview.keenmate.dev)**
 
+## What's New in v5.0.0-rc08
+
+- **`{ silent: true }` on highlight/selection methods**: Update tree state from URL params or other external sources without firing `onNodeClick` / `onHighlightChange` / `onSelectionChange` — perfect for deep links where you don't want the change callback to re-trigger your form loader. Applies to `highlightNode`, `highlightNodes`, `clearHighlight`, and `deselectAll`.
+- **Array variants for expand/collapse**: `expandNodes`, `collapseNodes`, `expandAll`, and `collapseAll` now take `string | string[]`. Open or close several places in one call.
+- **Exclusive focus mode**: Pass `{ exclusive: true }` to `expandNodes` / `expandAll` to open the target path and collapse everything else in a single pass — no two-step flicker compared to `collapseAll() + expandNodes(path)`.
+- **`noEmit` option for batching**: Suppress the change emit on individual expand/collapse calls when chaining several operations; emit once at the end.
+
 ## What's New in v5.0.0-rc07
 
 - **`isSelectedMember` prop**: Seed `selectedPaths` directly from your data — point the prop at a boolean field and every node where it's truthy lands pre-checked after `insertArray`.
 - **`isSelectableMember` fully wired through `Tree`**: The prop was already on the core types but wasn't reachable via the component. Now end-to-end usable to control checkbox rendering and clickability per node.
 - **Fix: filter race during async indexing**: `bind:searchText` no longer hides the entire tree if the FlexSearch index is still being built when the filter is applied. The filter now re-applies itself automatically once indexing completes, regardless of `indexerBatchSize` or dataset size.
 
-## What's New in v5.0.0-rc06
-
-- **Three-level selection**: `focusedNode` (click/arrows), `highlightedPaths` (Ctrl/Shift+click), `selectedPaths` (checkbox data state). Highlight and checkbox are independent — build a selection, then check/uncheck all at once.
-- **`clickBehavior` prop**: `'select'` | `'expand'` | `'expand-and-focus'` (default). Replaces `shouldToggleOnNodeClick`.
-- **`showCheckboxes` + `checkboxMode`**: Custom styled checkboxes with `'independent'` or `'cascade'` mode (parent toggles descendants, indeterminate state).
-- **Shift+Arrow/Home/End/PageUp/PageDown**: Extends highlight range via keyboard, like file managers.
-- **Pluggable keyboard navigation**: `TreeNavigation<T>` interface — each renderer provides its own spatial implementation. Override individual methods via `TreeNavigationOverrides<T>`.
-- **Bulk subtree operations**: `insertBranch()`, `replaceBranch()`, `deleteBranch()` on TreeController — add, replace, or remove entire subtrees with a single emission.
-- **Clipboard API**: `copyNodes()`, `cutNodes()`, `pasteNodes()`, `cancelCut()` on TreeController. Cut nodes are visually dimmed. Supports auto-handle and manual (server-driven) paste modes.
-
-### v5.0.0-rc03
-
-- **Multi-select**: Ctrl+click toggles nodes, Shift+click selects ranges, plain click replaces selection. New `selectedPaths` bindable (`Set<string>`), `onSelectionChanged` event, and `rangeSelectionMode` prop (`'visual'` vs `'logical'`).
-- **Public multi-select API**: `selectNode(path, mode)`, `selectNodes(paths)`, `deselectAll()`, `getSelectedNodes()`, `isNodeSelected(path)` on TreeController.
-- **Selection-aware context menus**: `contextMenuCallback` now receives `selectedNodes` as 3rd parameter for bulk actions.
-
-### v5.0.0-rc03
-
-- **Unified Context Menu API**: New shared type system (`ContextMenuItem`, `ContextMenuDivider`, `ContextMenuEntry`) used by both svelte-treeview and canvas-tree. Breaking: `title` → `label`, `callback` → `onclick`, `isDivider` → separate `ContextMenuDivider` type.
-- **Context menu features**: Keyboard shortcuts, nested submenus, named dividers (`──── Section ────`), `isVisible`/`isDisabled` per item, `className="danger"`, async `onclick`.
-- **Svelte context menu components**: `ContextMenuItemC` and `ContextMenuDividerC` for declarative snippet-based menus alongside the callback approach.
-- **Accordion expand**: `accordionExpand={true}` — expanding a node auto-collapses its siblings.
-- **Toggle icon mode**: `toggleIconMode="rotate"` (default) smoothly rotates the expand icon vs `"swap"` which switches between two icons.
-- **Fix**: Expand/collapse icon not updating in flat rendering mode.
-- **Fix**: `vite.config.ts` no longer requires `@types/node`.
-
 ## v5.0: Core/Renderer Split + Virtual Scroll
 
 > [!IMPORTANT]

package/dist/components/Tree.svelte

@@ -507,20 +507,32 @@
 	);
 
 	// ── Export public methods (thin proxies) ────────────────────────────
-	export async function expandNodes(nodePath: string) {
-		controller.expandNodes(nodePath);
+	export async function expandNodes(
+		nodePath: string | string[],
+		options?: { exclusive?: boolean; noEmit?: boolean }
+	) {
+		controller.expandNodes(nodePath, options);
 	}
 
-	export async function collapseNodes(nodePath: string) {
-		controller.collapseNodes(nodePath);
+	export async function collapseNodes(
+		nodePath: string | string[],
+		options?: { noEmit?: boolean }
+	) {
+		controller.collapseNodes(nodePath, options);
 	}
 
-	export function expandAll(nodePath?: string | null | undefined) {
-		controller.expandAll(nodePath);
+	export function expandAll(
+		nodePath?: string | string[] | null | undefined,
+		options?: { exclusive?: boolean; noEmit?: boolean }
+	) {
+		controller.expandAll(nodePath, options);
 	}
 
-	export function collapseAll(nodePath?: string | null | undefined) {
-		controller.collapseAll(nodePath);
+	export function collapseAll(
+		nodePath?: string | string[] | null | undefined,
+		options?: { noEmit?: boolean }
+	) {
+		controller.collapseAll(nodePath, options);
 	}
 
 	export function filterNodes(searchTextVal: string, searchOptions?: SearchOptions): void {
@@ -613,16 +625,28 @@
 	}
 
 	// Multi-select methods
-	export function selectNode(path: string, mode: 'replace' | 'toggle' | 'range' = 'replace') {
-		controller.selectNode(path, mode);
+	export function selectNode(path: string, mode: 'replace' | 'toggle' | 'range' = 'replace', options?: { silent?: boolean }) {
+		controller.selectNode(path, mode, options);
+	}
+
+	export function selectNodes(paths: string[], options?: { silent?: boolean }) {
+		controller.selectNodes(paths, options);
+	}
+
+	export function highlightNode(path: string, mode: 'replace' | 'toggle' | 'range' = 'replace', options?: { silent?: boolean }) {
+		controller.highlightNode(path, mode, options);
+	}
+
+	export function highlightNodes(paths: string[], options?: { silent?: boolean }) {
+		controller.highlightNodes(paths, options);
 	}
 
-	export function selectNodes(paths: string[]) {
-		controller.selectNodes(paths);
+	export function clearHighlight(options?: { silent?: boolean }) {
+		controller.clearHighlight(options);
 	}
 
-	export function deselectAll() {
-		controller.deselectAll();
+	export function deselectAll(options?: { silent?: boolean }) {
+		controller.deselectAll(options);
 	}
 
 	export function getSelectedNodes(): LTreeNode<T>[] {

package/dist/components/Tree.svelte.d.ts

@@ -134,10 +134,20 @@ declare function $$render<T>(): {
         navigationOverrides?: TreeNavigationOverrides<T>;
     };
     exports: {
-        expandNodes: (nodePath: string) => Promise<void>;
-        collapseNodes: (nodePath: string) => Promise<void>;
-        expandAll: (nodePath?: string | null | undefined) => void;
-        collapseAll: (nodePath?: string | null | undefined) => void;
+        expandNodes: (nodePath: string | string[], options?: {
+            exclusive?: boolean;
+            noEmit?: boolean;
+        }) => Promise<void>;
+        collapseNodes: (nodePath: string | string[], options?: {
+            noEmit?: boolean;
+        }) => Promise<void>;
+        expandAll: (nodePath?: string | string[] | null | undefined, options?: {
+            exclusive?: boolean;
+            noEmit?: boolean;
+        }) => void;
+        collapseAll: (nodePath?: string | string[] | null | undefined, options?: {
+            noEmit?: boolean;
+        }) => void;
         filterNodes: (searchTextVal: string, searchOptions?: SearchOptions) => void;
         searchNodes: (searchTextVal: string | null | undefined, searchOptions?: SearchOptions) => LTreeNode<T>[];
         getChildren: (parentPath: string) => LTreeNode<T>[];
@@ -178,9 +188,24 @@ declare function $$render<T>(): {
         setExpandedPaths: (paths: string[]) => void;
         getAllData: () => T[];
         closeContextMenu: () => void;
-        selectNode: (path: string, mode?: "replace" | "toggle" | "range") => void;
-        selectNodes: (paths: string[]) => void;
-        deselectAll: () => void;
+        selectNode: (path: string, mode?: "replace" | "toggle" | "range", options?: {
+            silent?: boolean;
+        }) => void;
+        selectNodes: (paths: string[], options?: {
+            silent?: boolean;
+        }) => void;
+        highlightNode: (path: string, mode?: "replace" | "toggle" | "range", options?: {
+            silent?: boolean;
+        }) => void;
+        highlightNodes: (paths: string[], options?: {
+            silent?: boolean;
+        }) => void;
+        clearHighlight: (options?: {
+            silent?: boolean;
+        }) => void;
+        deselectAll: (options?: {
+            silent?: boolean;
+        }) => void;
         getSelectedNodes: () => LTreeNode<T>[];
         isNodeSelected: (path: string) => boolean;
         scrollToPath: (path: string, options?: {
@@ -329,10 +354,20 @@ declare class __sveltets_Render<T> {
     slots(): ReturnType<typeof $$render<T>>['slots'];
     bindings(): "data" | "focusedNode" | "highlightedPaths" | "selectedPaths" | "searchText" | "insertResult" | "isRendering";
     exports(): {
-        expandNodes: (nodePath: string) => Promise<void>;
-        collapseNodes: (nodePath: string) => Promise<void>;
-        expandAll: (nodePath?: string | null | undefined) => void;
-        collapseAll: (nodePath?: string | null | undefined) => void;
+        expandNodes: (nodePath: string | string[], options?: {
+            exclusive?: boolean;
+            noEmit?: boolean;
+        } | undefined) => Promise<void>;
+        collapseNodes: (nodePath: string | string[], options?: {
+            noEmit?: boolean;
+        } | undefined) => Promise<void>;
+        expandAll: (nodePath?: string | string[] | null | undefined, options?: {
+            exclusive?: boolean;
+            noEmit?: boolean;
+        } | undefined) => void;
+        collapseAll: (nodePath?: string | string[] | null | undefined, options?: {
+            noEmit?: boolean;
+        } | undefined) => void;
         filterNodes: (searchTextVal: string, searchOptions?: SearchOptions) => void;
         searchNodes: (searchTextVal: string | null | undefined, searchOptions?: SearchOptions) => LTreeNode<T>[];
         getChildren: (parentPath: string) => LTreeNode<T>[];
@@ -373,9 +408,24 @@ declare class __sveltets_Render<T> {
         setExpandedPaths: (paths: string[]) => void;
         getAllData: () => T[];
         closeContextMenu: () => void;
-        selectNode: (path: string, mode?: "replace" | "toggle" | "range") => void;
-        selectNodes: (paths: string[]) => void;
-        deselectAll: () => void;
+        selectNode: (path: string, mode?: "replace" | "toggle" | "range", options?: {
+            silent?: boolean;
+        } | undefined) => void;
+        selectNodes: (paths: string[], options?: {
+            silent?: boolean;
+        } | undefined) => void;
+        highlightNode: (path: string, mode?: "replace" | "toggle" | "range", options?: {
+            silent?: boolean;
+        } | undefined) => void;
+        highlightNodes: (paths: string[], options?: {
+            silent?: boolean;
+        } | undefined) => void;
+        clearHighlight: (options?: {
+            silent?: boolean;
+        } | undefined) => void;
+        deselectAll: (options?: {
+            silent?: boolean;
+        } | undefined) => void;
         getSelectedNodes: () => LTreeNode<T>[];
         isNodeSelected: (path: string) => boolean;
         scrollToPath: (path: string, options?: {

package/dist/constants.generated.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "5.0.0-rc07";
+export declare const VERSION = "5.0.0-rc08";
 export declare const PACKAGE_NAME = "@keenmate/svelte-treeview";
 export declare const AUTHOR = "KeenMate";
 export declare const LICENSE = "MIT";

package/dist/constants.generated.js

@@ -1,6 +1,6 @@
 // Auto-generated file - do not edit manually
 // Generated by scripts/generate-constants.js
-export const VERSION = "5.0.0-rc07";
+export const VERSION = "5.0.0-rc08";
 export const PACKAGE_NAME = "@keenmate/svelte-treeview";
 export const AUTHOR = "KeenMate";
 export const LICENSE = "MIT";

package/dist/core/TreeController.svelte.d.ts

@@ -298,10 +298,20 @@ export declare class TreeController<T> {
     };
     constructor(props: TreeControllerProps<T>);
     handleVirtualScroll: (event: Event) => void;
-    expandNodes(nodePath: string): Promise<void>;
-    collapseNodes(nodePath: string): Promise<void>;
-    expandAll(nodePath?: string | null | undefined): void;
-    collapseAll(nodePath?: string | null | undefined): void;
+    expandNodes(nodePath: string | string[], options?: {
+        exclusive?: boolean;
+        noEmit?: boolean;
+    }): Promise<void>;
+    collapseNodes(nodePath: string | string[], options?: {
+        noEmit?: boolean;
+    }): Promise<void>;
+    expandAll(nodePath?: string | string[] | null | undefined, options?: {
+        exclusive?: boolean;
+        noEmit?: boolean;
+    }): void;
+    collapseAll(nodePath?: string | string[] | null | undefined, options?: {
+        noEmit?: boolean;
+    }): void;
     filterNodes(searchTextVal: string, searchOptions?: SearchOptions): void;
     searchNodes(searchTextVal: string | null | undefined, searchOptions?: SearchOptions): LTreeNode<T>[];
     getChildren(parentPath: string): LTreeNode<T>[];
@@ -441,12 +451,21 @@ export declare class TreeController<T> {
     /** Get ALL nodes between two paths (inclusive), in depth-first tree order.
      *  Includes collapsed/hidden nodes — "logical" range selection. */
     private _getAllNodesBetween;
-    /** Highlight a node with the given mode */
-    highlightNode(path: string, mode?: 'replace' | 'toggle' | 'range'): void;
-    /** Highlight multiple nodes by paths (replaces current highlights) */
-    highlightNodes(paths: string[]): void;
-    /** Clear all highlights */
-    clearHighlight(): void;
+    /** Highlight a node with the given mode.
+     *  Pass `{ silent: true }` to update state without firing `onNodeClick` / `onHighlightChange`
+     *  (useful when restoring state from URL params or other external sources). */
+    highlightNode(path: string, mode?: 'replace' | 'toggle' | 'range', options?: {
+        silent?: boolean;
+    }): void;
+    /** Highlight multiple nodes by paths (replaces current highlights).
+     *  Pass `{ silent: true }` to skip `onHighlightChange`. */
+    highlightNodes(paths: string[], options?: {
+        silent?: boolean;
+    }): void;
+    /** Clear all highlights. Pass `{ silent: true }` to skip `onHighlightChange`. */
+    clearHighlight(options?: {
+        silent?: boolean;
+    }): void;
     /** Get all highlighted nodes */
     getHighlightedNodes(): LTreeNode<T>[];
     /** Check if a specific node path is highlighted */
@@ -455,12 +474,18 @@ export declare class TreeController<T> {
     getSelectedNodes(): LTreeNode<T>[];
     /** Check if a specific node path is selected (checked) */
     isNodeSelected(path: string): boolean;
-    /** Clear all checkbox selections */
-    deselectAll(): void;
+    /** Clear all checkbox selections. Pass `{ silent: true }` to skip `onSelectionChange`. */
+    deselectAll(options?: {
+        silent?: boolean;
+    }): void;
     /** @deprecated Use highlightNode() instead */
-    selectNode(path: string, mode?: 'replace' | 'toggle' | 'range'): void;
+    selectNode(path: string, mode?: 'replace' | 'toggle' | 'range', options?: {
+        silent?: boolean;
+    }): void;
     /** @deprecated Use highlightNodes() instead */
-    selectNodes(paths: string[]): void;
+    selectNodes(paths: string[], options?: {
+        silent?: boolean;
+    }): void;
     private _onNodeRightClicked;
     private isDropAllowedByMode;
     private calculateDropPosition;

package/dist/core/TreeController.svelte.js

@@ -510,17 +510,17 @@ export class TreeController {
         });
     };
     // ── Public API methods ──────────────────────────────────────────────
-    async expandNodes(nodePath) {
-        this.tree.expandNodes(nodePath);
+    async expandNodes(nodePath, options) {
+        this.tree.expandNodes(nodePath, options);
     }
-    async collapseNodes(nodePath) {
-        this.tree.collapseNodes(nodePath);
+    async collapseNodes(nodePath, options) {
+        this.tree.collapseNodes(nodePath, options);
     }
-    expandAll(nodePath) {
-        this.tree?.expandAll(nodePath);
+    expandAll(nodePath, options) {
+        this.tree?.expandAll(nodePath, options);
     }
-    collapseAll(nodePath) {
-        this.tree?.collapseAll(nodePath);
+    collapseAll(nodePath, options) {
+        this.tree?.collapseAll(nodePath, options);
     }
     filterNodes(searchTextVal, searchOptions) {
         this.tree?.filterNodes(searchTextVal, searchOptions);
@@ -1327,12 +1327,13 @@ export class TreeController {
             this.onSelectionChangeHandler = updates.onSelectionChange;
     }
     // ── Internal event handlers ─────────────────────────────────────────
-    async _onNodeClicked(node, modifiers) {
+    async _onNodeClicked(node, modifiers, options) {
         if (this.contextMenuVisible) {
             this.closeContextMenu();
         }
         const ctrl = modifiers?.ctrl ?? false;
         const shift = modifiers?.shift ?? false;
+        const silent = options?.silent ?? false;
         uiLogger.debug(`[highlight] Click on ${node.path}`, { ctrl, shift, lastAnchor: this.lastHighlightedPath, prevCount: this.highlightedPaths.size });
         if (ctrl) {
             // Toggle this node in/out of highlight
@@ -1378,11 +1379,17 @@ export class TreeController {
         }
         // Update focus
         this._setFocusedNode(node);
-        this.onNodeClickHandler?.(node);
-        this._notifyHighlightChanged();
+        if (!silent) {
+            this.onNodeClickHandler?.(node);
+            this._notifyHighlightChanged();
+        }
         this.tree.refresh();
-        // Focus the tree container so keyboard navigation works after clicking a node
-        this.containerElement?.focus();
+        // Focus the tree container so keyboard navigation works after clicking a node.
+        // Skip in silent mode — programmatic highlight (e.g. from URL params) shouldn't
+        // steal focus from whatever the user is currently interacting with.
+        if (!silent) {
+            this.containerElement?.focus();
+        }
     }
     /** Get all descendant paths of a node (depth-first) */
     _getDescendantPaths(node) {
@@ -1648,23 +1655,26 @@ export class TreeController {
         return result;
     }
     // ── Public highlight methods (UI selection) ────────────────────────
-    /** Highlight a node with the given mode */
-    highlightNode(path, mode = 'replace') {
+    /** Highlight a node with the given mode.
+     *  Pass `{ silent: true }` to update state without firing `onNodeClick` / `onHighlightChange`
+     *  (useful when restoring state from URL params or other external sources). */
+    highlightNode(path, mode = 'replace', options) {
         const node = this.tree.getNodeByPath(path);
         if (!node)
             return;
         if (mode === 'toggle') {
-            this._onNodeClicked(node, { ctrl: true, shift: false });
+            this._onNodeClicked(node, { ctrl: true, shift: false }, options);
         }
         else if (mode === 'range') {
-            this._onNodeClicked(node, { ctrl: false, shift: true });
+            this._onNodeClicked(node, { ctrl: false, shift: true }, options);
         }
         else {
-            this._onNodeClicked(node);
+            this._onNodeClicked(node, undefined, options);
         }
     }
-    /** Highlight multiple nodes by paths (replaces current highlights) */
-    highlightNodes(paths) {
+    /** Highlight multiple nodes by paths (replaces current highlights).
+     *  Pass `{ silent: true }` to skip `onHighlightChange`. */
+    highlightNodes(paths, options) {
         this._clearAllHighlightFlags();
         const newPaths = new Set();
         let lastNode = null;
@@ -1682,15 +1692,17 @@ export class TreeController {
             this._setFocusedNode(lastNode);
             this.lastHighlightedPath = lastNode.path;
         }
-        this._notifyHighlightChanged();
+        if (!options?.silent)
+            this._notifyHighlightChanged();
         this.tree.refresh();
     }
-    /** Clear all highlights */
-    clearHighlight() {
+    /** Clear all highlights. Pass `{ silent: true }` to skip `onHighlightChange`. */
+    clearHighlight(options) {
         this._clearAllHighlightFlags();
         this.highlightedPaths = new Set();
         this.lastHighlightedPath = null;
-        this._notifyHighlightChanged();
+        if (!options?.silent)
+            this._notifyHighlightChanged();
         this.tree.refresh();
     }
     /** Get all highlighted nodes */
@@ -1722,20 +1734,21 @@ export class TreeController {
     isNodeSelected(path) {
         return this.selectedPaths.has(path);
     }
-    /** Clear all checkbox selections */
-    deselectAll() {
+    /** Clear all checkbox selections. Pass `{ silent: true }` to skip `onSelectionChange`. */
+    deselectAll(options) {
         this._clearAllSelectionFlags();
         this.selectedPaths = new Set();
-        this._notifySelectionChanged();
+        if (!options?.silent)
+            this._notifySelectionChanged();
         this.tree.refresh();
     }
     /** @deprecated Use highlightNode() instead */
-    selectNode(path, mode = 'replace') {
-        this.highlightNode(path, mode);
+    selectNode(path, mode = 'replace', options) {
+        this.highlightNode(path, mode, options);
     }
     /** @deprecated Use highlightNodes() instead */
-    selectNodes(paths) {
-        this.highlightNodes(paths);
+    selectNodes(paths, options) {
+        this.highlightNodes(paths, options);
     }
     _onNodeRightClicked(node, event) {
         if (!this.hasContextMenuSnippet && !this.getContextMenuItemsHandler) {

package/dist/ltree/ltree.svelte.js

@@ -437,28 +437,89 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             this.isFiltered = false;
             this._emitTreeChanged();
         },
-        expandAll(nodePath) {
+        expandAll(nodePath, options) {
             perfStart(`[${_treeId}] expandAll`);
+            const self = this;
+            const exclusive = options?.exclusive ?? false;
+            const noEmit = options?.noEmit ?? false;
             function setExpandedRecursive(node, value) {
                 node.isExpanded = value;
                 for (const key in node.children) {
                     setExpandedRecursive(node.children[key], value);
                 }
             }
-            if (isEmptyString(nodePath)) {
+            const paths = Array.isArray(nodePath)
+                ? nodePath.filter((p) => !isEmptyString(p))
+                : isEmptyString(nodePath)
+                    ? []
+                    : [nodePath];
+            if (paths.length === 0) {
+                // Whole-tree expand. exclusive has no meaning (nothing to exclude from).
                 setExpandedRecursive(root, true);
             }
             else {
-                const target = this.getNodeByPath(nodePath);
-                if (target)
-                    setExpandedRecursive(target, true);
+                if (exclusive) {
+                    // Build spine: every ancestor path of every target must stay expanded
+                    // so the target subtree is reachable.
+                    const spineSet = new Set();
+                    for (const p of paths) {
+                        const segs = p.split(this.treePathSeparator);
+                        for (let i = 0; i < segs.length; i++) {
+                            spineSet.add(segs.slice(0, i + 1).join(this.treePathSeparator));
+                        }
+                    }
+                    const isUnderTarget = (path) => {
+                        for (const tp of paths) {
+                            if (path === tp || path.startsWith(tp + this.treePathSeparator))
+                                return true;
+                        }
+                        return false;
+                    };
+                    // Walk currently-expanded subtree; collapse anything not on a spine
+                    // and not under a target. Only descends into expanded branches.
+                    const trim = (node) => {
+                        for (const key in node.children) {
+                            const child = node.children[key];
+                            if (!child.isExpanded)
+                                continue;
+                            if (spineSet.has(child.path) || isUnderTarget(child.path)) {
+                                trim(child);
+                            }
+                            else if (self.getNodeIsCollapsible(child)) {
+                                child.isExpanded = false;
+                                trim(child);
+                            }
+                        }
+                    };
+                    trim(root);
+                }
+                // Expand spine + entire subtree under each target.
+                for (const p of paths) {
+                    let node = root;
+                    const segments = p.split(this.treePathSeparator);
+                    for (let i = 0; i < segments.length; i++) {
+                        const segment = segmentPrefix + segments[i];
+                        if (node && node.children.hasOwnProperty(segment)) {
+                            node = node.children[segment];
+                            node.isExpanded = true;
+                        }
+                        else {
+                            node = undefined;
+                            break;
+                        }
+                    }
+                    if (node)
+                        setExpandedRecursive(node, true);
+                }
             }
-            this._emitTreeChanged();
+            if (!noEmit)
+                this._emitTreeChanged();
             perfEnd(`[${_treeId}] expandAll`);
         },
-        collapseAll(nodePath) {
+        collapseAll(nodePath, options) {
             perfStart(`[${_treeId}] collapseAll`);
             const self = this;
+            const noEmit = options?.noEmit ?? false;
             function collapseRecursive(node) {
                 if (node.isExpanded && self.getNodeIsCollapsible(node)) {
                     node.isExpanded = false;
@@ -467,15 +528,23 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                     collapseRecursive(node.children[key]);
                 }
             }
-            if (isEmptyString(nodePath)) {
+            const paths = Array.isArray(nodePath)
+                ? nodePath.filter((p) => !isEmptyString(p))
+                : isEmptyString(nodePath)
+                    ? []
+                    : [nodePath];
+            if (paths.length === 0) {
                 collapseRecursive(root);
             }
             else {
-                const target = this.getNodeByPath(nodePath);
-                if (target)
-                    collapseRecursive(target);
+                for (const p of paths) {
+                    const target = this.getNodeByPath(p);
+                    if (target)
+                        collapseRecursive(target);
+                }
             }
-            this._emitTreeChanged();
+            if (!noEmit)
+                this._emitTreeChanged();
             perfEnd(`[${_treeId}] collapseAll`);
         },
         insert: function (path, data, noEmitChanges = false) {
@@ -494,49 +563,91 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                 this._emitTreeChanged();
             }
         },
-        expandNodes: function (path, noEmitChanges = false) {
+        expandNodes: function (path, options) {
             perfStart(`[${_treeId}] expandNodes`);
-            let node = this.isFiltered ? filteredRoot : root;
+            const self = this;
+            const exclusive = options?.exclusive ?? false;
+            const noEmit = options?.noEmit ?? false;
+            const rootNode = this.isFiltered ? filteredRoot : root;
+            const paths = Array.isArray(path) ? path : [path];
             let hasChanges = false;
-            const segments = path.split(this.treePathSeparator);
-            for (let i = 0; i < segments.length; i++) {
-                const segment = segmentPrefix + segments[i];
-                if (node.children.hasOwnProperty(segment)) {
-                    node = node.children[segment];
-                    // Only mark as changed if actually changing from collapsed to expanded
-                    if (!node.isExpanded) {
-                        node.isExpanded = true;
-                        hasChanges = true;
+            if (exclusive) {
+                // Build spine set: union of every ancestor path across all inputs.
+                const spineSet = new Set();
+                for (const p of paths) {
+                    const segs = p.split(this.treePathSeparator);
+                    for (let i = 0; i < segs.length; i++) {
+                        spineSet.add(segs.slice(0, i + 1).join(this.treePathSeparator));
+                    }
+                }
+                // Walk currently-expanded subtree, collapse anything off-spine.
+                const trim = (node) => {
+                    for (const key in node.children) {
+                        const child = node.children[key];
+                        if (!child.isExpanded)
+                            continue;
+                        if (spineSet.has(child.path)) {
+                            trim(child);
+                        }
+                        else if (self.getNodeIsCollapsible(child)) {
+                            child.isExpanded = false;
+                            hasChanges = true;
+                            trim(child);
+                        }
+                    }
+                };
+                trim(rootNode);
+            }
+            for (const p of paths) {
+                let node = rootNode;
+                const segments = p.split(this.treePathSeparator);
+                for (let i = 0; i < segments.length; i++) {
+                    const segment = segmentPrefix + segments[i];
+                    if (node && node.children.hasOwnProperty(segment)) {
+                        node = node.children[segment];
+                        if (!node.isExpanded) {
+                            node.isExpanded = true;
+                            hasChanges = true;
+                        }
+                    }
+                    else {
+                        break;
                     }
                 }
             }
-            // Only emit changes if something actually changed
-            if (!noEmitChanges && hasChanges) {
+            if (!noEmit && hasChanges) {
                 this._emitTreeChanged();
             }
             perfEnd(`[${_treeId}] expandNodes`);
-            return this; // Return the API object for chaining
+            return this;
         },
-        collapseNodes: function (path, noEmitChanges = false) {
-            let node = this.isFiltered ? filteredRoot : this.root;
+        collapseNodes: function (path, options) {
+            const noEmit = options?.noEmit ?? false;
+            const rootNode = this.isFiltered ? filteredRoot : this.root;
+            const paths = Array.isArray(path) ? path : [path];
             let hasChanges = false;
-            const segments = path.split(this.treePathSeparator);
-            for (let i = 0; i < segments.length; i++) {
-                const segment = segmentPrefix + segments[i];
-                if (node.children.hasOwnProperty(segment)) {
-                    node = node.children[segment];
+            for (const p of paths) {
+                let node = rootNode;
+                const segments = p.split(this.treePathSeparator);
+                for (let i = 0; i < segments.length; i++) {
+                    const segment = segmentPrefix + segments[i];
+                    if (node && node.children.hasOwnProperty(segment)) {
+                        node = node.children[segment];
+                    }
+                    else {
+                        node = undefined;
+                        break;
+                    }
+                }
+                if (node && node.isExpanded) {
+                    node.isExpanded = false;
+                    hasChanges = true;
                 }
             }
-            // Only collapse the target node, not ancestors
-            if (node.isExpanded) {
-                node.isExpanded = false;
-                hasChanges = true;
-            }
-            // Only emit changes if something actually changed
-            if (!noEmitChanges && hasChanges) {
+            if (!noEmit && hasChanges) {
                 this._emitTreeChanged();
             }
-            return this; // Return the API object for chaining
+            return this;
         },
         // Private helper methods
         getNodeByPath: function (path, _root) {

package/dist/ltree/types.d.ts

@@ -117,12 +117,22 @@ export interface Ltree<T> {
     searchNodes(_searchText: string | null | undefined, _searchOptions?: SearchOptions): LTreeNode<T>[];
     createFilteredTree(targetPaths: string[]): void;
     clearFilter(): void;
-    expandAll(nodePath?: string | null | undefined): void;
-    collapseAll(nodePath?: string | null | undefined): void;
+    expandAll(nodePath?: string | string[] | null | undefined, options?: {
+        exclusive?: boolean;
+        noEmit?: boolean;
+    }): void;
+    collapseAll(nodePath?: string | string[] | null | undefined, options?: {
+        noEmit?: boolean;
+    }): void;
     insert(path: string, data: T, noEmitChanges?: boolean): void;
     getNodeByPath(path: string, _root?: LTreeNode<T> | null | undefined): LTreeNode<T> | null;
-    expandNodes(path: string): Ltree<T>;
-    collapseNodes(path: string): Ltree<T>;
+    expandNodes(path: string | string[], options?: {
+        exclusive?: boolean;
+        noEmit?: boolean;
+    }): Ltree<T>;
+    collapseNodes(path: string | string[], options?: {
+        noEmit?: boolean;
+    }): Ltree<T>;
     getNodeDisplayValue(node: LTreeNode<T>): string;
     getNodeSearchValue(node: LTreeNode<T>): string;
     _defaultSort(self: Ltree<T>, items: LTreeNode<T>[]): LTreeNode<T>[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@keenmate/svelte-treeview",
-	"version": "5.0.0-rc07",
+	"version": "5.0.0-rc08",
 	"scripts": {
 		"dev": "vite dev --port 17777",
 		"build": "vite build && npm run prepack",