@ixfx/components 0.13.6 → 0.13.8

package/dist/miller.d.ts

@@ -1,6 +1,6 @@
-import { D as TreeTickleDetail, E as TreeSelectEvent, O as TreeTickleEvent, T as TreeSelectDetail, a as TreeComponent, b as TreeItemClickDetail, i as TreeCollapseEvent, k as TreeDataModel, n as TreeActivateEvent, o as TreeComponentEventMap, r as TreeCollapseDetail, t as TreeActivateDetail, v as TreeExpandDetail, w as TreeSearchHost, x as TreeItemClickEvent, y as TreeExpandEvent } from "./tree-component-Bx40hxMz.js";
+import { A as TreeTickleEvent, D as TreeSelectDetail, E as TreeSearchHost, O as TreeSelectEvent, a as TreeComponent, b as TreeItemClickDetail, i as TreeCollapseEvent, j as TreeDataModel, k as TreeTickleDetail, n as TreeActivateEvent, o as TreeComponentEventMap, r as TreeCollapseDetail, t as TreeActivateDetail, v as TreeExpandDetail, w as TreeNavigateOptions, x as TreeItemClickEvent, y as TreeExpandEvent } from "./tree-component-Tslymyyl.js";
 import { a as TreeItem, n as TreeExclusivity, o as TreeNode, r as TreeFilterPredicate, s as TreeSelectionFilter, t as LoadChildrenCallback } from "./types-DQ7KOUIj.js";
-import { S as ListSearchController } from "./index-CzFRWPzh.js";
+import { S as ListSearchController } from "./index-CO6m-YC0.js";
 import { n as TickledController } from "./tickled-controller-DodxD3eQ.js";
 import { LitElement, PropertyValues, TemplateResult, nothing } from "lit";
 import { CommandRegistry } from "@clinth/ui-commands";
@@ -218,7 +218,13 @@ declare class MillerBaseElement extends LitElement implements TreeComponent, Tre
    * Programmatically navigate to a node by key path, relative to the current
    * view root (rebased or full tree).
    */
-  navigateTo(keys: readonly string[]): boolean;
+  navigateTo(keys: readonly string[], options?: TreeNavigateOptions): boolean;
+  /**
+   * Re-sync the element with children arrays patched in place (see
+   * `MillerTreeController.sync()`): columns whose selected node was removed are
+   * closed, selection entries for removed nodes are dropped, then it re-renders.
+   */
+  invalidateStructure(): void;
   /**
    * Programmatically navigate to the first node (breadth-first) matching a predicate.
    */
@@ -352,6 +358,11 @@ type MillerTreeControllerOptions<T> = {
    * `TraversableTree` node has any children.
    */
   valueToItem: (value: T, node: TraversableTree<T>) => TreeItem;
+  /**
+   * Children loader installed on the element by `connect()`. Defaults to a
+   * synchronous read from the source tree. `sync()` never touches it.
+   */
+  loadChildren?: LoadChildrenCallback;
 };
 /**
  * Bridges an `ixfx` `TraversableTree<T>` with an `ixfx-miller-*` component.
@@ -399,7 +410,28 @@ declare class MillerTreeController<T> {
    *
    * Returns `false` if no matching node is found.
    */
-  navigateToValue(predicate: (value: T) => boolean): boolean;
+  navigateToValue(predicate: (value: T) => boolean, options?: TreeNavigateOptions): boolean;
+  /**
+   * Navigate using item keys **relative to the element's current view root**
+   * (the real root when not rebased). Ancestors with unloaded children are
+   * populated first. Returns `false` if a key is missing.
+   */
+  navigateToKeyPath(keys: readonly string[], options?: TreeNavigateOptions): boolean;
+  /**
+   * Navigate to the source node with this identity. Returns `false` when it is
+   * unknown or lies outside a rebased view (keys are relative to the view root).
+   */
+  navigateToIdentity(identity: unknown, options?: TreeNavigateOptions): boolean;
+  /** The source node whose item key is `key`, if it has been materialised. */
+  lookupByKey(key: string): TraversableTree<T> | undefined;
+  /**
+   * Re-derive children for every already-materialised node from the source tree
+   * and patch them in place. Children arrays are mutated (not replaced) so open
+   * columns keep their references, and `MillerNode`s are reused by key so
+   * selection survives. A rebased `viewRoot` is reset only if its node was
+   * removed. `loadChildren` is left alone. Refreshes the element once.
+   */
+  sync(): void;
 }
 //#endregion
 export { type TreeActivateDetail as MillerActivateDetail, type TreeActivateEvent as MillerActivateEvent, MillerBaseElement, MillerBaseElementEventMap, type TreeCollapseDetail as MillerCollapseDetail, type TreeCollapseEvent as MillerCollapseEvent, MillerConfig, type TreeExpandDetail as MillerExpandDetail, type TreeExpandEvent as MillerExpandEvent, MillerHeaderClickDetail, MillerHeaderClickEvent, MillerHeaderRightClickDetail, MillerHeaderRightClickEvent, type TreeItem as MillerItem, type TreeItemClickDetail as MillerItemClickDetail, type TreeItemClickEvent as MillerItemClickEvent, MillerItemDblClickDetail, MillerItemDblClickEvent, MillerItemRightClickDetail, MillerItemRightClickEvent, MillerItemState, MillerListElement, type TreeNode as MillerNode, MillerRebaseDetail, MillerRebaseEvent, type TreeSelectDetail as MillerSelectDetail, type TreeSelectEvent as MillerSelectEvent, MillerSelectionMode, type TreeTickleDetail as MillerTickleDetail, type TreeTickleEvent as MillerTickleEvent, MillerTreeController, MillerTreeControllerOptions };

