@aceshooting/lyra-ui 2.0.0 → 2.2.0

package/dist/components/tree/tree.class.d.ts

@@ -0,0 +1,130 @@
+import { type PropertyValues, type TemplateResult } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+import './tree-node.class.js';
+export interface TreeItem {
+    id: string;
+    label: string;
+    children?: TreeItem[];
+    badge?: string | number;
+}
+/**
+ * `<lyra-tree>` — an expand/collapse hierarchy for graph/document navigation.
+ *
+ * Implements the WAI-ARIA treeitem keyboard pattern: a single roving
+ * `tabindex` (tracked here as `activeId`, pushed down to every
+ * `<lyra-tree-node>` — including nested ones, recursively) and
+ * ArrowUp/Down/Right/Left/Home/End/Enter/Space handled by one delegated
+ * `keydown` listener. Native `KeyboardEvent`s are `composed: true` and
+ * bubble across shadow-DOM boundaries, so a press inside a deeply-nested
+ * `<lyra-tree-node>`'s own shadow root still reaches this listener.
+ *
+ * @customElement lyra-tree
+ * @event lyra-node-toggle - `detail: { id, expanded }`, dispatched by a descendant `<lyra-tree-node>` and observed here (bubbling, composed) to keep the roving-tabindex `activeId` in sync.
+ * @event lyra-node-select - `detail: { id }`, dispatched by a descendant `<lyra-tree-node>` and observed here (bubbling, composed) to keep the roving-tabindex `activeId` in sync.
+ * @csspart base
+ * @slot - `<lyra-tree-node>` elements (top-level tree items).
+ */
+export declare class LyraTree extends LyraElement {
+    static styles: import("lit").CSSResultGroup[];
+    data: TreeItem[];
+    /** Accessible name for the tree -- `role="tree"` lives on an internal element, not the host, so `aria-label`/`aria-labelledby` set directly on `<lyra-tree>` would not label it. */
+    label: string;
+    private activeId;
+    /** Set by `willUpdate()` when a `data` reassignment removes the node that currently holds real DOM focus; consumed by `updated()` to refocus the newly-designated `activeId` node once it's actually focusable. */
+    private pendingFocusId;
+    private get nodeElements();
+    private childrenOf;
+    /**
+     * Every currently *visible* (ancestor-expanded) node, top-to-bottom.
+     *
+     * Recomputed on every call rather than memoized: `item`/`expanded` are
+     * plain public settable properties on `<lyra-tree-node>` (not just
+     * reachable through this class's own `data` setter or the bubbling
+     * `lyra-node-toggle` event), so a cache keyed off those two entry points
+     * alone would go stale the moment a caller mutated a node directly --
+     * e.g. `node.item = { ...node.item, children: [...] }` to append a child
+     * in place. This walk only runs from user-paced `keydown` handling (never
+     * a hot render-loop path), so the cost of a `shadowRoot.querySelectorAll`
+     * per currently-expanded node is not worth trading for that staleness risk.
+     */
+    private visibleNodeElements;
+    private findItem;
+    protected willUpdate(changed: PropertyValues): void;
+    protected updated(changed: PropertyValues): void;
+    /** By-id reconciliation of top-level items: reuses/reorders existing `<lyra-tree-node>` elements and removes ones no longer present in `data`. */
+    private syncNodes;
+    private focusNode;
+    /**
+     * A mouse click always lands directly on the node it interacts with --
+     * `select()`/`expand()`/`collapse()` all emit their own node's id --
+     * independent of whatever `activeId` currently holds. Sync `activeId` to
+     * that id here so a click always becomes the tree's new roving-tabindex
+     * target: this keeps it aligned with real DOM focus, keeps the next
+     * arrow-key press relative to the item the user just clicked (rather than
+     * a stale `activeId`), and keeps `activeId` valid when a click collapses
+     * an ancestor of the previously-active node -- the collapsed node's own
+     * id (always still visible, since collapsing never removes a node's own
+     * top-level or already-rendered self) replaces the now-hidden descendant's
+     * id, so at least one node keeps a roving tabindex of 0. Keyboard-driven
+     * toggles/selects always target the already-active node, so this is a
+     * same-value, no-op assignment for them.
+     */
+    private onNodeActivate;
+    /**
+     * `updated()` only pushes the new `activeId` to *top-level* nodes; nested
+     * nodes only receive it once their ancestor chain's own renders cascade it
+     * down (one more pending update per depth level). Cascade `updateComplete`
+     * to match (see `cascadeUpdateComplete`), so `focusNode()`'s `.focus()`
+     * call never runs while a nested target is still mid-cascade -- `.focus()`
+     * on an element with no `tabindex` attribute committed yet is a silent
+     * no-op.
+     *
+     * The `pendingFocusId` refocus (set by `willUpdate()` when a `data`
+     * reassignment removes the node that currently holds real DOM focus) is
+     * also resolved *here*, after the cascade above, rather than from
+     * `updated()` firing a detached `void this.updateComplete.then(...)` of
+     * its own: `updateComplete`'s getter (see the base class) calls this
+     * method fresh on *every* access rather than caching one promise, so a
+     * second, independent invocation started from inside `updated()` isn't
+     * the same promise chain a caller's own `await el.updateComplete` is
+     * following -- both ultimately settle once the same underlying update
+     * resolves, but as separate chains their `.then()` continuations aren't
+     * ordered against each other, so a caller's `await` can win the race and
+     * observe focus *not yet* restored. Doing the refocus inline, before this
+     * method's own `await` chain resolves, makes it unconditionally part of
+     * whatever `updateComplete` promise every caller (this class's own
+     * `focusNode()` included) is already waiting on.
+     */
+    protected getUpdateComplete(): Promise<boolean>;
+    private onTreeKeyDown;
+    /**
+     * Expand every node in the tree, recursively. Resolves once every
+     * descendant has actually finished expanding (not just had `expanded` set)
+     * -- callers that immediately read `visibleNodeElements()`-derived state
+     * (or call `collapseAll()` right after) should `await` this instead of
+     * firing it and moving on.
+     *
+     * Guarded on `n.hasChildren`, matching `expand()`'s own invariant -- a leaf
+     * node's `expanded` must never be set to `true`, since `collapse()` (and
+     * this method's own counterpart, `collapseAll()`) refuse to act on a node
+     * that's `!hasChildren`, which would otherwise leave the leaf permanently
+     * stuck with a reflected `expanded` attribute nothing can clear.
+     */
+    expandAll(): Promise<void>;
+    /**
+     * Collapse every node in the tree, recursively. Goes through each node's
+     * own `collapse()` (rather than assigning `expanded` directly) so its
+     * `lyra-node-toggle` emit reaches `onNodeActivate` -- that keeps `activeId`
+     * re-synced to a node that's still visible after collapsing, even when the
+     * roving-tabindex target was a nested descendant whose ancestor's
+     * `role="group"` is about to disappear.
+     */
+    collapseAll(): void;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-tree': LyraTree;
+    }
+}
+//# sourceMappingURL=tree.class.d.ts.map

