@malva-ui/core 0.1.12

package/tree/lib/tree/tree.d.ts

@@ -0,0 +1,156 @@
+import { type OnInit } from '@angular/core';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvTreeNode } from './tree-node';
+import type { MlvTreeSelectMode } from './tree-node';
+import { MlvTreeNodeDef } from './tree-node-def';
+import { MLV_TREE } from './tree-context';
+import type { MlvTreeAccessor } from './tree-context';
+import type { TreeItem } from '@angular/aria/tree';
+import * as i0 from "@angular/core";
+export { MLV_TREE };
+export type { MlvTreeAccessor };
+/** `aria-current` type surfaced when the tree is used as a navigation tree. */
+export type MlvTreeCurrentType = 'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false';
+/**
+ * Hierarchical data tree component for displaying nested data.
+ *
+ * Built on the `@angular/aria` headless `Tree`/`TreeItem`/`TreeItemGroup`
+ * directives (applied inside the component — consumers never see `ng*`
+ * selectors). aria owns roles, `aria-level`/`setsize`/`posinset`, roving
+ * `tabindex`, keyboard navigation (arrows, Home/End), text typeahead, and
+ * selection; the component keeps the Malva UI data-driven `nodes` API, the
+ * `mlv-expand` animated expand/collapse, lazy loading, custom node templates,
+ * and multi-select checkboxes.
+ *
+ * Features:
+ * - Expand/collapse nodes with smooth animated height transition via `mlv-expand`
+ * - Single-select and multi-select checkbox mode
+ * - Lazy loading via `loadChildren` callbacks with spinner
+ * - Full keyboard navigation and text typeahead (owned by `@angular/aria`)
+ * - Custom node templates via `[mlvTreeNodeDef]`
+ * - Optional navigation-tree mode (`nav` + `currentType`) for sidebar-style trees
+ * - Generic typed `MlvTreeNode<T>` interface
+ * - Recursive rendering via internal `MlvTreeSubtree`
+ *
+ * @example
+ * ```html
+ * <mlv-tree [nodes]="treeData" selectMode="multi" (selectionChange)="onSelect($event)" />
+ * ```
+ */
+export declare class MlvTree<T = unknown> implements OnInit, MlvTreeAccessor {
+    /** The tree nodes to render. Supports nested children. */
+    readonly nodes: import("@angular/core").InputSignal<MlvTreeNode<T>[]>;
+    /**
+     * Selection mode:
+     * - `'none'` — no selection (default); rows are activated (`nodeActivate`)
+     * - `'single'` — click/Space/Enter selects one node at a time
+     * - `'multi'` — checkbox-based multi-select
+     */
+    readonly selectMode: import("@angular/core").InputSignal<MlvTreeSelectMode>;
+    /** Indentation per depth level in `rem`. Defaults to `1.5`. */
+    readonly indentSize: import("@angular/core").InputSignal<number>;
+    /**
+     * When true, renders vertical and horizontal connector lines between parent and child nodes
+     * (file-explorer pattern). Defaults to `false`.
+     */
+    readonly showConnectors: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When true, the tree renders as a navigation tree: selected rows expose
+     * `aria-current` (of `currentType`) instead of `aria-selected`. Suited to
+     * sidebar-style navigation trees. Defaults to `false`.
+     */
+    readonly nav: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** The `aria-current` type used when `nav` is enabled. Defaults to `'page'`. */
+    readonly currentType: import("@angular/core").InputSignal<MlvTreeCurrentType>;
+    /** Emits the set of selected node IDs whenever the selection changes. */
+    readonly selectionChange: import("@angular/core").OutputEmitterRef<Set<string | number>>;
+    /** Emits when a node is activated (clicked or Enter in single-select/none mode). */
+    readonly nodeActivate: import("@angular/core").OutputEmitterRef<MlvTreeNode<T>>;
+    /** Emits when a node's expanded state changes. */
+    readonly nodeToggle: import("@angular/core").OutputEmitterRef<{
+        node: MlvTreeNode<T>;
+        expanded: boolean;
+    }>;
+    /**
+     * @public Selected node ids, mirrored to the aria `Tree.value` model (aria
+     * selection is always an array — a single-select tree holds at most one id).
+     */
+    readonly _value: import("@angular/core").WritableSignal<(string | number)[]>;
+    /**
+     * @private Selection membership set derived from `_value`. Rebuilt only when
+     * the selection changes, giving `_isSelected` an O(1) lookup instead of an
+     * O(selected) array scan on every node (twice per row) per change-detection
+     * pass. Mirrors the `_expandedIds`/`_loadingIds` Set pattern.
+     */
+    private readonly _selectedIdSet;
+    /** @public Internal expansion state set (node id → expanded). */
+    readonly _expandedIds: import("@angular/core").WritableSignal<Set<string | number>>;
+    /** @public Map of node id → loaded children (for lazy nodes). */
+    readonly _loadedChildren: import("@angular/core").WritableSignal<Map<string | number, MlvTreeNode<T>[]>>;
+    /** @private Set of node ids currently loading lazy children. */
+    private readonly _loadingIds;
+    /** @public The custom node template if provided. */
+    readonly _nodeDefDirective: import("@angular/core").Signal<MlvTreeNodeDef<any> | undefined>;
+    ngOnInit(): void;
+    /** @private Collect nodes that have `expanded: true` initially. */
+    private _collectInitialExpanded;
+    /** @public Whether the given node id is currently expanded. */
+    _isExpanded(id: string | number): boolean;
+    /** @public Whether the given node id is currently loading lazy children. */
+    _isLoading(id: string | number): boolean;
+    /** @public Whether the given node id is currently selected. */
+    _isSelected(id: string | number): boolean;
+    /**
+     * @public Effective children of a node — lazily-loaded children when present,
+     * otherwise the static `children` array.
+     */
+    _children(node: MlvTreeNode<T>): MlvTreeNode<T>[];
+    /** @public Whether a node renders an expandable group (static/loaded/lazy children). */
+    _hasChildren(node: MlvTreeNode<T>): boolean;
+    /**
+     * @public Reacts to the aria `TreeItem.expanded` model changing (keyboard,
+     * pointer, chevron, or programmatic). Syncs the expansion set, triggers lazy
+     * loading, and emits `nodeToggle`.
+     */
+    _onExpandedChange(node: MlvTreeNode<T>, expanded: boolean): void;
+    /**
+     * @public Chevron toggle handler. Guards disabled nodes, stops propagation so
+     * the aria tree does not also select the row, and flips the aria item's
+     * `expanded` model (which routes through `_onExpandedChange`).
+     */
+    _onToggle(node: MlvTreeNode<T>, item: TreeItem<string | number>, event: Event): void;
+    /**
+     * @public Row pointer handler. Emits `nodeActivate` in `none` mode and
+     * implements the single-select deselect-on-re-click affordance (aria's
+     * `selectOne` never deselects on its own).
+     */
+    _onRowClick(node: MlvTreeNode<T>, event: MouseEvent): void;
+    /** @public Row Enter/Space handler used to emit `nodeActivate` in `none` mode. */
+    _onActivateKey(node: MlvTreeNode<T>): void;
+    /**
+     * @public Bridges the aria `Tree.value` model to `selectionChange`. Also
+     * emits `nodeActivate` for user-driven single-select (pointer or keyboard);
+     * programmatic selection goes through `setSelection` instead.
+     */
+    _onAriaValueChange(value: (string | number)[]): void;
+    /** @private Load lazy children then keep the node expanded to reveal them. */
+    private _loadLazy;
+    /** @private Recursively find a node by id across static and loaded children. */
+    private _findNode;
+    /** @public Exposes the currently selected node ids. */
+    get selectedIds(): Set<string | number>;
+    /** Programmatically set the selected node IDs. */
+    setSelection(ids: Set<string | number>): void;
+    /** Programmatically expand a node by ID. */
+    expandNode(nodeId: string | number): void;
+    /** Programmatically collapse a node by ID. */
+    collapseNode(nodeId: string | number): void;
+    /** Expand all nodes. */
+    expandAll(): void;
+    /** Collapse all nodes. */
+    collapseAll(): void;
+    /** @private Collect all node IDs recursively. */
+    private _collectAllIds;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTree<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvTree<any>, "mlv-tree", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "selectMode": { "alias": "selectMode"; "required": false; "isSignal": true; }; "indentSize": { "alias": "indentSize"; "required": false; "isSignal": true; }; "showConnectors": { "alias": "showConnectors"; "required": false; "isSignal": true; }; "nav": { "alias": "nav"; "required": false; "isSignal": true; }; "currentType": { "alias": "currentType"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "nodeActivate": "nodeActivate"; "nodeToggle": "nodeToggle"; }, ["_nodeDefDirective"], never, true, never>;
+}

package/tree/malva-ui-core-tree.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/tree" />
+export * from './index';