@ixfx/components 0.2.3 → 0.2.5

package/dist/tree-component-CQpoPo4s.d.ts

@@ -0,0 +1,326 @@
+//#region src/common/types.d.ts
+/**
+ * Canonical shared types for all tree-like components (ixfx-tree-list, ixfx-miller-list,
+ * ixfx-crumb-navigation). Import from here rather than from individual component packages.
+ */
+/** A single node's display data. */
+type TreeItem = {
+  /** Unique identifier within the tree. */key: string; /** Visible label text. */
+  label: string; /** When true the node cannot have children and will not show an expand affordance. */
+  isLeaf?: boolean; /** Arbitrary application data associated with this node. */
+  data?: unknown; /** Icon name passed to an icon component, if icons are enabled. */
+  icon?: string; /** Tooltip text shown on hover. */
+  tooltip?: string; /** Optional string value, e.g. for use as a command/route. */
+  value?: string;
+};
+/** A node in the tree, potentially containing lazily-loaded children. */
+type TreeNode = {
+  item: TreeItem;
+  /**
+   * Child nodes.
+   * - `undefined` = children not yet loaded (component will call loadChildren if set)
+   * - `[]` = confirmed leaf / empty branch
+   * - non-empty array = loaded children
+   */
+  children?: TreeNode[];
+};
+/**
+ * Callback invoked when a node's children need to be loaded.
+ * The AbortSignal is cancelled if the request is superseded (e.g. node collapsed before load completes).
+ */
+type LoadChildrenCallback = (node: TreeNode, depth: number, signal: AbortSignal) => TreeNode[] | Promise<TreeNode[]>;
+/**
+ * Predicate used by search/filter controllers to determine whether a node should be visible.
+ * Receives depth so column-scoped filtering (e.g. in ixfx-miller-list) is possible.
+ * Tree implementations that do not need depth can simply ignore the parameter.
+ */
+type TreeFilterPredicate = (node: TreeNode, depth: number) => boolean;
+/**
+ * Controls how expanding a node affects its siblings.
+ * - `'none'`   — no constraint; any number of nodes may be expanded simultaneously
+ * - `'depth'`  — only one sibling at the same depth may be expanded at a time (accordion)
+ * - `'global'` — only one node anywhere in the tree may be expanded at a time
+ */
+type TreeExclusivity = 'none' | 'depth' | 'global';
+/**
+ * Restricts which kinds of nodes may enter the selection.
+ * Applied as a guard in all interaction modes.
+ * - `'none'`   — no node can be selected (read-only / display-only)
+ * - `'leaf'`   — only leaf nodes are selectable
+ * - `'branch'` — only branch nodes (nodes with children) are selectable
+ * - `'all'`    — both leaf and branch nodes are selectable
+ */
+type TreeSelectionFilter = 'none' | 'leaf' | 'branch' | 'all';
+/**
+ * Controls how pointer and keyboard gestures map to selection changes.
+ * - `'implicit'`  — single selection that follows the click; clicking always selects + toggles expand
+ * - `'standard'`  — single click selects+toggles; Ctrl/Cmd+click toggles item; Shift+click range-selects
+ * - `'manual'`    — component never auto-selects; use `select()`/`deselect()`/`clearSelection()` to drive state
+ * - `'checked'`   — checkboxes on every item; checkbox click toggles selection recursively; row click only expands/collapses
+ * - `'vscode'`    — like `standard` for clicks; Shift+arrow uses snapshot-based toggle-range
+ */
+type TreeInteractionMode = 'implicit' | 'standard' | 'manual' | 'checked' | 'vscode';
+//#endregion
+//#region src/common/tree-data-model.d.ts
+type InvalidateEvent = {
+  type: 'invalidate';
+  key: string;
+};
+type RootEvent = {
+  type: 'root';
+  root: TreeNode;
+};
+type ModelEvent = InvalidateEvent | RootEvent;
+type ModelSubscriber = (event: ModelEvent) => void;
+type TreeDataModelOptions = {
+  /** The initial root node. Required. */root: TreeNode;
+  /**
+   * Optional callback for lazily loading children.
+   * If omitted, nodes with `children === undefined` are treated as empty branches.
+   */
+  loadChildren?: LoadChildrenCallback;
+};
+/**
+ * Manages tree data for tree-like components.
+ *
+ * Handles two concerns:
+ * 1. **Lazy loading** — caches children fetched via `loadChildren` and can invalidate
+ *    specific branches so they are re-fetched on next expand.
+ * 2. **Structural mutations** — convenience methods to add, remove, update, or move
+ *    nodes. Each mutation produces a new immutable root and notifies connected components.
+ *
+ * Assign an instance to a component's `model` property instead of setting `root`/`loadChildren`
+ * directly. The same model instance can be shared across multiple components.
+ *
+ * @example
+ * ```typescript
+ * const model = new TreeDataModel({
+ *   root: { item: { key: 'root', label: 'Root' }, children: [] },
+ *   loadChildren: async (node, depth, signal) => fetchChildren(node.item.key),
+ * });
+ * myTreeList.model = model;
+ * myMillerList.model = model;
+ *
+ * // Later — invalidate a branch to force a re-fetch on next expand:
+ * model.invalidate('some-key');
+ * ```
+ */
+declare class TreeDataModel {
+  #private;
+  constructor(options: TreeDataModelOptions);
+  /** The current immutable root snapshot. */
+  get root(): TreeNode;
+  /**
+   * Replace the entire root with a new immutable snapshot.
+   * All cached children are cleared. Connected components re-render.
+   */
+  setRoot(root: TreeNode): void;
+  /**
+   * Returns children for the given node.
+   * If children are cached, they are returned immediately (as a resolved Promise).
+   * Otherwise the `loadChildren` callback is invoked and the result is cached.
+   * If no `loadChildren` is set and no cache entry exists, returns `[]`.
+   *
+   * Called by components internally — not typically called by application code.
+   */
+  getChildren(node: TreeNode, depth: number, signal: AbortSignal): Promise<TreeNode[]>;
+  /**
+   * Clears the cached children for the node with the given key.
+   * Connected components will collapse that node (if currently expanded), so that
+   * the next expand triggers a fresh `loadChildren` call.
+   */
+  invalidate(key: string): void;
+  /**
+   * Adds `node` as a child of the node identified by `parentKey`.
+   * Returns the new root (connected components are notified automatically).
+   */
+  addNode(parentKey: string, node: TreeNode): TreeNode;
+  /**
+   * Removes the node with the given key and all its descendants.
+   * Returns the new root (connected components are notified automatically).
+   */
+  removeNode(key: string): TreeNode;
+  /**
+   * Applies a partial update to the `item` of the node with the given key.
+   * Returns the new root (connected components are notified automatically).
+   */
+  updateItem(key: string, patch: Partial<TreeItem>): TreeNode;
+  /**
+   * Moves the node with the given key to become a child of `newParentKey`.
+   * Returns the new root (connected components are notified automatically).
+   */
+  moveNode(key: string, newParentKey: string): TreeNode;
+  /**
+   * Subscribe to model events. Returns an unsubscribe function.
+   * Components call this when the `model` property is set, and unsubscribe when it is unset.
+   *
+   * @internal
+   */
+  _subscribe(callback: ModelSubscriber): () => void;
+}
+//#endregion
+//#region src/common/tree-component.d.ts
+/**
+ * Fired when the selection set changes by any means (click, keyboard, programmatic).
+ * Event name: `select`
+ */
+type TreeSelectDetail = {
+  /** The new selection set. */readonly selected: ReadonlySet<TreeNode>; /** The previous selection set (empty set if there was no prior selection). */
+  readonly previous: ReadonlySet<TreeNode>;
+};
+/**
+ * Fired when an item enters cursor focus — either the pointer hovers over it, or
+ * the keyboard navigation cursor moves to it.
+ * Event name: `tickle`
+ */
+type TreeTickleDetail = {
+  readonly node: TreeNode;
+  readonly depth: number;
+};
+/**
+ * Fired when the user explicitly activates an item (Enter key or double-click).
+ * Event name: `activate`
+ */
+type TreeActivateDetail = {
+  readonly node: TreeNode;
+  readonly depth: number;
+};
+/**
+ * Fired when the user clicks an item (raw pointer event, before any selection change).
+ * Event name: `item-click`
+ */
+type TreeItemClickDetail = {
+  readonly node: TreeNode;
+  readonly depth: number;
+};
+/**
+ * Fired when a node or column is expanded.
+ * Event name: `expand`
+ */
+type TreeExpandDetail = {
+  readonly node: TreeNode;
+  readonly depth: number;
+};
+/**
+ * Fired when a node or column is collapsed.
+ * Event name: `collapse`
+ */
+type TreeCollapseDetail = {
+  readonly node: TreeNode;
+  readonly depth: number;
+};
+type TreeSelectEvent = CustomEvent<TreeSelectDetail>;
+type TreeTickleEvent = CustomEvent<TreeTickleDetail>;
+type TreeActivateEvent = CustomEvent<TreeActivateDetail>;
+type TreeItemClickEvent = CustomEvent<TreeItemClickDetail>;
+type TreeExpandEvent = CustomEvent<TreeExpandDetail>;
+type TreeCollapseEvent = CustomEvent<TreeCollapseDetail>;
+interface TreeComponentEventMap {
+  'select': TreeSelectEvent;
+  'tickle': TreeTickleEvent;
+  'activate': TreeActivateEvent;
+  'item-click': TreeItemClickEvent;
+  'expand': TreeExpandEvent;
+  'collapse': TreeCollapseEvent;
+}
+/**
+ * The common interface all tree-like components must implement.
+ *
+ * Use this interface when writing controllers or utilities that should work
+ * across different tree component implementations.
+ *
+ * @example Writing a controller that works with any tree component:
+ * ```typescript
+ * function attachMyController(component: TreeComponent) {
+ *   component.addEventListener('select', e => console.log(e.detail.selected));
+ * }
+ * ```
+ */
+interface TreeComponent extends EventTarget {
+  /**
+   * Root node of the tree.
+   * Set this directly for static/fully-known trees.
+   * Use `model` for lazy-loaded or programmatically mutated trees.
+   */
+  root: TreeNode | undefined;
+  /**
+   * Optional data model providing lazy loading, caching, and mutation helpers.
+   * When set, the component uses `model.getChildren()` instead of `loadChildren`,
+   * and re-renders when the model notifies of root or invalidation changes.
+   * `model` takes precedence over `loadChildren` when both are set.
+   */
+  model: TreeDataModel | undefined;
+  /**
+   * Callback for lazily loading children of a node.
+   * Superseded by `model` when both are set.
+   * Kept for backwards compatibility and simple use-cases.
+   */
+  loadChildren: LoadChildrenCallback | undefined;
+  /**
+   * The primary/most-recently selected node, or `undefined` if nothing is selected.
+   * In multi-selection modes (e.g. `interactionMode='standard'` with Ctrl+click) this is the most recently added node.
+   */
+  selectedNode: TreeNode | undefined;
+  /**
+   * The full selection set. Always in sync with `selectedNode`.
+   * Empty set when nothing is selected.
+   */
+  readonly selectedNodes: ReadonlySet<TreeNode>;
+  /**
+   * Restricts which kinds of nodes may be selected. Applied as a guard in all interaction modes.
+   * Reflected as the `selection-filter` attribute.
+   * @default 'leaf'
+   */
+  selectionFilter: TreeSelectionFilter;
+  /**
+   * Predicate used by search/filter controllers.
+   * When set, nodes for which the predicate returns `false` (and which have no
+   * matching descendants) are hidden from the rendered output.
+   */
+  filterPredicate: TreeFilterPredicate | undefined;
+  /**
+   * Controls how expanding one node affects other expanded nodes.
+   * Reflected as the `exclusivity` attribute.
+   * @default 'none'
+   */
+  exclusivity: TreeExclusivity;
+  /** Select `node`, replacing any current selection. Respects `selectionFilter` — no-op if the node is not selectable. */
+  select(node: TreeNode): void;
+  /** Remove `node` from the selection. */
+  deselect(node: TreeNode): void;
+  /** Clear the entire selection. */
+  clearSelection(): void;
+  /**
+   * Expand ancestors and select the node reached by following `keys` from the root's children.
+   * Returns `true` if the path was found and applied.
+   */
+  navigateTo(keys: readonly string[]): boolean;
+  /**
+   * Expand ancestors and select the first node for which `predicate` returns `true`.
+   * Returns `true` if a matching node was found.
+   */
+  navigateToNode(predicate: (node: TreeNode) => boolean): boolean;
+  /**
+   * Returns all nodes currently visible in the rendered output, in render order,
+   * with their depth (0-based, root's children are depth 0).
+   */
+  getNodes(): ReadonlyArray<{
+    node: TreeNode;
+    depth: number;
+  }>;
+}
+/**
+ * Extended interface used by search/filter controllers.
+ * Both TreeBaseElement and MillerBaseElement implement this.
+ *
+ * Replaces the previous separate `TreeSearchHost` / `MillerSearchHost` types
+ * in `searchable.ts`. The unified `filterPredicate` signature (with `depth`)
+ * allows a single search controller implementation to work with all tree components.
+ */
+interface TreeSearchHost extends TreeComponent {
+  readonly shadowRoot: ShadowRoot | null;
+  readonly updateComplete: Promise<boolean>;
+}
+//#endregion
+export { TreeNode as C, TreeItem as S, TreeDataModelOptions as _, TreeComponent as a, TreeFilterPredicate as b, TreeExpandEvent as c, TreeSearchHost as d, TreeSelectDetail as f, TreeDataModel as g, TreeTickleEvent as h, TreeCollapseEvent as i, TreeItemClickDetail as l, TreeTickleDetail as m, TreeActivateEvent as n, TreeComponentEventMap as o, TreeSelectEvent as p, TreeCollapseDetail as r, TreeExpandDetail as s, TreeActivateDetail as t, TreeItemClickEvent as u, LoadChildrenCallback as v, TreeSelectionFilter as w, TreeInteractionMode as x, TreeExclusivity as y };
+//# sourceMappingURL=tree-component-CQpoPo4s.d.ts.map