package/dist/components/tree/tree.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.class.d.ts","sourceRoot":"","sources":["../../../src/components/tree/tree.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAE9E,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAK7D,OAAO,sBAAsB,CAAC;AAG9B,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,QAAS,SAAQ,WAAW;IACvC,MAAM,CAAC,MAAM,iCAAgC;IAEb,IAAI,EAAE,QAAQ,EAAE,CAAM;IACtD,oLAAoL;IACxK,KAAK,SAAM;IAEd,OAAO,CAAC,QAAQ,CAAuB;IAChD,mNAAmN;IACnN,OAAO,CAAC,cAAc,CAAuB;IAE7C,OAAO,KAAK,YAAY,GAEvB;IAED,OAAO,CAAC,UAAU;IAIlB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,QAAQ;IAShB,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAgBlD;IAED,SAAS,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAS/C;IAED,kJAAkJ;IAClJ,OAAO,CAAC,SAAS;IAwBjB,OAAO,CAAC,SAAS;IAMjB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,cAAc,CAEpB;IAEF;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,UAAgB,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CASpD;IAED,OAAO,CAAC,aAAa,CA2DnB;IAEF;;;;;;;;;;;;OAYG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAW/B;IAED;;;;;;;OAOG;IACH,WAAW,IAAI,IAAI,CAQlB;IAED,MAAM,IAAI,cAAc,CAavB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,WAAW,EAAE,QAAQ,CAAC;KACvB;CACF"}

