@malva-ui/core 0.1.12

package/toolbar/lib/toolbar/toolbar-widget.d.ts

@@ -0,0 +1,75 @@
+import { Toolbar, ToolbarWidget } from '@angular/aria/toolbar';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/aria/toolbar";
+/**
+ * Opt-in roving-focus behaviour for a `mlv-toolbar`, backed by
+ * `@angular/aria`'s headless `ngToolbar` pattern.
+ *
+ * Apply `mlvToolbarRoving` to the `<mlv-toolbar>` element and
+ * {@link MlvToolbarWidget} (`mlvToolbarWidget`) to each interactive
+ * child to turn the toolbar into a single Tab stop whose items are traversed
+ * with the arrow keys (plus `Home`/`End`), per the WAI-ARIA toolbar pattern:
+ *
+ * ```html
+ * <mlv-toolbar mlvToolbarRoving>
+ *   <button mlvButton mlvToolbarWidget>Save</button>
+ *   <button mlvButton mlvToolbarWidget>Print</button>
+ * </mlv-toolbar>
+ * ```
+ *
+ * This is **opt-in** on purpose: `mlv-toolbar` projects arbitrary content, so
+ * applying the aria toolbar pattern unconditionally would (a) require every
+ * consumer to annotate their children and (b) mark a widget-less toolbar as a
+ * focusable, `aria-disabled` element. Plain `mlv-toolbar` usage is therefore
+ * left completely untouched.
+ *
+ * The aria pattern's knobs are re-exposed so consumers can pin them where the
+ * element is used (a host directive's inputs cannot be set from the wrapper's
+ * own `host` metadata):
+ *
+ * - `orientation` (`'horizontal'` default) — arrow-key axis.
+ * - `wrap` (`true` default) — whether arrow navigation wraps at the ends.
+ * - `softDisabled` (`true` default) — keep disabled widgets focusable-but-inert
+ *   (`false` skips them during navigation).
+ * - `disabled` — disable the whole toolbar.
+ * - `value` / `valueChange` — selection model for toggle/radio-style toolbars
+ *   (an array of the selected widget values; see {@link MlvToolbarWidget}).
+ */
+export declare class MlvToolbarRoving<V> {
+    /** @protected The host `ngToolbar` pattern instance. */
+    protected readonly _toolbar: Toolbar<V>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvToolbarRoving<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvToolbarRoving<any>, "mlv-toolbar[mlvToolbarRoving]", ["mlvToolbarRoving"], {}, {}, never, never, true, [{ directive: typeof i1.Toolbar; inputs: { "orientation": "orientation"; "wrap": "wrap"; "disabled": "disabled"; "softDisabled": "softDisabled"; "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+/**
+ * Marks an interactive element as a widget inside a
+ * {@link MlvToolbarRoving} (`mlvToolbarRoving`) toolbar, backed by
+ * `@angular/aria`'s `ngToolbarWidget`.
+ *
+ * The widget's `value` is exposed through the selector attribute itself, so a
+ * plain action button needs no extra binding and a selection-group button
+ * supplies its identity inline:
+ *
+ * ```html
+ * <!-- action buttons: value defaults to '' -->
+ * <button mlvButton mlvToolbarWidget>Save</button>
+ *
+ * <!-- toggle/radio group: distinct values feed the toolbar's [(value)] model -->
+ * <button mlvButton mlvToolbarWidget="left">Left</button>
+ * <button mlvButton mlvToolbarWidget="center">Center</button>
+ * ```
+ *
+ * **Deviation from the migration plan:** the plan called for synthesising the
+ * required `value` internally via `mlvNextId`. In `@angular/aria` 22.0.5
+ * `ngToolbarWidget.value` is a *required* input, and a wrapper directive cannot
+ * set its own host directive's input from the wrapper's `host` metadata (doing
+ * so raises `NG0950`). The value must therefore be supplied where the element
+ * is declared; exposing it through the selector alias keeps that ergonomic
+ * (omitted → `''`) without forcing every consumer to bind it.
+ */
+export declare class MlvToolbarWidget<V> {
+    /** @protected The host `ngToolbarWidget` pattern instance. */
+    protected readonly _widget: ToolbarWidget<V>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvToolbarWidget<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvToolbarWidget<any>, "[mlvToolbarWidget]", ["mlvToolbarWidget"], {}, {}, never, never, true, [{ directive: typeof i1.ToolbarWidget; inputs: { "value": "mlvToolbarWidget"; "disabled": "disabled"; }; outputs: {}; }]>;
+}

package/toolbar/lib/toolbar/toolbar.d.ts

@@ -0,0 +1,8 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export declare class MlvToolbar {
+    readonly gap: import("@angular/core").InputSignal<number>;
+    readonly equalSize: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvToolbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvToolbar, "mlv-toolbar", never, { "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "equalSize": { "alias": "equalSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

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

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

package/tooltip/README.md

@@ -0,0 +1,7 @@
+# tooltip
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test tooltip` to execute the unit tests.

package/tooltip/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/tooltip/tooltip';
+export * from './lib/tooltip/tooltip-panel';
+export * from './lib/tooltip/tooltip.types';

package/tooltip/lib/tooltip/tooltip-panel.d.ts

@@ -0,0 +1,26 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvTooltipTone, MlvTooltipPlacement } from './tooltip.types';
+import * as i0 from "@angular/core";
+/**
+ * Internal tooltip panel component.
+ *
+ * This component is not intended for direct consumer use — it is created
+ * programmatically by `MlvTooltip` and attached to a CDK overlay.
+ *
+ * Renders the floating tooltip panel with optional directional arrow.
+ * Placement and tone variant are controlled via inputs set by the directive.
+ */
+export declare class MlvTooltipPanel {
+    /** The text content to display inside the tooltip panel. */
+    readonly content: import("@angular/core").InputSignal<string>;
+    /** The tone variant of the tooltip panel. */
+    readonly tone: import("@angular/core").InputSignal<MlvTooltipTone>;
+    /** Whether the directional arrow is visible. */
+    readonly showArrow: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** The preferred placement of the tooltip relative to the trigger. */
+    readonly placement: import("@angular/core").InputSignal<MlvTooltipPlacement>;
+    /** Unique ID for the tooltip panel, used by `aria-describedby` on the trigger. */
+    readonly tooltipId: import("@angular/core").InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTooltipPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvTooltipPanel, "mlv-tooltip-panel", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "showArrow": { "alias": "showArrow"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "tooltipId": { "alias": "tooltipId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/tooltip/lib/tooltip/tooltip.d.ts

@@ -0,0 +1,148 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvTooltipTone, MlvTooltipPlacement } from './tooltip.types';
+import * as i0 from "@angular/core";
+/**
+ * Tooltip directive — attach to any element to show a tooltip on hover and focus.
+ *
+ * The tooltip content is passed as the directive binding value (`mlvTooltip`).
+ * The tooltip appears after `tooltipDelay` ms and disappears immediately on
+ * mouseleave, focusout, or Escape key.
+ *
+ * @example Basic usage
+ * ```html
+ * <button [mlvTooltip]="'Save changes'">Save</button>
+ * ```
+ *
+ * @example With options
+ * ```html
+ * <button
+ *   [mlvTooltip]="'Delete item'"
+ *   tooltipPlacement="bottom"
+ *   tooltipTone="danger"
+ *   [tooltipDelay]="500"
+ * >Delete</button>
+ * ```
+ *
+ * @example Disabled tooltip
+ * ```html
+ * <button [mlvTooltip]="'Info'" tooltipDisabled>Button</button>
+ * ```
+ *
+ * @example No arrow
+ * ```html
+ * <button [mlvTooltip]="'Info'" [tooltipArrow]="false">Button</button>
+ * ```
+ */
+export declare class MlvTooltip {
+    /** @private Host element reference. */
+    private readonly _elementRef;
+    /** @private CDK Overlay for creating floating panels. */
+    private readonly _overlay;
+    /** @private Environment injector, required for ComponentPortal creation. */
+    private readonly _injector;
+    /** @private Renderer for DOM attribute manipulation. */
+    private readonly _renderer;
+    /** @private Zone for running timer callbacks inside change detection. */
+    private readonly _ngZone;
+    /** @private DestroyRef for cleanup on directive destruction. */
+    private readonly _destroyRef;
+    /**
+     * The tooltip text content.
+     * This is also the directive selector binding: `[mlvTooltip]="'my text'"`.
+     */
+    readonly mlvTooltip: import("@angular/core").InputSignal<string>;
+    /** Preferred placement of the tooltip relative to the trigger. Defaults to `'top'`. */
+    readonly tooltipPlacement: import("@angular/core").InputSignal<MlvTooltipPlacement>;
+    /** Tone variant of the tooltip panel. Defaults to `'dark'` (inverse/dark background). */
+    readonly tooltipTone: import("@angular/core").InputSignal<MlvTooltipTone>;
+    /**
+     * Delay in milliseconds before the tooltip appears after hover or focus.
+     * Defaults to `300`.
+     */
+    readonly tooltipDelay: import("@angular/core").InputSignal<number>;
+    /**
+     * When `true`, suppresses the tooltip entirely.
+     * Supports attribute syntax: `<element tooltipDisabled>`.
+     */
+    readonly tooltipDisabled: import("@angular/core").InputSignalWithTransform<BooleanInput, string | boolean>;
+    /**
+     * When `true` (default), renders a directional arrow pointing toward the trigger.
+     * Set to `false` to hide the arrow.
+     * Supports attribute syntax: `<element [tooltipArrow]="false">`.
+     */
+    readonly tooltipArrow: import("@angular/core").InputSignalWithTransform<BooleanInput, string | boolean>;
+    /**
+     * @private Reference to the dynamically created `MlvTooltipPanel` instance.
+     */
+    private _componentRef;
+    /**
+     * @private CDK overlay reference managing the floating panel.
+     */
+    private _overlayRef;
+    /**
+     * @private Timer handle for the `tooltipDelay` show timer.
+     */
+    private _showTimer;
+    /**
+     * @private Timer handle for the grace-period hide timer. Gives the pointer
+     * time to travel from the trigger onto the tooltip panel (WCAG 1.4.13).
+     */
+    private _hideTimer;
+    /**
+     * @private Grace period (ms) before hiding on mouseleave, allowing the pointer
+     * to reach the hoverable tooltip panel without it disappearing.
+     */
+    private readonly _hideDelay;
+    /**
+     * @private Cleanup functions for the panel hover listeners, invoked on hide.
+     */
+    private _panelListeners;
+    /**
+     * @private Stable unique ID for this tooltip instance, used by `aria-describedby`.
+     */
+    private readonly _tooltipId;
+    constructor();
+    /** @protected Schedules tooltip display on mouseenter. */
+    protected _onMouseEnter(): void;
+    /**
+     * @protected Cancels pending show and schedules a delayed hide on mouseleave.
+     * The grace period lets the pointer move onto the tooltip panel without it
+     * disappearing (WCAG 1.4.13 — content on hover must be hoverable).
+     */
+    protected _onMouseLeave(): void;
+    /** @protected Schedules tooltip display on focusin (keyboard users). */
+    protected _onFocusIn(): void;
+    /** @protected Cancels pending show and hides tooltip on focusout. */
+    protected _onFocusOut(): void;
+    /** @protected Cancels pending show and hides tooltip on Escape key. */
+    protected _onEscape(): void;
+    /**
+     * @private Schedules tooltip display after `tooltipDelay` ms inside NgZone.
+     */
+    private _scheduleShow;
+    /**
+     * @private Clears the pending show timer if one is active.
+     */
+    private _clearShowTimer;
+    /**
+     * @private Schedules the tooltip to hide after the `_hideDelay` grace period.
+     */
+    private _scheduleHide;
+    /**
+     * @private Clears the pending hide timer if one is active.
+     */
+    private _clearHideTimer;
+    /**
+     * @private Creates the CDK overlay, attaches `MlvTooltipPanel`, and wires
+     * `aria-describedby` on the host element. If the tooltip is already visible
+     * this method is a no-op.
+     */
+    private _show;
+    /**
+     * @private Disposes the CDK overlay, destroys the component reference, and
+     * removes `aria-describedby` from the host element.
+     */
+    private _hide;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvTooltip, "[mlvTooltip]", never, { "mlvTooltip": { "alias": "mlvTooltip"; "required": true; "isSignal": true; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; "isSignal": true; }; "tooltipTone": { "alias": "tooltipTone"; "required": false; "isSignal": true; }; "tooltipDelay": { "alias": "tooltipDelay"; "required": false; "isSignal": true; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; "isSignal": true; }; "tooltipArrow": { "alias": "tooltipArrow"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/tooltip/lib/tooltip/tooltip.types.d.ts

@@ -0,0 +1,17 @@
+import type { MlvTone } from '@malva-ui/cdk/utils';
+/**
+ * Tone variant for the tooltip panel.
+ *
+ * Extends the shared {@link MlvTone} semantic vocabulary
+ * (`'info' | 'success' | 'warning' | 'danger'`) with surface and brand options:
+ *
+ * - `'dark'` — dark/inverse background (default)
+ * - `'light'` — light background
+ * - `'primary'` — primary accent color
+ */
+export type MlvTooltipTone = MlvTone | 'dark' | 'light' | 'primary';
+/**
+ * Preferred placement of the tooltip relative to the trigger element.
+ * CDK will use the first placement that fits in the viewport.
+ */
+export type MlvTooltipPlacement = 'top' | 'bottom' | 'left' | 'right';

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

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

package/tree/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/tree/tree-node';
+export * from './lib/tree/tree-node-def';
+export * from './lib/tree/tree';
+export * from './lib/tree/tree-context';

package/tree/lib/tree/tree-context.d.ts

@@ -0,0 +1,62 @@
+import { InjectionToken } from '@angular/core';
+import type { TreeItem } from '@angular/aria/tree';
+import type { MlvTreeNode, MlvTreeSelectMode } from './tree-node';
+import type { MlvTreeNodeDef } from './tree-node-def';
+/**
+ * Public accessor interface that the recursive `MlvTreeSubtree` uses to
+ * communicate with its parent `MlvTree` via the `MLV_TREE` injection
+ * token.
+ *
+ * All members map to the corresponding public members of `MlvTree`.
+ * Selection, roving focus, keyboard navigation, expansion state and all ARIA
+ * attributes are owned by the `@angular/aria` `Tree`/`TreeItem`/`TreeItemGroup`
+ * directives applied inside the subtree template; this accessor only surfaces
+ * the Malva UI-specific glue (lazy loading, custom templates, `nodeActivate`,
+ * `nodeToggle`, and the single-select deselect-on-re-click affordance).
+ */
+export interface MlvTreeAccessor {
+    /** Current selection mode. */
+    selectMode(): MlvTreeSelectMode;
+    /** Indentation size in rem per depth level. */
+    indentSize(): number;
+    /** Whether the given node id is currently expanded. */
+    _isExpanded(id: string | number): boolean;
+    /** Whether the given node id is currently loading lazy children. */
+    _isLoading(id: string | number): boolean;
+    /** Whether the given node id is currently selected. */
+    _isSelected(id: string | number): boolean;
+    /**
+     * Returns the effective children of a node: lazily-loaded children when
+     * present, otherwise the static `children` array.
+     */
+    _children(node: MlvTreeNode): MlvTreeNode[];
+    /** Whether a node renders an expandable group (static, loaded, or lazy children). */
+    _hasChildren(node: MlvTreeNode): boolean;
+    /** Custom node template directive, if any. */
+    _nodeDefDirective(): MlvTreeNodeDef | undefined;
+    /**
+     * 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, expanded: boolean): void;
+    /**
+     * 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, item: TreeItem<string | number>, event: Event): void;
+    /**
+     * 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, event: MouseEvent): void;
+    /** Row Enter/Space handler used to emit `nodeActivate` in `none` mode. */
+    _onActivateKey(node: MlvTreeNode): void;
+}
+/**
+ * Injection token that provides the parent `MlvTree` as a
+ * `MlvTreeAccessor` to nested `MlvTreeSubtree` instances.
+ */
+export declare const MLV_TREE: InjectionToken<MlvTreeAccessor>;

package/tree/lib/tree/tree-node-def.d.ts

@@ -0,0 +1,33 @@
+import { TemplateRef } from '@angular/core';
+import type { MlvFlatTreeNode } from './tree-node';
+import * as i0 from "@angular/core";
+/**
+ * Context provided to the `[mlvTreeNodeDef]` template.
+ */
+export interface MlvTreeNodeDefContext<T = unknown> {
+    /** The flat tree node for the current row. */
+    $implicit: MlvFlatTreeNode<T>;
+}
+/**
+ * Structural directive that marks a `<ng-template>` as a custom node template.
+ *
+ * Usage:
+ * ```html
+ * <mlv-tree [nodes]="nodes">
+ *   <ng-template mlvTreeNodeDef let-flatNode>
+ *     <span>{{ flatNode.node.label }}</span>
+ *   </ng-template>
+ * </mlv-tree>
+ * ```
+ */
+export declare class MlvTreeNodeDef<T = unknown> {
+    /** The template reference for this custom node slot. */
+    readonly templateRef: TemplateRef<any>;
+    /**
+     * Type guard for correct template variable inference.
+     * @internal
+     */
+    static ngTemplateContextGuard<T>(_dir: MlvTreeNodeDef<T>, _ctx: unknown): _ctx is MlvTreeNodeDefContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTreeNodeDef<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvTreeNodeDef<any>, "[mlvTreeNodeDef]", never, {}, {}, never, never, true, never>;
+}

package/tree/lib/tree/tree-node.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Represents a single node in the tree data structure.
+ * The generic parameter `T` is the type of the node's data payload.
+ */
+export interface MlvTreeNode<T = unknown> {
+    /** Unique identifier for the node. Used for tracking and key management. */
+    id: string | number;
+    /** The data payload associated with this node. */
+    data: T;
+    /** Human-readable label shown in the default node template. */
+    label: string;
+    /** Pre-loaded children of this node. If omitted and `loadChildren` is set, children are loaded lazily. */
+    children?: MlvTreeNode<T>[];
+    /**
+     * Async callback for lazy-loading child nodes.
+     * When defined, the node shows a loading spinner on first expand until the promise resolves.
+     */
+    loadChildren?: () => Promise<MlvTreeNode<T>[]>;
+    /** When true, the node is rendered as disabled — not selectable or expandable via keyboard. */
+    disabled?: boolean;
+    /** Optional icon name (Lucide icon) shown before the label in the default template. */
+    icon?: string;
+    /** When true, the node starts expanded. Only applies to initial render. */
+    expanded?: boolean;
+}
+/**
+ * Internal flat-list representation of a tree node used for rendering.
+ * Calculated from the tree data by depth and expansion state.
+ */
+export interface MlvFlatTreeNode<T = unknown> {
+    /** Reference to the original tree node. */
+    node: MlvTreeNode<T>;
+    /** Depth level (0 = root). Used for indentation. */
+    depth: number;
+    /** Whether this node is currently expanded. */
+    isExpanded: boolean;
+    /** Whether this node has children (loaded or lazy). */
+    hasChildren: boolean;
+    /** Whether this node is currently loading children (lazy load in progress). */
+    isLoading: boolean;
+    /** Unique key for `@for` tracking. */
+    key: string | number;
+}
+/** Selection mode for the tree component. */
+export type MlvTreeSelectMode = 'none' | 'single' | 'multi';

package/tree/lib/tree/tree-subtree.d.ts

@@ -0,0 +1,63 @@
+import { TreeItemGroup } from '@angular/aria/tree';
+import type { Tree } from '@angular/aria/tree';
+import type { MlvFlatTreeNode, MlvTreeNode } from './tree-node';
+import type { MlvTreeAccessor } from './tree-context';
+import * as i0 from "@angular/core";
+/** The valid `parent` reference for a subtree's items: the tree root or a group. */
+type TreeParent = Tree<string | number> | TreeItemGroup<string | number>;
+/**
+ * Internal recursive subtree component used by `MlvTree`.
+ *
+ * Renders one level of `<div ngTreeItem>` rows using the `@angular/aria`
+ * `Tree`/`TreeItem`/`TreeItemGroup` headless directives (applied here so aria
+ * owns roles, `aria-level`/`setsize`/`posinset`, roving `tabindex`, keyboard
+ * navigation, typeahead and selection). Children are wrapped in
+ * `<ng-template ngTreeItemGroup>` + `mlv-expand` for the animated height
+ * transition; `[preserveContent]="true"` keeps aria's `DeferredContent` from
+ * unmounting the group so `mlv-expand` can own the enter/leave animation.
+ *
+ * The recursion is expressed as **nested components** (not a self-referential
+ * `ngTemplateOutlet`, which throws `createEmbeddedViewImpl is not a function`
+ * when rendered through aria's `DeferredContent`).
+ *
+ * @internal Not part of the public API — use `MlvTree` instead.
+ */
+export declare class MlvTreeSubtree {
+    /** The nodes to render at this level. */
+    readonly nodes: import("@angular/core").InputSignal<MlvTreeNode<unknown>[]>;
+    /**
+     * The aria parent for this level's items — the `Tree` root for the top level,
+     * or the owning `TreeItemGroup` for a nested level. Required: aria's
+     * `TreeItem` needs a defined `parent` from creation (its `level`/`selected`
+     * patterns dereference it) — an undefined parent crashes rendering.
+     */
+    readonly parent: import("@angular/core").InputSignal<TreeParent>;
+    /** The depth of this level (0 = root). Drives indentation and connectors. */
+    readonly depth: import("@angular/core").InputSignal<number>;
+    /** @protected The parent tree context injected via `MLV_TREE`. */
+    protected readonly tree: MlvTreeAccessor;
+    /**
+     * @private Per-node cache of the `[mlvTreeNodeDef]` template context and its
+     * `ngTemplateOutlet` wrapper, keyed by node identity. The entry is rebuilt for
+     * a node only when one of its derived fields actually changes, so the context
+     * object identity stays stable across change detection — the custom template
+     * (and any OnPush children inside it) is not re-stamped against a freshly
+     * allocated context object on every pass.
+     */
+    private readonly _contextCache;
+    /**
+     * @protected Returns the identity-stable `ngTemplateOutlet` context wrapper for
+     * a node's `[mlvTreeNodeDef]` template. Preserves the public context shape
+     * (`let-flatNode` → `MlvFlatTreeNode`). Derived from the node + component state
+     * rather than aria's `TreeItem` patterns (which are only available after the
+     * item's `ngOnInit`). A new wrapper (and `MlvFlatTreeNode`) is produced only when
+     * a field changes, so unchanged rows keep a stable context reference across
+     * change detection.
+     */
+    protected _nodeContext(node: MlvTreeNode): {
+        $implicit: MlvFlatTreeNode;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTreeSubtree, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvTreeSubtree, "mlv-tree-subtree", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "parent": { "alias": "parent"; "required": true; "isSignal": true; }; "depth": { "alias": "depth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};