package/dist/tree-component-CQpoPo4s.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-component-CQpoPo4s.d.ts","names":[],"sources":["../src/common/types.ts","../src/common/tree-data-model.ts","../src/common/tree-component.ts"],"mappings":"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"}

package/dist/tree-data-model-DGvRVOFY.js

@@ -0,0 +1,190 @@
+//#region src/common/tree-data-model.ts
+function findNode(root, key) {
+	if (root.item.key === key) return root;
+	if (!root.children) return void 0;
+	for (const child of root.children) {
+		const found = findNode(child, key);
+		if (found) return found;
+	}
+}
+/** Return a new root with the node at `key` replaced by `replacer(node)`. */
+function mapNode(root, key, replacer) {
+	if (root.item.key === key) return replacer(root);
+	if (!root.children) return root;
+	return {
+		item: root.item,
+		children: root.children.map((c) => mapNode(c, key, replacer))
+	};
+}
+/** Return a new root with `newChild` appended to the children of the node at `parentKey`. */
+function addChildTo(root, parentKey, newChild) {
+	return mapNode(root, parentKey, (parent) => ({
+		item: parent.item,
+		children: [...parent.children ?? [], newChild]
+	}));
+}
+/** Return a new root with the node at `key` removed (along with all its descendants). */
+function removeNodeFrom(root, key) {
+	if (!root.children) return root;
+	return {
+		item: root.item,
+		children: root.children.filter((c) => c.item.key !== key).map((c) => removeNodeFrom(c, key))
+	};
+}
+/** Return a new root with the node at `key` moved to become a child of `newParentKey`. */
+function moveNodeTo(root, key, newParentKey) {
+	const target = findNode(root, key);
+	if (!target) return root;
+	return addChildTo(removeNodeFrom(root, key), newParentKey, target);
+}
+/**
+* Manages tree data for tree-like components.
+*
+* Handles two concerns:
+* 1. **Lazy loading** — caches children fetched via `loadChildren` and can invalidate
+*    specific branches so they are re-fetched on next expand.
+* 2. **Structural mutations** — convenience methods to add, remove, update, or move
+*    nodes. Each mutation produces a new immutable root and notifies connected components.
+*
+* Assign an instance to a component's `model` property instead of setting `root`/`loadChildren`
+* directly. The same model instance can be shared across multiple components.
+*
+* @example
+* ```typescript
+* const model = new TreeDataModel({
+*   root: { item: { key: 'root', label: 'Root' }, children: [] },
+*   loadChildren: async (node, depth, signal) => fetchChildren(node.item.key),
+* });
+* myTreeList.model = model;
+* myMillerList.model = model;
+*
+* // Later — invalidate a branch to force a re-fetch on next expand:
+* model.invalidate('some-key');
+* ```
+*/
+var TreeDataModel = class {
+	#root;
+	#loadChildren;
+	#cache = /* @__PURE__ */ new Map();
+	#subscribers = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.#root = options.root;
+		this.#loadChildren = options.loadChildren;
+	}
+	/** The current immutable root snapshot. */
+	get root() {
+		return this.#root;
+	}
+	/**
+	* Replace the entire root with a new immutable snapshot.
+	* All cached children are cleared. Connected components re-render.
+	*/
+	setRoot(root) {
+		this.#root = root;
+		this.#cache.clear();
+		this.#notify({
+			type: "root",
+			root
+		});
+	}
+	/**
+	* Returns children for the given node.
+	* If children are cached, they are returned immediately (as a resolved Promise).
+	* Otherwise the `loadChildren` callback is invoked and the result is cached.
+	* If no `loadChildren` is set and no cache entry exists, returns `[]`.
+	*
+	* Called by components internally — not typically called by application code.
+	*/
+	async getChildren(node, depth, signal) {
+		const key = node.item.key;
+		if (this.#cache.has(key)) return this.#cache.get(key);
+		if (!this.#loadChildren) return [];
+		const result = await this.#loadChildren(node, depth, signal);
+		if (!signal.aborted) this.#cache.set(key, result);
+		return result;
+	}
+	/**
+	* Clears the cached children for the node with the given key.
+	* Connected components will collapse that node (if currently expanded), so that
+	* the next expand triggers a fresh `loadChildren` call.
+	*/
+	invalidate(key) {
+		this.#cache.delete(key);
+		this.#notify({
+			type: "invalidate",
+			key
+		});
+	}
+	/**
+	* Adds `node` as a child of the node identified by `parentKey`.
+	* Returns the new root (connected components are notified automatically).
+	*/
+	addNode(parentKey, node) {
+		this.#root = addChildTo(this.#root, parentKey, node);
+		this.#notify({
+			type: "root",
+			root: this.#root
+		});
+		return this.#root;
+	}
+	/**
+	* Removes the node with the given key and all its descendants.
+	* Returns the new root (connected components are notified automatically).
+	*/
+	removeNode(key) {
+		this.#cache.delete(key);
+		this.#root = removeNodeFrom(this.#root, key);
+		this.#notify({
+			type: "root",
+			root: this.#root
+		});
+		return this.#root;
+	}
+	/**
+	* Applies a partial update to the `item` of the node with the given key.
+	* Returns the new root (connected components are notified automatically).
+	*/
+	updateItem(key, patch) {
+		this.#root = mapNode(this.#root, key, (n) => ({
+			item: {
+				...n.item,
+				...patch
+			},
+			children: n.children
+		}));
+		this.#notify({
+			type: "root",
+			root: this.#root
+		});
+		return this.#root;
+	}
+	/**
+	* Moves the node with the given key to become a child of `newParentKey`.
+	* Returns the new root (connected components are notified automatically).
+	*/
+	moveNode(key, newParentKey) {
+		this.#root = moveNodeTo(this.#root, key, newParentKey);
+		this.#notify({
+			type: "root",
+			root: this.#root
+		});
+		return this.#root;
+	}
+	/**
+	* Subscribe to model events. Returns an unsubscribe function.
+	* Components call this when the `model` property is set, and unsubscribe when it is unset.
+	*
+	* @internal
+	*/
+	_subscribe(callback) {
+		this.#subscribers.add(callback);
+		return () => this.#subscribers.delete(callback);
+	}
+	#notify(event) {
+		for (const sub of this.#subscribers) sub(event);
+	}
+};
+//#endregion
+export { TreeDataModel as t };
+
+//# sourceMappingURL=tree-data-model-DGvRVOFY.js.map