package/dist/components/tree/tree.class.js

@@ -0,0 +1,326 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { html, nothing } from 'lit';
+import { property, state } from 'lit/decorators.js';
+import { LyraElement } from '../../internal/lyra-element.js';
+import { tag } from '../../internal/prefix.js';
+import { isRtl } from '../../internal/rtl.js';
+import { styles } from './tree.styles.js';
+import { cascadeUpdateComplete } from './update-cascade.js';
+import './tree-node.class.js';
+/**
+ * `<lyra-tree>` — an expand/collapse hierarchy for graph/document navigation.
+ *
+ * Implements the WAI-ARIA treeitem keyboard pattern: a single roving
+ * `tabindex` (tracked here as `activeId`, pushed down to every
+ * `<lyra-tree-node>` — including nested ones, recursively) and
+ * ArrowUp/Down/Right/Left/Home/End/Enter/Space handled by one delegated
+ * `keydown` listener. Native `KeyboardEvent`s are `composed: true` and
+ * bubble across shadow-DOM boundaries, so a press inside a deeply-nested
+ * `<lyra-tree-node>`'s own shadow root still reaches this listener.
+ *
+ * @customElement lyra-tree
+ * @event lyra-node-toggle - `detail: { id, expanded }`, dispatched by a descendant `<lyra-tree-node>` and observed here (bubbling, composed) to keep the roving-tabindex `activeId` in sync.
+ * @event lyra-node-select - `detail: { id }`, dispatched by a descendant `<lyra-tree-node>` and observed here (bubbling, composed) to keep the roving-tabindex `activeId` in sync.
+ * @csspart base
+ * @slot - `<lyra-tree-node>` elements (top-level tree items).
+ */
+export class LyraTree extends LyraElement {
+    constructor() {
+        super(...arguments);
+        this.data = [];
+        /** Accessible name for the tree -- `role="tree"` lives on an internal element, not the host, so `aria-label`/`aria-labelledby` set directly on `<lyra-tree>` would not label it. */
+        this.label = '';
+        this.activeId = null;
+        /** Set by `willUpdate()` when a `data` reassignment removes the node that currently holds real DOM focus; consumed by `updated()` to refocus the newly-designated `activeId` node once it's actually focusable. */
+        this.pendingFocusId = null;
+        /**
+         * A mouse click always lands directly on the node it interacts with --
+         * `select()`/`expand()`/`collapse()` all emit their own node's id --
+         * independent of whatever `activeId` currently holds. Sync `activeId` to
+         * that id here so a click always becomes the tree's new roving-tabindex
+         * target: this keeps it aligned with real DOM focus, keeps the next
+         * arrow-key press relative to the item the user just clicked (rather than
+         * a stale `activeId`), and keeps `activeId` valid when a click collapses
+         * an ancestor of the previously-active node -- the collapsed node's own
+         * id (always still visible, since collapsing never removes a node's own
+         * top-level or already-rendered self) replaces the now-hidden descendant's
+         * id, so at least one node keeps a roving tabindex of 0. Keyboard-driven
+         * toggles/selects always target the already-active node, so this is a
+         * same-value, no-op assignment for them.
+         */
+        this.onNodeActivate = (e) => {
+            this.activeId = e.detail.id;
+        };
+        this.onTreeKeyDown = (e) => {
+            const visible = this.visibleNodeElements();
+            if (visible.length === 0)
+                return;
+            const currentIndex = visible.findIndex((n) => n.item.id === this.activeId);
+            const current = currentIndex >= 0 ? visible[currentIndex] : visible[0];
+            // Expand/step-in and collapse/step-out are physical-direction actions --
+            // swap which arrow key does which in RTL, matching split.ts/time-range.ts.
+            const rtl = isRtl(this);
+            const expandKey = rtl ? 'ArrowLeft' : 'ArrowRight';
+            const collapseKey = rtl ? 'ArrowRight' : 'ArrowLeft';
+            switch (e.key) {
+                case 'ArrowDown':
+                    e.preventDefault();
+                    this.focusNode(visible[Math.min(visible.length - 1, currentIndex + 1)]);
+                    break;
+                case 'ArrowUp':
+                    e.preventDefault();
+                    this.focusNode(visible[Math.max(0, currentIndex - 1)]);
+                    break;
+                case 'Home':
+                    e.preventDefault();
+                    this.focusNode(visible[0]);
+                    break;
+                case 'End':
+                    e.preventDefault();
+                    this.focusNode(visible[visible.length - 1]);
+                    break;
+                case expandKey:
+                    e.preventDefault();
+                    if (!current.hasChildren)
+                        break;
+                    if (!current.expanded) {
+                        current.expand(); // focus stays put; a 2nd press steps into the first child
+                    }
+                    else {
+                        const child = visible[currentIndex + 1];
+                        if (child && child.depth > current.depth)
+                            this.focusNode(child);
+                    }
+                    break;
+                case collapseKey:
+                    e.preventDefault();
+                    if (current.hasChildren && current.expanded) {
+                        current.collapse();
+                    }
+                    else {
+                        for (let i = currentIndex - 1; i >= 0; i--) {
+                            if (visible[i].depth < current.depth) {
+                                this.focusNode(visible[i]);
+                                break;
+                            }
+                        }
+                    }
+                    break;
+                case 'Enter':
+                case ' ':
+                    e.preventDefault();
+                    current.select();
+                    break;
+                default:
+                    return;
+            }
+        };
+    }
+    static { this.styles = [LyraElement.styles, styles]; }
+    get nodeElements() {
+        return [...this.querySelectorAll(tag('tree-node'))];
+    }
+    childrenOf(node) {
+        return [...(node.shadowRoot?.querySelectorAll(tag('tree-node')) ?? [])];
+    }
+    /**
+     * Every currently *visible* (ancestor-expanded) node, top-to-bottom.
+     *
+     * Recomputed on every call rather than memoized: `item`/`expanded` are
+     * plain public settable properties on `<lyra-tree-node>` (not just
+     * reachable through this class's own `data` setter or the bubbling
+     * `lyra-node-toggle` event), so a cache keyed off those two entry points
+     * alone would go stale the moment a caller mutated a node directly --
+     * e.g. `node.item = { ...node.item, children: [...] }` to append a child
+     * in place. This walk only runs from user-paced `keydown` handling (never
+     * a hot render-loop path), so the cost of a `shadowRoot.querySelectorAll`
+     * per currently-expanded node is not worth trading for that staleness risk.
+     */
+    visibleNodeElements() {
+        const acc = [];
+        const walk = (nodes) => {
+            for (const n of nodes) {
+                acc.push(n);
+                if (n.expanded)
+                    walk(this.childrenOf(n));
+            }
+        };
+        walk(this.nodeElements);
+        return acc;
+    }
+    findItem(items, id) {
+        for (const item of items) {
+            if (item.id === id)
+                return item;
+            const nested = item.children && this.findItem(item.children, id);
+            if (nested)
+                return nested;
+        }
+        return undefined;
+    }
+    willUpdate(changed) {
+        if (changed.has('data')) {
+            // `document.activeElement` collapses to the outermost light-DOM node
+            // even when the real focus target is a nested descendant several
+            // shadow roots down, so this also catches a focused nested node whose
+            // top-level ancestor is about to be removed.
+            const focused = this.nodeElements.find((n) => n === document.activeElement);
+            this.syncNodes();
+            if (!this.activeId || !this.findItem(this.data, this.activeId)) {
+                this.activeId = this.data[0]?.id ?? null;
+            }
+            // `node.remove()` inside `syncNodes()` (per the DOM spec) already moved
+            // real focus off `focused` and onto <body> by this point; record the
+            // newly-resolved `activeId` so `updated()` can restore focus to it.
+            this.pendingFocusId = focused && !focused.isConnected ? this.activeId : null;
+        }
+    }
+    updated(changed) {
+        if (changed.has('activeId') || changed.has('data')) {
+            const count = this.data.length;
+            this.nodeElements.forEach((node, i) => {
+                node.activeId = this.activeId;
+                node.setSize = count;
+                node.posInSet = i + 1;
+            });
+        }
+    }
+    /** By-id reconciliation of top-level items: reuses/reorders existing `<lyra-tree-node>` elements and removes ones no longer present in `data`. */
+    syncNodes() {
+        const existingById = new Map();
+        for (const node of this.nodeElements) {
+            if (node.item)
+                existingById.set(node.item.id, node);
+        }
+        const seen = new Set();
+        let previousSibling = null;
+        for (const item of this.data) {
+            const reused = !seen.has(item.id) ? existingById.get(item.id) : undefined;
+            const node = reused ?? document.createElement(tag('tree-node'));
+            node.item = item;
+            node.depth = 0;
+            seen.add(item.id);
+            const targetPosition = previousSibling
+                ? previousSibling.nextElementSibling
+                : this.firstElementChild;
+            if (targetPosition !== node)
+                this.insertBefore(node, targetPosition);
+            previousSibling = node;
+        }
+        for (const [id, node] of existingById) {
+            if (!seen.has(id))
+                node.remove();
+        }
+    }
+    focusNode(node) {
+        if (!node)
+            return;
+        this.activeId = node.item.id;
+        node.focus();
+    }
+    /**
+     * `updated()` only pushes the new `activeId` to *top-level* nodes; nested
+     * nodes only receive it once their ancestor chain's own renders cascade it
+     * down (one more pending update per depth level). Cascade `updateComplete`
+     * to match (see `cascadeUpdateComplete`), so `focusNode()`'s `.focus()`
+     * call never runs while a nested target is still mid-cascade -- `.focus()`
+     * on an element with no `tabindex` attribute committed yet is a silent
+     * no-op.
+     *
+     * The `pendingFocusId` refocus (set by `willUpdate()` when a `data`
+     * reassignment removes the node that currently holds real DOM focus) is
+     * also resolved *here*, after the cascade above, rather than from
+     * `updated()` firing a detached `void this.updateComplete.then(...)` of
+     * its own: `updateComplete`'s getter (see the base class) calls this
+     * method fresh on *every* access rather than caching one promise, so a
+     * second, independent invocation started from inside `updated()` isn't
+     * the same promise chain a caller's own `await el.updateComplete` is
+     * following -- both ultimately settle once the same underlying update
+     * resolves, but as separate chains their `.then()` continuations aren't
+     * ordered against each other, so a caller's `await` can win the race and
+     * observe focus *not yet* restored. Doing the refocus inline, before this
+     * method's own `await` chain resolves, makes it unconditionally part of
+     * whatever `updateComplete` promise every caller (this class's own
+     * `focusNode()` included) is already waiting on.
+     */
+    async getUpdateComplete() {
+        const result = await super.getUpdateComplete();
+        await cascadeUpdateComplete(this.nodeElements);
+        if (this.pendingFocusId != null) {
+            const id = this.pendingFocusId;
+            this.pendingFocusId = null;
+            this.nodeElements.find((n) => n.item.id === id)?.focus();
+        }
+        return result;
+    }
+    /**
+     * Expand every node in the tree, recursively. Resolves once every
+     * descendant has actually finished expanding (not just had `expanded` set)
+     * -- callers that immediately read `visibleNodeElements()`-derived state
+     * (or call `collapseAll()` right after) should `await` this instead of
+     * firing it and moving on.
+     *
+     * Guarded on `n.hasChildren`, matching `expand()`'s own invariant -- a leaf
+     * node's `expanded` must never be set to `true`, since `collapse()` (and
+     * this method's own counterpart, `collapseAll()`) refuse to act on a node
+     * that's `!hasChildren`, which would otherwise leave the leaf permanently
+     * stuck with a reflected `expanded` attribute nothing can clear.
+     */
+    async expandAll() {
+        const setAll = async (nodes) => {
+            await Promise.all(nodes.map(async (n) => {
+                if (n.hasChildren)
+                    n.expanded = true;
+                await n.updateComplete;
+                await setAll(this.childrenOf(n));
+            }));
+        };
+        await setAll(this.nodeElements);
+    }
+    /**
+     * Collapse every node in the tree, recursively. Goes through each node's
+     * own `collapse()` (rather than assigning `expanded` directly) so its
+     * `lyra-node-toggle` emit reaches `onNodeActivate` -- that keeps `activeId`
+     * re-synced to a node that's still visible after collapsing, even when the
+     * roving-tabindex target was a nested descendant whose ancestor's
+     * `role="group"` is about to disappear.
+     */
+    collapseAll() {
+        const setAll = (nodes) => {
+            for (const n of nodes) {
+                setAll(this.childrenOf(n));
+                n.collapse();
+            }
+        };
+        setAll(this.nodeElements);
+    }
+    render() {
+        return html `
+      <div
+        part="base"
+        role="tree"
+        aria-label=${this.label || nothing}
+        @keydown=${this.onTreeKeyDown}
+        @lyra-node-toggle=${this.onNodeActivate}
+        @lyra-node-select=${this.onNodeActivate}
+      >
+        <slot></slot>
+      </div>
+    `;
+    }
+}
+__decorate([
+    property({ attribute: false })
+], LyraTree.prototype, "data", void 0);
+__decorate([
+    property()
+], LyraTree.prototype, "label", void 0);
+__decorate([
+    state()
+], LyraTree.prototype, "activeId", void 0);
+//# sourceMappingURL=tree.class.js.map