package/dist/miller.js

@@ -39,6 +39,8 @@ let MillerBaseElement = class MillerBaseElement extends LitElement {
 			}
 			return items;
 		} });
+		this.#selectOrigin = `user`;
+		this.#selectSilent = false;
 		this.#onKeyDown = (event) => {
 			if (this.search.isOpen) return;
 			const currentDepth = this.#getTickledDepthOrDefault();
@@ -403,14 +405,47 @@ let MillerBaseElement = class MillerBaseElement extends LitElement {
 	* Programmatically navigate to a node by key path, relative to the current
 	* view root (rebased or full tree).
 	*/
-	navigateTo(keys) {
+	navigateTo(keys, options = {}) {
 		const display = this.#displayRoot;
 		if (!display?.children) return false;
+		const prevOrigin = this.#selectOrigin;
+		const prevSilent = this.#selectSilent;
+		this.#selectOrigin = `programmatic`;
+		this.#selectSilent = options.silent === true;
+		try {
+			return this.#navigateTo(display.children, keys, options.reveal ?? `edge`);
+		} finally {
+			this.#selectOrigin = prevOrigin;
+			this.#selectSilent = prevSilent;
+		}
+	}
+	/**
+	* Re-sync the element with children arrays patched in place (see
+	* `MillerTreeController.sync()`): columns whose selected node was removed are
+	* closed, selection entries for removed nodes are dropped, then it re-renders.
+	*/
+	invalidateStructure() {
+		const present = /* @__PURE__ */ new Set();
+		for (const col of this._columns) for (const n of col) present.add(n);
+		for (let depth = 0; depth < this._columns.length; depth++) {
+			const selected = this._selectedByDepth.get(depth);
+			if (selected && !this._columns[depth].includes(selected)) {
+				this._columns = this._columns.slice(0, depth + 1);
+				for (const d of [...this._selectedByDepth.keys()]) if (d >= depth) this._selectedByDepth.delete(d);
+				break;
+			}
+		}
+		for (const n of [...this._selectedNodes]) if (!present.has(n)) this._selectedNodes.delete(n);
+		this.requestUpdate();
+	}
+	#selectOrigin;
+	#selectSilent;
+	#navigateTo(rootColumn, keys, reveal) {
 		this.#abortPending();
 		this._selectedByDepth.clear();
 		this.tickled.clearTickled();
-		const newColumns = [display.children];
-		let currentColumn = display.children;
+		const newColumns = [rootColumn];
+		let currentColumn = rootColumn;
 		let success = true;
 		let lastNode;
 		let lastDepth = 0;
@@ -438,7 +473,7 @@ let MillerBaseElement = class MillerBaseElement extends LitElement {
 			if (leafKey) this._selectedKeys = /* @__PURE__ */ new Set([leafKey]);
 		}
 		this.requestUpdate();
-		this.#scrollNavigatedItemIntoView();
+		this.#scrollNavigatedItemIntoView(reveal === `center-if-hidden` ? `auto` : `smooth`, reveal);
 		return success;
 	}
 	/**
@@ -718,9 +753,11 @@ let MillerBaseElement = class MillerBaseElement extends LitElement {
 		return true;
 	}
 	#dispatchSelectEvent(previous) {
+		if (this.#selectSilent) return;
 		const detail = {
 			selected: new Set(this._selectedNodes),
-			previous
+			previous,
+			origin: this.#selectOrigin
 		};
 		this.dispatchEvent(new CustomEvent(`select`, {
 			detail,
@@ -990,13 +1027,26 @@ let MillerBaseElement = class MillerBaseElement extends LitElement {
 			index
 		};
 	}
-	#scrollNavigatedItemIntoView(behavior = `smooth`) {
+	#scrollNavigatedItemIntoView(behavior = `smooth`, reveal = `edge`) {
 		requestAnimationFrame(() => {
 			const tickled = this.#getTickledNodeAndDepth();
 			if (!tickled) return;
 			const container = this.shadowRoot?.querySelectorAll(`.column`)[tickled.depth]?.querySelector(`.column-content`);
 			if (!container) return;
-			container.querySelectorAll(`.item`)[tickled.index]?.scrollIntoView({
+			const item = container.querySelectorAll(`.item`)[tickled.index];
+			if (!item) return;
+			if (reveal === `center-if-hidden`) {
+				const rect = item.getBoundingClientRect();
+				const box = container.getBoundingClientRect();
+				const hidden = rect.top < box.top || rect.bottom > box.bottom;
+				item.scrollIntoView({
+					block: hidden ? `center` : `nearest`,
+					inline: `nearest`,
+					behavior
+				});
+				return;
+			}
+			item.scrollIntoView({
 				block: `nearest`,
 				behavior
 			});
@@ -1562,6 +1612,10 @@ var MillerTreeController = class {
 	#options;
 	#nodeToTree = /* @__PURE__ */ new WeakMap();
 	#identityToMillerNode = /* @__PURE__ */ new Map();
+	#keyToTreeNode = /* @__PURE__ */ new Map();
+	#identityToTree = /* @__PURE__ */ new Map();
+	/** `valueToItem` results per source node identity; replaced wholesale by `sync()`. */
+	#itemCache = /* @__PURE__ */ new WeakMap();
 	#connectSignal;
 	constructor(root, element, options) {
 		this.#root = root;
@@ -1575,18 +1629,19 @@ var MillerTreeController = class {
 	connect() {
 		this.disconnect();
 		this.#connectSignal = new AbortController();
-		const rootValue = this.#root.getValue();
-		const rootItem = this.#options.valueToItem(rootValue, this.#root);
-		const rootChildren = this.#childrenOf(this.#root);
-		this.#element.root = {
-			item: rootItem,
-			children: rootChildren
-		};
-		this.#element.loadChildren = ({ node }) => {
+		this.#itemCache = /* @__PURE__ */ new WeakMap();
+		this.#identityToMillerNode.clear();
+		this.#identityToTree.clear();
+		this.#keyToTreeNode.clear();
+		const rootNode = { item: this.#itemOf(this.#root) };
+		this.#nodeToTree.set(rootNode, this.#root);
+		rootNode.children = this.#childrenOf(this.#root);
+		this.#element.root = rootNode;
+		this.#element.loadChildren = this.#options.loadChildren ?? (({ node }) => {
 			const treeNode = this.#nodeToTree.get(node);
 			if (!treeNode) return [];
 			return this.#childrenOf(treeNode);
-		};
+		});
 	}
 	/** Remove all event listeners and release internal state. */
 	disconnect() {
@@ -1606,46 +1661,110 @@ var MillerTreeController = class {
 	*
 	* Returns `false` if no matching node is found.
 	*/
-	navigateToValue(predicate) {
+	navigateToValue(predicate, options) {
 		const treePath = this.#findTreePath(this.#root, predicate);
 		if (!treePath) return false;
+		return this.#navigateToPath(treePath, options);
+	}
+	/**
+	* Navigate using item keys **relative to the element's current view root**
+	* (the real root when not rebased). Ancestors with unloaded children are
+	* populated first. Returns `false` if a key is missing.
+	*/
+	navigateToKeyPath(keys, options) {
+		const base = this.#element.viewRoot ?? this.#element.root;
+		if (!base || keys.length === 0) return false;
+		this.#ensureChildren(base);
+		let column = base.children ?? [];
+		for (let i = 0; i < keys.length - 1; i++) {
+			const node = column.find((n) => n.item.key === keys[i]);
+			if (!node) return false;
+			this.#ensureChildren(node);
+			column = node.children ?? [];
+		}
+		return this.#element.navigateTo(keys, options);
+	}
+	/**
+	* Navigate to the source node with this identity. Returns `false` when it is
+	* unknown or lies outside a rebased view (keys are relative to the view root).
+	*/
+	navigateToIdentity(identity, options) {
+		const target = this.#treeNodeByIdentity(identity);
+		if (!target) return false;
+		const path = [];
+		const rootId = this.#root.getIdentity();
+		for (let n = target; n; n = n.getParent()) {
+			path.unshift(n);
+			if (n.getIdentity() === rootId) return this.#navigateToPath(path, options);
+		}
+		return false;
+	}
+	/** The source node whose item key is `key`, if it has been materialised. */
+	lookupByKey(key) {
+		return this.#keyToTreeNode.get(key);
+	}
+	/**
+	* Re-derive children for every already-materialised node from the source tree
+	* and patch them in place. Children arrays are mutated (not replaced) so open
+	* columns keep their references, and `MillerNode`s are reused by key so
+	* selection survives. A rebased `viewRoot` is reset only if its node was
+	* removed. `loadChildren` is left alone. Refreshes the element once.
+	*/
+	sync() {
+		const root = this.#element.root;
+		if (!root) return;
+		this.#itemCache = /* @__PURE__ */ new WeakMap();
+		this.#identityToMillerNode.clear();
+		this.#identityToTree.clear();
+		this.#keyToTreeNode.clear();
+		this.#nodeToTree.set(root, this.#root);
+		root.item = this.#itemOf(this.#root);
+		const kept = /* @__PURE__ */ new Set([root]);
+		if (root.children) this.#syncChildren(this.#root, root.children, kept);
+		const view = this.#element.viewRoot;
+		if (view && !kept.has(view)) this.#element.viewRoot = void 0;
+		this.#element.invalidateStructure();
+	}
+	#navigateToPath(treePath, options) {
 		const base = this.#element.viewRoot ?? this.#element.root;
 		if (!base) return false;
 		let startIndex = 1;
 		if (this.#element.viewRoot) {
 			const mappedBase = this.#nodeToTree.get(base);
 			if (!mappedBase) return false;
-			const baseIndex = treePath.indexOf(mappedBase);
+			const baseId = mappedBase.getIdentity();
+			const baseIndex = treePath.findIndex((n) => n.getIdentity() === baseId);
 			if (baseIndex < 0) return false;
 			startIndex = baseIndex + 1;
-			if (base.children === void 0) base.children = this.#childrenOf(mappedBase);
 		}
-		let currentColumn = base.children ?? [];
-		const keys = [];
-		for (let i = startIndex; i < treePath.length; i++) {
-			const treeNode = treePath[i];
-			const key = this.#options.valueToItem(treeNode.getValue(), treeNode).key;
-			keys.push(key);
-			if (i < treePath.length - 1) {
-				const millerNode = currentColumn.find((n) => n.item.key === key);
-				if (!millerNode) return false;
-				if (millerNode.children === void 0) {
-					const mapped = this.#nodeToTree.get(millerNode);
-					if (mapped) millerNode.children = this.#childrenOf(mapped);
-				}
-				currentColumn = millerNode.children ?? [];
-			}
+		if (startIndex >= treePath.length) return false;
+		return this.navigateToKeyPath(treePath.slice(startIndex).map((n) => this.#itemOf(n).key), options);
+	}
+	#ensureChildren(node) {
+		if (node.children !== void 0) return;
+		const mapped = this.#nodeToTree.get(node);
+		if (mapped) node.children = this.#childrenOf(mapped);
+	}
+	#treeNodeByIdentity(identity) {
+		return this.#identityToTree.get(identity);
+	}
+	#itemOf(treeNode) {
+		const id = treeNode.getIdentity();
+		let item = this.#itemCache.get(id);
+		if (!item) {
+			item = this.#options.valueToItem(treeNode.getValue(), treeNode);
+			this.#itemCache.set(id, item);
 		}
-		return this.#element.navigateTo(keys);
+		return item;
 	}
 	/** Convert a TraversableTree node's children to MillerNode[]. */
 	#childrenOf(treeNode) {
 		return Array.from(treeNode.children(), (child) => this.#toMillerNode(child));
 	}
 	#toMillerNode(treeNode) {
-		const value = treeNode.getValue();
 		const childList = [...treeNode.children()];
-		const userItem = this.#options.valueToItem(value, treeNode);
+		for (const child of childList) this.#identityToTree.set(child.getIdentity(), child);
+		const userItem = this.#itemOf(treeNode);
 		const isLeaf = userItem.isLeaf ?? childList.length === 0;
 		const millerNode = {
 			item: {
@@ -1654,10 +1773,35 @@ var MillerTreeController = class {
 			},
 			children: isLeaf ? [] : void 0
 		};
-		this.#nodeToTree.set(millerNode, treeNode);
-		this.#identityToMillerNode.set(treeNode.getIdentity(), millerNode);
+		this.#register(millerNode, treeNode);
 		return millerNode;
 	}
+	#register(node, treeNode) {
+		this.#nodeToTree.set(node, treeNode);
+		this.#identityToMillerNode.set(treeNode.getIdentity(), node);
+		this.#identityToTree.set(treeNode.getIdentity(), treeNode);
+		this.#keyToTreeNode.set(node.item.key, treeNode);
+	}
+	/** Patch `existing` (in place) to match the source children of `treeNode`; recurse into loaded nodes. */
+	#syncChildren(treeNode, existing, kept) {
+		const byKey = new Map(existing.map((n) => [n.item.key, n]));
+		const next = Array.from(treeNode.children(), (child) => {
+			const fresh = this.#toMillerNode(child);
+			const old = byKey.get(fresh.item.key);
+			if (!old) {
+				kept.add(fresh);
+				return fresh;
+			}
+			old.item = fresh.item;
+			this.#register(old, child);
+			kept.add(old);
+			if (fresh.item.isLeaf) old.children = [];
+			else if (old.children !== void 0) this.#syncChildren(child, old.children, kept);
+			else old.children = void 0;
+			return old;
+		});
+		existing.splice(0, existing.length, ...next);
+	}
 	/** DFS through the ixfx tree returning the path of nodes to the first match. */
 	#findTreePath(node, predicate, ancestors = []) {
 		const path = [...ancestors, node];