package/dist/tree-data-model-DGvRVOFY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-data-model-DGvRVOFY.js","names":["#root","#loadChildren","#cache","#notify","#subscribers"],"sources":["../src/common/tree-data-model.ts"],"sourcesContent":["import type { LoadChildrenCallback, TreeItem, TreeNode } from './types.js';\n\n// ---------------------------------------------------------------------------\n// Subscription event types (internal — not part of the public API)\n// ---------------------------------------------------------------------------\n\ntype InvalidateEvent = { type: 'invalidate'; key: string };\ntype RootEvent = { type: 'root'; root: TreeNode };\ntype ModelEvent = InvalidateEvent | RootEvent;\n\ntype ModelSubscriber = (event: ModelEvent) => void;\n\n// ---------------------------------------------------------------------------\n// Pure tree-mutation helpers (functional, produce new roots)\n// ---------------------------------------------------------------------------\n\nfunction cloneNode(node: TreeNode): TreeNode {\n  if (node.children === undefined) return { item: { ...node.item } };\n  return { item: { ...node.item }, children: node.children.map(cloneNode) };\n}\n\nfunction findNode(root: TreeNode, key: string): TreeNode | undefined {\n  if (root.item.key === key) return root;\n  if (!root.children) return undefined;\n  for (const child of root.children) {\n    const found = findNode(child, key);\n    if (found) return found;\n  }\n  return undefined;\n}\n\n/** Return a new root with the node at `key` replaced by `replacer(node)`. */\nfunction mapNode(root: TreeNode, key: string, replacer: (n: TreeNode) => TreeNode): TreeNode {\n  if (root.item.key === key) return replacer(root);\n  if (!root.children) return root;\n  return { item: root.item, children: root.children.map(c => mapNode(c, key, replacer)) };\n}\n\n/** Return a new root with `newChild` appended to the children of the node at `parentKey`. */\nfunction addChildTo(root: TreeNode, parentKey: string, newChild: TreeNode): TreeNode {\n  return mapNode(root, parentKey, parent => ({\n    item: parent.item,\n    children: [...(parent.children ?? []), newChild],\n  }));\n}\n\n/** Return a new root with the node at `key` removed (along with all its descendants). */\nfunction removeNodeFrom(root: TreeNode, key: string): TreeNode {\n  if (!root.children) return root;\n  return {\n    item: root.item,\n    children: root.children\n      .filter(c => c.item.key !== key)\n      .map(c => removeNodeFrom(c, key)),\n  };\n}\n\n/** Return a new root with the node at `key` moved to become a child of `newParentKey`. */\nfunction moveNodeTo(root: TreeNode, key: string, newParentKey: string): TreeNode {\n  const target = findNode(root, key);\n  if (!target) return root;\n  const withoutTarget = removeNodeFrom(root, key);\n  return addChildTo(withoutTarget, newParentKey, target);\n}\n\n// ---------------------------------------------------------------------------\n// TreeDataModelOptions\n// ---------------------------------------------------------------------------\n\nexport type TreeDataModelOptions = {\n  /** The initial root node. Required. */\n  root: TreeNode;\n  /**\n   * Optional callback for lazily loading children.\n   * If omitted, nodes with `children === undefined` are treated as empty branches.\n   */\n  loadChildren?: LoadChildrenCallback;\n};\n\n// ---------------------------------------------------------------------------\n// TreeDataModel\n// ---------------------------------------------------------------------------\n\n/**\n * Manages tree data for tree-like components.\n *\n * Handles two concerns:\n * 1. **Lazy loading** — caches children fetched via `loadChildren` and can invalidate\n *    specific branches so they are re-fetched on next expand.\n * 2. **Structural mutations** — convenience methods to add, remove, update, or move\n *    nodes. Each mutation produces a new immutable root and notifies connected components.\n *\n * Assign an instance to a component's `model` property instead of setting `root`/`loadChildren`\n * directly. The same model instance can be shared across multiple components.\n *\n * @example\n * ```typescript\n * const model = new TreeDataModel({\n *   root: { item: { key: 'root', label: 'Root' }, children: [] },\n *   loadChildren: async (node, depth, signal) => fetchChildren(node.item.key),\n * });\n * myTreeList.model = model;\n * myMillerList.model = model;\n *\n * // Later — invalidate a branch to force a re-fetch on next expand:\n * model.invalidate('some-key');\n * ```\n */\nexport class TreeDataModel {\n  #root: TreeNode;\n  #loadChildren: LoadChildrenCallback | undefined;\n  #cache = new Map<string, TreeNode[]>();\n  #subscribers = new Set<ModelSubscriber>();\n\n  constructor(options: TreeDataModelOptions) {\n    this.#root = options.root;\n    this.#loadChildren = options.loadChildren;\n  }\n\n  // ---------------------------------------------------------------------------\n  // Root\n  // ---------------------------------------------------------------------------\n\n  /** The current immutable root snapshot. */\n  get root(): TreeNode {\n    return this.#root;\n  }\n\n  /**\n   * Replace the entire root with a new immutable snapshot.\n   * All cached children are cleared. Connected components re-render.\n   */\n  setRoot(root: TreeNode): void {\n    this.#root = root;\n    this.#cache.clear();\n    this.#notify({ type: 'root', root });\n  }\n\n  // ---------------------------------------------------------------------------\n  // Child loading\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Returns children for the given node.\n   * If children are cached, they are returned immediately (as a resolved Promise).\n   * Otherwise the `loadChildren` callback is invoked and the result is cached.\n   * If no `loadChildren` is set and no cache entry exists, returns `[]`.\n   *\n   * Called by components internally — not typically called by application code.\n   */\n  async getChildren(node: TreeNode, depth: number, signal: AbortSignal): Promise<TreeNode[]> {\n    const key = node.item.key;\n    if (this.#cache.has(key)) {\n      return this.#cache.get(key)!;\n    }\n    if (!this.#loadChildren) {\n      return [];\n    }\n    const result = await this.#loadChildren(node, depth, signal);\n    if (!signal.aborted) {\n      this.#cache.set(key, result);\n    }\n    return result;\n  }\n\n  // ---------------------------------------------------------------------------\n  // Cache invalidation\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Clears the cached children for the node with the given key.\n   * Connected components will collapse that node (if currently expanded), so that\n   * the next expand triggers a fresh `loadChildren` call.\n   */\n  invalidate(key: string): void {\n    this.#cache.delete(key);\n    this.#notify({ type: 'invalidate', key });\n  }\n\n  // ---------------------------------------------------------------------------\n  // Convenience mutators\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Adds `node` as a child of the node identified by `parentKey`.\n   * Returns the new root (connected components are notified automatically).\n   */\n  addNode(parentKey: string, node: TreeNode): TreeNode {\n    this.#root = addChildTo(this.#root, parentKey, node);\n    this.#notify({ type: 'root', root: this.#root });\n    return this.#root;\n  }\n\n  /**\n   * Removes the node with the given key and all its descendants.\n   * Returns the new root (connected components are notified automatically).\n   */\n  removeNode(key: string): TreeNode {\n    this.#cache.delete(key);\n    this.#root = removeNodeFrom(this.#root, key);\n    this.#notify({ type: 'root', root: this.#root });\n    return this.#root;\n  }\n\n  /**\n   * Applies a partial update to the `item` of the node with the given key.\n   * Returns the new root (connected components are notified automatically).\n   */\n  updateItem(key: string, patch: Partial<TreeItem>): TreeNode {\n    this.#root = mapNode(this.#root, key, n => ({\n      item: { ...n.item, ...patch },\n      children: n.children,\n    }));\n    this.#notify({ type: 'root', root: this.#root });\n    return this.#root;\n  }\n\n  /**\n   * Moves the node with the given key to become a child of `newParentKey`.\n   * Returns the new root (connected components are notified automatically).\n   */\n  moveNode(key: string, newParentKey: string): TreeNode {\n    this.#root = moveNodeTo(this.#root, key, newParentKey);\n    this.#notify({ type: 'root', root: this.#root });\n    return this.#root;\n  }\n\n  // ---------------------------------------------------------------------------\n  // Internal subscription (used by components — not part of the public API)\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Subscribe to model events. Returns an unsubscribe function.\n   * Components call this when the `model` property is set, and unsubscribe when it is unset.\n   *\n   * @internal\n   */\n  _subscribe(callback: ModelSubscriber): () => void {\n    this.#subscribers.add(callback);\n    return () => this.#subscribers.delete(callback);\n  }\n\n  #notify(event: ModelEvent): void {\n    for (const sub of this.#subscribers) {\n      sub(event);\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/tree.d.ts