package/dist/components/tree/tree.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.class.js","sourceRoot":"","sources":["../../../src/components/tree/tree.class.ts"],"names":[],"mappings":"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"}

package/dist/components/tree/tree.d.ts

@@ -1,120 +1,3 @@
-import { type PropertyValues, type TemplateResult } from 'lit';
-import { LyraElement } from '../../internal/lyra-element.js';
-import './tree-node.js';
-export interface TreeItem {
-    id: string;
-    label: string;
-    children?: TreeItem[];
-    badge?: string | number;
-}
-/**
- * `<lyra-tree>` — an expand/collapse hierarchy for graph/document navigation.
- *
- * Implements the WAI-ARIA treeitem keyboard pattern: a single roving
- * `tabindex` (tracked here as `activeId`, pushed down to every
- * `<lyra-tree-node>` — including nested ones, recursively) and
- * ArrowUp/Down/Right/Left/Home/End/Enter/Space handled by one delegated
- * `keydown` listener. Native `KeyboardEvent`s are `composed: true` and
- * bubble across shadow-DOM boundaries, so a press inside a deeply-nested
- * `<lyra-tree-node>`'s own shadow root still reaches this listener.
- *
- * @customElement lyra-tree
- * @event lyra-node-toggle - `detail: { id, expanded }`, dispatched by a descendant `<lyra-tree-node>` and observed here (bubbling, composed) to keep the roving-tabindex `activeId` in sync.
- * @event lyra-node-select - `detail: { id }`, dispatched by a descendant `<lyra-tree-node>` and observed here (bubbling, composed) to keep the roving-tabindex `activeId` in sync.
- * @csspart base
- * @slot - `<lyra-tree-node>` elements (top-level tree items).
- */
-export declare class LyraTree extends LyraElement {
-    static styles: import("lit").CSSResultGroup[];
-    data: TreeItem[];
-    /** Accessible name for the tree -- `role="tree"` lives on an internal element, not the host, so `aria-label`/`aria-labelledby` set directly on `<lyra-tree>` would not label it. */
-    label: string;
-    private activeId;
-    /** Set by `willUpdate()` when a `data` reassignment removes the node that currently holds real DOM focus; consumed by `updated()` to refocus the newly-designated `activeId` node once it's actually focusable. */
-    private pendingFocusId;
-    private get nodeElements();
-    private childrenOf;
-    /**
-     * Memoized result of the last `visibleNodeElements()` walk. Every keydown
-     * (ArrowUp/Down/Home/End especially) reads the full visible-node list, and
-     * rebuilding it means a `shadowRoot.querySelectorAll` per currently-expanded
-     * node -- invalidated below on the only two things that can change which
-     * nodes are visible: a `data` reassignment, or a node expanding/collapsing.
-     */
-    private cachedVisible;
-    private invalidateVisibleCache;
-    /** Every currently *visible* (ancestor-expanded) node, top-to-bottom. */
-    private visibleNodeElements;
-    private findItem;
-    protected willUpdate(changed: PropertyValues): void;
-    protected updated(changed: PropertyValues): void;
-    /** By-id reconciliation of top-level items: reuses/reorders existing `<lyra-tree-node>` elements and removes ones no longer present in `data`. */
-    private syncNodes;
-    private focusNode;
-    /**
-     * A mouse click always lands directly on the node it interacts with --
-     * `select()`/`expand()`/`collapse()` all emit their own node's id --
-     * independent of whatever `activeId` currently holds. Sync `activeId` to
-     * that id here so a click always becomes the tree's new roving-tabindex
-     * target: this keeps it aligned with real DOM focus, keeps the next
-     * arrow-key press relative to the item the user just clicked (rather than
-     * a stale `activeId`), and keeps `activeId` valid when a click collapses
-     * an ancestor of the previously-active node -- the collapsed node's own
-     * id (always still visible, since collapsing never removes a node's own
-     * top-level or already-rendered self) replaces the now-hidden descendant's
-     * id, so at least one node keeps a roving tabindex of 0. Keyboard-driven
-     * toggles/selects always target the already-active node, so this is a
-     * same-value, no-op assignment for them.
-     */
-    private onNodeActivate;
-    /**
-     * `updated()` only pushes the new `activeId` to *top-level* nodes; nested
-     * nodes only receive it once their ancestor chain's own renders cascade it
-     * down (one more pending update per depth level). Cascade `updateComplete`
-     * to match (see `cascadeUpdateComplete`), so `focusNode()`'s `.focus()`
-     * call never runs while a nested target is still mid-cascade -- `.focus()`
-     * on an element with no `tabindex` attribute committed yet is a silent
-     * no-op.
-     *
-     * The `pendingFocusId` refocus (set by `willUpdate()` when a `data`
-     * reassignment removes the node that currently holds real DOM focus) is
-     * also resolved *here*, after the cascade above, rather than from
-     * `updated()` firing a detached `void this.updateComplete.then(...)` of
-     * its own: `updateComplete`'s getter (see the base class) calls this
-     * method fresh on *every* access rather than caching one promise, so a
-     * second, independent invocation started from inside `updated()` isn't
-     * the same promise chain a caller's own `await el.updateComplete` is
-     * following -- both ultimately settle once the same underlying update
-     * resolves, but as separate chains their `.then()` continuations aren't
-     * ordered against each other, so a caller's `await` can win the race and
-     * observe focus *not yet* restored. Doing the refocus inline, before this
-     * method's own `await` chain resolves, makes it unconditionally part of
-     * whatever `updateComplete` promise every caller (this class's own
-     * `focusNode()` included) is already waiting on.
-     */
-    protected getUpdateComplete(): Promise<boolean>;
-    private onTreeKeyDown;
-    /**
-     * Expand every node in the tree, recursively. Resolves once every
-     * descendant has actually finished expanding (not just had `expanded` set)
-     * -- callers that immediately read `visibleNodeElements()`-derived state
-     * (or call `collapseAll()` right after) should `await` this instead of
-     * firing it and moving on.
-     */
-    expandAll(): Promise<void>;
-    /**
-     * Collapse every node in the tree, recursively. Goes through each node's
-     * own `collapse()` (rather than assigning `expanded` directly) so its
-     * `lyra-node-toggle` emit reaches `onNodeActivate` -- that keeps `activeId`
-     * re-synced to a node that's still visible after collapsing, even when the
-     * roving-tabindex target was a nested descendant whose ancestor's
-     * `role="group"` is about to disappear.
-     */
-    collapseAll(): void;
-    render(): TemplateResult;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'lyra-tree': LyraTree;
-    }
-}
+export * from './tree.class.js';
+import "./tree-node.js";
+//# sourceMappingURL=tree.d.ts.map

package/dist/components/tree/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../../../src/components/tree/tree.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAGhC,OAAO,gBAAgB,CAAC"}