package/dist/{tree-BjrfaX7d.js → tree-9Hs7VxuX.js}

@@ -2386,6 +2386,69 @@ let TreeBaseElement = class TreeBaseElement extends LitElement {
 		this.#dispatchSelect(prev);
 		this.requestUpdate();
 	}
+	/**
+	* Expand every already-loaded branch in a single update. With `maxDepth`,
+	* only branches at depth < `maxDepth` are expanded (the root's children are
+	* depth 0), so rows at depth `maxDepth` become visible but stay collapsed.
+	*
+	* Unloaded (lazy) branches are not fetched — call again once their children
+	* have loaded to expand further. Bulk expansion ignores `exclusivity`. Fires
+	* one `expand` event per branch that actually opens — none for branches that
+	* were already expanded, including ones opened by filter auto-expansion.
+	*/
+	expandAll(maxDepth) {
+		this.#bulkExpand(true, maxDepth);
+	}
+	/**
+	* Collapse expanded branches in a single update. With `maxDepth`, only
+	* branches at depth >= `maxDepth` are collapsed, leaving the tree open down
+	* to depth `maxDepth - 1` (`collapseAll(0)` is a full collapse). Fires one
+	* `collapse` event per branch that actually closes.
+	*/
+	collapseAll(maxDepth) {
+		this.#bulkExpand(false, maxDepth);
+	}
+	/** Shared bulk expand / collapse: one `_expandedKeys` write, per-node events for real changes only. */
+	#bulkExpand(expand, maxDepth) {
+		const root = this.root;
+		if (!root) return;
+		const inScope = (depth) => expand ? depth < (maxDepth ?? Number.POSITIVE_INFINITY) : depth >= (maxDepth ?? 0);
+		const changed = [];
+		let next = this._expandedKeys;
+		const visit = (node, depth) => {
+			const children = node.children;
+			if (node.item.isLeaf !== true && children !== void 0 && children.length > 0 && inScope(depth)) {
+				const keyed = next.has(node.item.key);
+				if (expand && !keyed) {
+					next = withKey(next, node.item.key);
+					if (!this._isExpanded(node, depth)) changed.push({
+						node,
+						depth
+					});
+				} else if (!expand && keyed) {
+					next = withoutKey(next, node.item.key);
+					changed.push({
+						node,
+						depth
+					});
+				}
+			}
+			for (const child of children ?? []) visit(child, depth + 1);
+		};
+		for (const child of root.children ?? []) visit(child, 0);
+		if (next === this._expandedKeys) return;
+		this.#setExpanded(next);
+		const type = expand ? `expand` : `collapse`;
+		for (const { node, depth } of changed) this.dispatchEvent(new CustomEvent(type, {
+			detail: {
+				node,
+				depth
+			},
+			bubbles: true,
+			composed: true
+		}));
+		this.requestUpdate();
+	}
 	navigateTo(keys, options = {}) {
 		if (!this.root?.children) return false;
 		const prevOrigin = this.#selectOrigin;

package/dist/{tree-component-Bx40hxMz.d.ts → tree-component-Tslymyyl.d.ts}

@@ -213,6 +213,14 @@ type TreeDropEvent = CustomEvent<TreeDropDetail>;
 type TreeDragEndEvent = CustomEvent<{
   dropped: boolean;
 }>;
+/** How `navigateTo` scrolls its target: edge-align it, or centre it when it is off screen. */
+type TreeRevealMode = `edge` | `center-if-hidden`;
+type TreeNavigateOptions = {
+  /** Scroll behaviour for the target (default `edge`). */
+  reveal?: TreeRevealMode;
+  /** Suppress the `select` event this navigation would otherwise fire. */
+  silent?: boolean;
+};
 /**
  * Fired when the selection set changes by any means (click, keyboard, programmatic).
  * Event name: `select`
@@ -413,4 +421,4 @@ interface TreeSearchHost extends TreeComponent {
   readonly updateComplete: Promise<boolean>;
 }
 //#endregion
-export { TreeDataModelOptions as A, TreeItemDblClickEvent as C, TreeTickleDetail as D, TreeSelectEvent as E, ListDragPreviewSourceResolver as F, ListDragSource as I, ListNativeDragStartDetail as L, ListDragPreview as M, ListDragPreviewContext as N, TreeTickleEvent as O, ListDragPreviewRenderer as P, ListNativeDragStartEvent as R, TreeItemDblClickDetail as S, TreeSelectDetail as T, TreeDropTarget as _, TreeComponent as a, TreeItemClickDetail as b, TreeDragContext as c, TreeDragStartEvent as d, TreeDropApplyContext as f, TreeDropPosition as g, TreeDropEvent as h, TreeCollapseEvent as i, ListDragEntry as j, TreeDataModel as k, TreeDragEndEvent as l, TreeDropDetail as m, TreeActivateEvent as n, TreeComponentEventMap as o, TreeDropContext as p, TreeCollapseDetail as r, TreeDndMode as s, TreeActivateDetail as t, TreeDragOverEvent as u, TreeExpandDetail as v, TreeSearchHost as w, TreeItemClickEvent as x, TreeExpandEvent as y };
+export { TreeTickleEvent as A, ListNativeDragStartEvent as B, TreeItemDblClickEvent as C, TreeSelectDetail as D, TreeSearchHost as E, ListDragPreviewContext as F, ListDragPreviewRenderer as I, ListDragPreviewSourceResolver as L, TreeDataModelOptions as M, ListDragEntry as N, TreeSelectEvent as O, ListDragPreview as P, ListDragSource as R, TreeItemDblClickDetail as S, TreeRevealMode as T, TreeDropTarget as _, TreeComponent as a, TreeItemClickDetail as b, TreeDragContext as c, TreeDragStartEvent as d, TreeDropApplyContext as f, TreeDropPosition as g, TreeDropEvent as h, TreeCollapseEvent as i, TreeDataModel as j, TreeTickleDetail as k, TreeDragEndEvent as l, TreeDropDetail as m, TreeActivateEvent as n, TreeComponentEventMap as o, TreeDropContext as p, TreeCollapseDetail as r, TreeDndMode as s, TreeActivateDetail as t, TreeDragOverEvent as u, TreeExpandDetail as v, TreeNavigateOptions as w, TreeItemClickEvent as x, TreeExpandEvent as y, ListNativeDragStartDetail as z };

package/dist/tree.d.ts

@@ -1,4 +1,4 @@
-import { A as TreeDataModelOptions, D as TreeTickleDetail, E as TreeSelectEvent, O as TreeTickleEvent, T as TreeSelectDetail, _ as TreeDropTarget, b as TreeItemClickDetail, c as TreeDragContext, d as TreeDragStartEvent, g as TreeDropPosition, h as TreeDropEvent, i as TreeCollapseEvent, k as TreeDataModel, l as TreeDragEndEvent, m as TreeDropDetail, n as TreeActivateEvent, o as TreeComponentEventMap, p as TreeDropContext, r as TreeCollapseDetail, s as TreeDndMode, t as TreeActivateDetail, u as TreeDragOverEvent, v as TreeExpandDetail, x as TreeItemClickEvent, y as TreeExpandEvent } from "./tree-component-Bx40hxMz.js";
+import { A as TreeTickleEvent, D as TreeSelectDetail, M as TreeDataModelOptions, O as TreeSelectEvent, T as TreeRevealMode, _ as TreeDropTarget, b as TreeItemClickDetail, c as TreeDragContext, d as TreeDragStartEvent, g as TreeDropPosition, h as TreeDropEvent, i as TreeCollapseEvent, j as TreeDataModel, k as TreeTickleDetail, l as TreeDragEndEvent, m as TreeDropDetail, n as TreeActivateEvent, o as TreeComponentEventMap, p as TreeDropContext, r as TreeCollapseDetail, s as TreeDndMode, t as TreeActivateDetail, u as TreeDragOverEvent, v as TreeExpandDetail, w as TreeNavigateOptions, x as TreeItemClickEvent, y as TreeExpandEvent } from "./tree-component-Tslymyyl.js";
 import { a as TreeItem, n as TreeExclusivity, o as TreeNode, r as TreeFilterPredicate, s as TreeSelectionFilter, t as LoadChildrenCallback } from "./types-DQ7KOUIj.js";
-import { a as TreeDropVisibleRow, c as TreeListElement, d as TreeBaseElementEventMap, f as TreeNavigateOptions, h as TreeConfig, i as TreeDropRowInfo, l as TreeCheckboxState, m as TreeVirtualize, n as TreeDropControllerConfig, o as TreeController, p as TreeRevealMode, r as TreeDropResolvedDrag, s as TreeControllerOptions, t as TreeDropController, u as TreeBaseElement } from "./index-AifRs3k9.js";
-export { type LoadChildrenCallback, type TreeActivateDetail, type TreeActivateEvent, TreeBaseElement, TreeBaseElementEventMap, type TreeCheckboxState, type TreeCollapseDetail, type TreeCollapseEvent, type TreeComponentEventMap, TreeConfig, TreeController, TreeControllerOptions, TreeDataModel, type TreeDataModelOptions, type TreeDndMode, type TreeDragContext, type TreeDragEndEvent, type TreeDragOverEvent, type TreeDragStartEvent, type TreeDropContext, TreeDropController, TreeDropControllerConfig, type TreeDropDetail, type TreeDropEvent, type TreeDropPosition, TreeDropResolvedDrag, TreeDropRowInfo, type TreeDropTarget, TreeDropVisibleRow, type TreeExclusivity, type TreeExpandDetail, type TreeExpandEvent, type TreeFilterPredicate, type TreeItem, type TreeItemClickDetail, type TreeItemClickEvent, TreeListElement, TreeNavigateOptions, type TreeNode, TreeRevealMode, type TreeSelectDetail, type TreeSelectEvent, type TreeSelectionFilter, type TreeTickleDetail, type TreeTickleEvent, TreeVirtualize };
+import { a as TreeDropVisibleRow, c as TreeListElement, d as TreeBaseElementEventMap, f as TreeVirtualize, i as TreeDropRowInfo, l as TreeCheckboxState, n as TreeDropControllerConfig, o as TreeController, p as TreeConfig, r as TreeDropResolvedDrag, s as TreeControllerOptions, t as TreeDropController, u as TreeBaseElement } from "./index-CSCrK0hR.js";
+export { type LoadChildrenCallback, type TreeActivateDetail, type TreeActivateEvent, TreeBaseElement, TreeBaseElementEventMap, type TreeCheckboxState, type TreeCollapseDetail, type TreeCollapseEvent, type TreeComponentEventMap, TreeConfig, TreeController, TreeControllerOptions, TreeDataModel, type TreeDataModelOptions, type TreeDndMode, type TreeDragContext, type TreeDragEndEvent, type TreeDragOverEvent, type TreeDragStartEvent, type TreeDropContext, TreeDropController, TreeDropControllerConfig, type TreeDropDetail, type TreeDropEvent, type TreeDropPosition, TreeDropResolvedDrag, TreeDropRowInfo, type TreeDropTarget, TreeDropVisibleRow, type TreeExclusivity, type TreeExpandDetail, type TreeExpandEvent, type TreeFilterPredicate, type TreeItem, type TreeItemClickDetail, type TreeItemClickEvent, TreeListElement, type TreeNavigateOptions, type TreeNode, type TreeRevealMode, type TreeSelectDetail, type TreeSelectEvent, type TreeSelectionFilter, type TreeTickleDetail, type TreeTickleEvent, TreeVirtualize };

package/dist/tree.js

@@ -1,2 +1,2 @@
-import { a as TreeDataModel, i as TreeDropController, n as TreeListElement, r as TreeBaseElement, t as TreeController } from "./tree-BjrfaX7d.js";
+import { a as TreeDataModel, i as TreeDropController, n as TreeListElement, r as TreeBaseElement, t as TreeController } from "./tree-9Hs7VxuX.js";
 export { TreeBaseElement, TreeController, TreeDataModel, TreeDropController, TreeListElement };

package/dist/{vertical-list-BohPAS04.d.ts → vertical-list-B1Fq06xr.d.ts}

@@ -1,6 +1,6 @@
-import { F as ListDragPreviewSourceResolver, P as ListDragPreviewRenderer, R as ListNativeDragStartEvent } from "./tree-component-Bx40hxMz.js";
+import { B as ListNativeDragStartEvent, I as ListDragPreviewRenderer, L as ListDragPreviewSourceResolver } from "./tree-component-Tslymyyl.js";
 import { n as ListViewportChangeEvent } from "./list-viewport-types-BRZsLcvp.js";
-import { S as ListSearchController } from "./index-CzFRWPzh.js";
+import { S as ListSearchController } from "./index-CO6m-YC0.js";
 import { i as ListInteractionMode, l as ListSelectionMode, r as ListElementEventMap } from "./list-selection-types-PjKdhF-a.js";
 import "./editable-label-rzXkjf1H.js";
 import { LitElement, PropertyValues } from "lit";

package/dist/vertical-list.d.ts

@@ -1,5 +1,5 @@
-import { I as ListDragSource, L as ListNativeDragStartDetail, M as ListDragPreview, N as ListDragPreviewContext, P as ListDragPreviewRenderer, R as ListNativeDragStartEvent, j as ListDragEntry } from "./tree-component-Bx40hxMz.js";
+import { B as ListNativeDragStartEvent, F as ListDragPreviewContext, I as ListDragPreviewRenderer, N as ListDragEntry, P as ListDragPreview, R as ListDragSource, z as ListNativeDragStartDetail } from "./tree-component-Tslymyyl.js";
 import { n as ListViewportChangeEvent, t as ListViewportChangeDetail } from "./list-viewport-types-BRZsLcvp.js";
 import { a as ListItemClickDetail, c as ListSelectEvent, d as ListTickleEvent, i as ListInteractionMode, l as ListSelectionMode, n as ListActivateEvent, o as ListItemClickEvent, r as ListElementEventMap, s as ListSelectDetail, t as ListActivateDetail, u as ListTickleDetail } from "./list-selection-types-PjKdhF-a.js";
-import { a as ListContextMenuDetail, c as ListDragLeaveEvent, d as ListDropEvent, f as ListEditCancelDetail, h as ListEditCommitEvent, i as VerticalListElementEventMap, l as ListDragOverEvent, m as ListEditCommitDetail, n as CustomCheckboxOptions, o as ListContextMenuEvent, p as ListEditCancelEvent, r as VerticalListElement, s as ListDragLeaveDetail, t as AddItemOptions, u as ListDropDetail } from "./vertical-list-BohPAS04.js";
+import { a as ListContextMenuDetail, c as ListDragLeaveEvent, d as ListDropEvent, f as ListEditCancelDetail, h as ListEditCommitEvent, i as VerticalListElementEventMap, l as ListDragOverEvent, m as ListEditCommitDetail, n as CustomCheckboxOptions, o as ListContextMenuEvent, p as ListEditCancelEvent, r as VerticalListElement, s as ListDragLeaveDetail, t as AddItemOptions, u as ListDropDetail } from "./vertical-list-B1Fq06xr.js";
 export { AddItemOptions, CustomCheckboxOptions, type ListActivateDetail, type ListActivateEvent, type ListContextMenuDetail, type ListContextMenuEvent, type ListDragEntry, type ListDragLeaveDetail, type ListDragLeaveEvent, type ListDragOverEvent, type ListDragPreview, type ListDragPreviewContext, type ListDragPreviewRenderer, type ListDragSource, type ListDropDetail, type ListDropEvent, type ListEditCancelDetail, type ListEditCancelEvent, type ListEditCommitDetail, type ListEditCommitEvent, type ListElementEventMap, type ListInteractionMode, type ListItemClickDetail, type ListItemClickEvent, type ListNativeDragStartDetail, type ListNativeDragStartEvent, type ListSelectDetail, type ListSelectEvent, type ListSelectionMode, type ListTickleDetail, type ListTickleEvent, type ListViewportChangeDetail, type ListViewportChangeEvent, VerticalListElement, VerticalListElementEventMap };

package/docs-user/hyperbolic-tree.md

@@ -118,7 +118,7 @@ Labels keep their on-screen size while zooming, so zooming in spreads a crowd ap
 
 ### Child preview
 
-On by default; `disable-child-preview` turns it off. Hovering or keyboard-tickling a node whose children aren't all legible opens a popover listing them. That means some children had their labels culled, or sit beyond `maxRadius`. It shows up to 12 children, then "+N more". Clicking an entry focuses that child and selects it, per `interactionMode`. The popover stays open while the pointer moves onto it, and Escape closes it. Style it with `::part(child-preview)`. Nodes that can show a preview drop their native `<title>` tooltip so the two don't stack. With the preview disabled, every node keeps its tooltip.
+On by default; `disable-child-preview` turns it off. Hovering or keyboard-tickling a node whose children aren't all legible, and resting there for 600ms, opens a popover listing them. That means some children had their labels culled, or sit beyond `maxRadius`. It shows up to 12 children, then "+N more". Clicking an entry focuses that child and selects it, per `interactionMode`. The popover stays open while the pointer moves onto it, and Escape closes it. Starting a drag (pan) cancels a pending preview and closes an open one. Style it with `::part(child-preview)`. Nodes that can show a preview drop their native `<title>` tooltip so the two don't stack. With the preview disabled, every node keeps its tooltip.
 
 ### Crowded fans
 

package/docs-user/index.json

@@ -1,7 +1,7 @@
 {
   "name": "@ixfx/components",
-  "version": "0.13.6",
-  "generated": "2026-10-05T20:21:38.161Z",
+  "version": "0.13.8",
+  "generated": "2026-10-08T21:09:54.870Z",
   "components": [
     {
       "name": "ac-text",

package/docs-user/miller.md

@@ -54,7 +54,11 @@ Inherited from theme:
 // Navigate to a node by key path (root-to-target keys, excluding root itself).
 // Only works with already-loaded children — returns false if any node along
 // the path has unloaded children or if a key is not found.
-navigateTo(keys: readonly string[]): boolean
+navigateTo(keys: readonly string[], options?: { reveal?: 'edge' | 'center-if-hidden'; silent?: boolean }): boolean
+
+// Re-sync after children arrays were patched in place (used by MillerTreeController.sync()):
+// closes columns whose selected node was removed, then re-renders.
+invalidateStructure(): void
 
 // Navigate to the first loaded node (breadth-first) matching a predicate.
 // Returns false if no match is found in the currently loaded tree.
@@ -398,11 +402,27 @@ type MillerTreeControllerOptions<T> = {
   // key and label are required. If isLeaf is omitted, it is inferred
   // from whether the TraversableTree node has any children.
   valueToItem: (value: T, node: TraversableTree<T>) => MillerItem;
+  // Installed as element.loadChildren by connect(). Defaults to a synchronous
+  // read from the source tree. sync() never touches it.
+  loadChildren?: LoadChildrenCallback;
 };
 ```
 
 ### Methods
 
+```typescript
+// Re-derive children of already-loaded nodes from the source tree and patch them
+// in place (arrays mutated, MillerNodes reused by key). viewRoot is reset only if
+// its node was removed. Refreshes the element once.
+sync(): void
+
+// Lookups that avoid searching the source tree. Key paths are RELATIVE TO THE
+// VIEW ROOT; identities outside a rebased view return false.
+lookupByKey(key: string): TraversableTree<T> | undefined
+navigateToKeyPath(keys: readonly string[], options?: TreeNavigateOptions): boolean
+navigateToIdentity(identity: unknown, options?: TreeNavigateOptions): boolean
+```
+
 ```typescript
 // Wire up the controller — sets element.root and provides loadChildren callback.
 // Safe to call again after disconnect().

package/docs-user/multicol-list.md

@@ -17,7 +17,7 @@ provider returns that column's choices; items may carry a `count` for display.
 
 | Property | Type | Default | Description |
 |----------|------|---------|-------------|
-| `categories` | `readonly MulticolCategory[]` | `[]` | Facet definitions (tree, shown in the header picker menu). Each may carry `defaults`: `grouped`, `groupBy`, `allLabel`, `sort`. |
+| `categories` | `readonly MulticolCategory[]` | `[]` | Facet definitions (tree, shown in the header picker menu). Each may carry `description` (shown as a tooltip on the column header label) and `defaults`: `grouped`, `groupBy`, `allLabel`, `sort`. |
 | `dataProvider` | `IDataProvider<MulticolQuery, MulticolItem>` \| `undefined` | — | Called per column whenever that column's inputs change. Sync arrays, Promises and async-iterables are supported; the `AbortSignal` is honoured. |
 | `selectionMode` | `ListSelectionMode` | `'multiple'` | `'none'`, `'single'` or `'multiple'` selection within a column. |
 | `minColumns` | `number` | `1` | Floor for column removal. |

package/docs-user/tree.md

@@ -330,6 +330,39 @@ el.addEventListener('select', ({ detail }) => {
 
 ---
 
+## Expansion
+
+### Programmatic expansion
+
+```typescript
+// Expand every already-loaded branch
+el.expandAll();
+
+// Expand down to depth 1: top-level branches open, so their children
+// (depth 1) are visible (root's children are depth 0)
+el.expandAll(1);
+
+// Collapse everything
+el.collapseAll();
+
+// Collapse branches at depth 1 and deeper — top-level branches stay open,
+// so the tree remains open down to depth 0
+el.collapseAll(1);
+```
+
+Notes:
+
+- Both methods apply in a single update — one re-render for the whole tree.
+- Only **already-loaded** branches are expanded; lazily loaded children are not
+  fetched. Call `expandAll()` again after children load to expand further.
+- Bulk expansion ignores `exclusivity` — it is an explicit "open everything"
+  command.
+- One `expand` / `collapse` event fires per branch whose state actually changes;
+  branches already in the target state (including those opened by filter
+  auto-expansion) stay silent.
+
+---
+
 ## Events
 
 All events **bubble** and are **composed** (cross shadow-DOM boundaries).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ixfx/components",
   "type": "module",
-  "version": "0.13.6",
+  "version": "0.13.8",
   "packageManager": "pnpm@10.0.0",
   "description": "Web components for ixfx — Lit-based UI toolkit",
   "author": "Clint Heyer",