@@ -0,0 +1,100 @@
+import { n as TraversableTree, t as TickledController } from "./tickled-controller-Cq1Va0rR.js";
+import { C as TreeNode, S as TreeItem, _ as TreeDataModelOptions, a as TreeComponent, b as TreeFilterPredicate, c as TreeExpandEvent, d as TreeSearchHost, f as TreeSelectDetail, g as TreeDataModel, h as TreeTickleEvent, i as TreeCollapseEvent, l as TreeItemClickDetail, m as TreeTickleDetail, n as TreeActivateEvent, o as TreeComponentEventMap, p as TreeSelectEvent, r as TreeCollapseDetail, s as TreeExpandDetail, t as TreeActivateDetail, u as TreeItemClickEvent, v as LoadChildrenCallback, w as TreeSelectionFilter, x as TreeInteractionMode, y as TreeExclusivity } from "./tree-component-CQpoPo4s.js";
+import { t as TreeConfig } from "./types-BKaqnpwx.js";
+import * as _$lit from "lit";
+import { LitElement, PropertyValues, TemplateResult, nothing } from "lit";
+
+//#region src/tree/tree-base.d.ts
+declare class TreeBaseElement extends LitElement implements TreeComponent, TreeSearchHost {
+  #private;
+  root: TreeNode | undefined;
+  model: TreeDataModel | undefined;
+  /** Callback to lazily load children for a node. Superseded by `model` when both are set. */
+  loadChildren: LoadChildrenCallback | undefined;
+  exclusivity: TreeExclusivity;
+  selectionFilter: TreeSelectionFilter;
+  /** Controls how pointer/keyboard gestures map to selection changes. Default: `'standard'`. */
+  interactionMode: TreeInteractionMode;
+  selectedNode: TreeNode | undefined;
+  protected _selectedNodes: Set<TreeNode>;
+  get selectedNodes(): ReadonlySet<TreeNode>;
+  filterPredicate: TreeFilterPredicate | undefined;
+  disableKeyboardNavigation: boolean;
+  protected _expandedKeys: Set<string>;
+  protected tickled: TickledController<string>;
+  protected _focusedDepth: number;
+  updated(changedProps: PropertyValues): void;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  getConfig(): TreeConfig;
+  setConfig(config: Partial<TreeConfig>): void;
+  select(node: TreeNode): void;
+  deselect(node: TreeNode): void;
+  clearSelection(): void;
+  navigateTo(keys: readonly string[]): boolean;
+  navigateToNode(predicate: (node: TreeNode) => boolean): boolean;
+  getNodes(): ReadonlyArray<{
+    node: TreeNode;
+    depth: number;
+  }>;
+  protected renderNodeContent(node: TreeNode, _depth: number): TemplateResult | typeof nothing;
+  protected _handleItemClick(node: TreeNode, depth: number, event?: MouseEvent): void;
+  protected _handleCheckboxClick(event: MouseEvent, node: TreeNode, _depth: number): void;
+  protected _isSelected(node: TreeNode): boolean;
+  protected _isFocused(node: TreeNode): boolean;
+  protected _isExpanded(node: TreeNode): boolean;
+  protected get _pendingNode(): TreeNode | undefined;
+  protected renderLoadingIndicator(): TemplateResult | typeof nothing;
+  protected render(): TemplateResult<1>;
+  protected _renderNode(node: TreeNode, depth: number): TemplateResult;
+  static styles: _$lit.CSSResult[];
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-tree-base': TreeBaseElement;
+  }
+}
+interface TreeBaseElementEventMap extends TreeComponentEventMap {
+  'item-click': TreeItemClickEvent;
+  'expand': TreeExpandEvent;
+  'collapse': TreeCollapseEvent;
+  'select': TreeSelectEvent;
+  'tickle': TreeTickleEvent;
+  'activate': TreeActivateEvent;
+}
+interface TreeBaseElement {
+  addEventListener: (<K extends keyof TreeBaseElementEventMap>(type: K, listener: (this: TreeBaseElement, event: TreeBaseElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+  removeEventListener: (<K extends keyof TreeBaseElementEventMap>(type: K, listener: (this: TreeBaseElement, event: TreeBaseElementEventMap[K]) => void, options?: boolean | EventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions) => void);
+}
+//#endregion
+//#region src/tree/tree-controller.d.ts
+type TreeControllerOptions<T> = {
+  valueToItem: (value: T, node: TraversableTree<T>) => TreeItem;
+};
+declare class TreeController<T> {
+  #private;
+  constructor(root: TraversableTree<T>, element: TreeBaseElement, options: TreeControllerOptions<T>);
+  connect(): void;
+  disconnect(): void;
+  navigateToValue(predicate: (value: T) => boolean): boolean;
+}
+//#endregion
+//#region src/tree/tree-list.d.ts
+declare class TreeListElement extends TreeBaseElement {
+  #private;
+  protected render(): TemplateResult<1>;
+  protected renderNodeContent(node: TreeNode, depth: number): TemplateResult;
+  protected _renderNode(node: TreeNode, depth: number): TemplateResult;
+  static styles: _$lit.CSSResult[];
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-tree-list': TreeListElement;
+  }
+}
+interface TreeListElement {
+  addEventListener: (<K extends keyof TreeBaseElementEventMap>(type: K, listener: (this: TreeListElement, event: TreeBaseElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+}
+//#endregion
+export { LoadChildrenCallback, TreeActivateDetail, TreeActivateEvent, TreeBaseElement, TreeBaseElementEventMap, TreeCollapseDetail, TreeCollapseEvent, TreeComponentEventMap, TreeConfig, TreeController, TreeControllerOptions, TreeDataModel, TreeDataModelOptions, TreeExclusivity, TreeExpandDetail, TreeExpandEvent, TreeFilterPredicate, TreeItem, TreeItemClickDetail, TreeItemClickEvent, TreeListElement, TreeNode, TreeSelectDetail, TreeSelectEvent, TreeSelectionFilter, TreeTickleDetail, TreeTickleEvent };
+//# sourceMappingURL=tree.d.ts.map

package/dist/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","names":[],"sources":["../src/tree/tree-base.ts","../src/tree/tree-controller.ts","../src/tree/tree-list.ts"],"mappings":"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"}