@malva-ui/core 0.1.12

package/list/lib/list-selectable.d.ts

@@ -0,0 +1,73 @@
+import { Listbox, Option } from '@angular/aria/listbox';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/aria/listbox";
+/**
+ * Turns a `mlv-list` into a single- or multi-select listbox, backed by
+ * `@angular/aria`'s headless `ngListbox` pattern.
+ *
+ * The `Listbox` directive is applied as a host directive so the public
+ * `mlv-list[selectable]` selector, `multiple`/`value` inputs and `valueChange`
+ * output are unchanged. The aria pattern's selection/navigation knobs are
+ * re-exposed as inputs so consumers (and the shared dropdown panel) can pin
+ * them:
+ *
+ * - `selectionMode` (default aria `follow`) — set `"explicit"` to reproduce the
+ *   previous `CdkListbox` behaviour where selection only changes on
+ *   click / Space / Enter, never on arrow-key focus movement. The shared
+ *   `mlv-dropdown-panel` (and therefore `mlv-select` / `mlv-combobox`) pins
+ *   this to `"explicit"`.
+ * - `softDisabled` (default aria `true`) — set `false` to skip disabled options
+ *   during keyboard navigation, matching the previous `CdkListbox` behaviour.
+ *
+ * - `focusMode` (default aria `roving`) — set `"activedescendant"` so DOM focus
+ *   stays on an owning combobox trigger/input while the active option is tracked
+ *   via `aria-activedescendant`. The shared `mlv-dropdown-panel` re-exposes this
+ *   so `mlv-combobox` can keep keyboard focus in its text input.
+ *
+ * `wrap` and text typeahead keep aria's defaults, which already match the
+ * previous configuration (typeahead reads each option's `label`; see
+ * {@link MlvListItemSelectable}).
+ *
+ * The aria `Listbox`'s own `id` input is re-exposed publicly as `listboxId`. The
+ * pattern binds `[attr.id]="id()"` on the host and, when left unset, generates a
+ * `ng-listbox-*` id that would otherwise override any `[id]` template binding —
+ * dangling the `aria-controls` reference of a wrapping `mlv-select` /
+ * `mlv-combobox` trigger. Forwarding a consumer-provided id through the aria
+ * input keeps the rendered DOM id under the consumer's control (the shared
+ * `mlv-dropdown-panel` wires this from its `listboxId` input). A host
+ * directive's exposed inputs cannot be set from this wrapper's own `host`
+ * metadata, so `listboxId` is bound where the `<mlv-list>` element is used.
+ */
+export declare class MlvListSelectable<T> {
+    /** @protected The host `ngListbox` pattern instance. */
+    protected readonly _listbox: Listbox<T>;
+    /**
+     * Moves keyboard focus to the first option in the list. Used by the
+     * dropdown panel when a parent select/combobox opens the popup.
+     */
+    focusFirst(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvListSelectable<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvListSelectable<any>, "mlv-list[selectable]", never, {}, {}, never, never, true, [{ directive: typeof i1.Listbox; inputs: { "value": "value"; "multi": "multiple"; "orientation": "orientation"; "wrap": "wrap"; "disabled": "disabled"; "readonly": "readonly"; "selectionMode": "selectionMode"; "softDisabled": "softDisabled"; "focusMode": "focusMode"; "id": "listboxId"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+/**
+ * Marks a `mlv-list-item` as a selectable option inside a
+ * `mlv-list[selectable]`, backed by `@angular/aria`'s `ngOption`.
+ *
+ * The required `value`, optional `disabled`, optional typeahead `label`, and
+ * optional `optionId` inputs are forwarded to the host `Option` directive.
+ * Provide `label` (the visible option text) so type-to-select works — aria's
+ * typeahead reads the explicit `label` input and defaults to an empty search
+ * term otherwise. The shared `mlv-dropdown-panel` sets this automatically from
+ * the option label.
+ *
+ * `optionId` re-exposes aria's `ngOption` `id` input (rendered as the option
+ * element's `[attr.id]`). Forwarding a deterministic id lets an owning combobox
+ * point its input's `aria-activedescendant` at the active option element (the
+ * activedescendant focus model). Left unset, aria mints its own id.
+ */
+export declare class MlvListItemSelectable {
+    /** @protected The host `ngOption` pattern instance. */
+    protected readonly option: Option<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvListItemSelectable, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvListItemSelectable, "mlv-list-item[value]", ["uiListItemSelectable"], {}, {}, never, never, true, [{ directive: typeof i1.Option; inputs: { "value": "value"; "disabled": "disabled"; "label": "label"; "id": "optionId"; }; outputs: {}; }]>;
+}

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

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

package/loader/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/loader/loader';

package/loader/lib/loader/loader.d.ts

@@ -0,0 +1,84 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvTone } from '@malva-ui/cdk/utils';
+import * as i0 from "@angular/core";
+/**
+ * Semantic tone of the loader. Extends the shared {@link MlvTone} vocabulary
+ * (`'info' | 'success' | 'warning' | 'danger'`) with a neutral `'default'`.
+ */
+export type MlvLoaderTone = MlvTone | 'default';
+/** Visual variant of the loader. */
+export type MlvLoaderVariant = 'bar' | 'circle';
+export declare class MlvLoader {
+    /** Visual variant — `'bar'` for a horizontal progress bar, `'circle'` for a circular spinner. */
+    readonly variant: import("@angular/core").InputSignal<MlvLoaderVariant>;
+    /** Semantic tone. Controls the `--mlv-l-color` CSS token. */
+    readonly tone: import("@angular/core").InputSignal<MlvLoaderTone>;
+    /** Current progress value. Used in determinate mode together with `max`. */
+    readonly value: import("@angular/core").InputSignal<number>;
+    /** Maximum progress value. Defaults to `100`. */
+    readonly max: import("@angular/core").InputSignal<number>;
+    /**
+     * When `true`, the loader animates continuously without tracking a specific value.
+     * Disables all ARIA value attributes (`aria-valuenow`, `aria-valuemin`, `aria-valuemax`).
+     */
+    readonly indeterminate: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Pixel size of the loader.
+     * For `'bar'` variant this sets the track height (defaults to `4`).
+     * For `'circle'` variant this sets the diameter (defaults to `48`).
+     */
+    readonly size: import("@angular/core").InputSignal<number | undefined>;
+    /** Stroke width in pixels for the `'circle'` variant. Defaults to `4`. */
+    readonly strokeWidth: import("@angular/core").InputSignal<number>;
+    /** Custom aria-label override. Falls back to the i18n-provided label. */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * When `true`, displays the current progress percentage as a text hint.
+     * For the `'bar'` variant the hint appears above the track.
+     * For the `'circle'` variant the hint appears centred inside the ring.
+     * Only shown when the loader is in determinate mode (not `indeterminate`).
+     */
+    readonly showHint: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Custom color override applied directly to `--mlv-l-color`.
+     * Accepts any valid CSS color value or a `linear-gradient()` / `url('#paintServerId')` string.
+     * When set, takes precedence over the `tone` color.
+     */
+    readonly color: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * Custom fill color override applied directly to `--mlv-l-track-color`.
+     * Accepts any valid CSS color value or a `linear-gradient()` / `url('#paintServerId')` string.
+     * When set, takes precedence over the `tone` color.
+     */
+    readonly trackColor: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * When `true`, adds a shimmer sweep animation over the filled bar / arc.
+     * Only applies to the `'bar'` variant in determinate mode.
+     * Has no effect in indeterminate mode (the bar is already animated).
+     */
+    readonly glow: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvLoaderI18n>;
+    /** @protected Resolved aria-label: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedAriaLabel: import("@angular/core").Signal<string>;
+    /** @protected Resolves the effective pixel size based on `size` input and `variant`. */
+    protected readonly _normalizedSize: import("@angular/core").Signal<number>;
+    /**
+     * @protected Delays enabling the CSS fill transition by one event loop tick so the
+     * browser has a defined starting `stroke-dashoffset` before the transition begins.
+     * Starts as `undefined` (falsy) and becomes truthy after the microtask queue drains.
+     */
+    protected readonly _progressVisible: import("@angular/core").Signal<boolean | undefined>;
+    /** @protected `true` when the loader is in determinate (value-tracking) mode. */
+    protected readonly _determinate: import("@angular/core").Signal<boolean>;
+    /** @protected Progress as a percentage clamped between 0 and 100. */
+    protected readonly _percentage: import("@angular/core").Signal<number>;
+    /** @protected Formatted hint text shown when `showHint` is true and mode is determinate. */
+    protected readonly _hintText: import("@angular/core").Signal<string>;
+    /** @protected Whether the hint should be visible. */
+    protected readonly _showHint: import("@angular/core").Signal<boolean>;
+    /** @protected CSS class string applied to the host element. */
+    protected readonly _hostClasses: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvLoader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvLoader, "mlv-loader", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "showHint": { "alias": "showHint"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "trackColor": { "alias": "trackColor"; "required": false; "isSignal": true; }; "glow": { "alias": "glow"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

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

package/malva-ui-core.d.ts

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

package/menu/index.d.ts

@@ -0,0 +1,9 @@
+export * from './lib/menu/menu';
+export * from './lib/menu/menu-item';
+export * from './lib/menu/menu-separator';
+export * from './lib/menu/menu-group';
+export * from './lib/menu/menu-group-label';
+export * from './lib/menu/menu-trigger';
+export * from './lib/menu/menu.types';
+export * from './lib/menu/menubar';
+export * from './lib/menu/menubar.types';

package/menu/lib/menu/menu-group-label.d.ts

@@ -0,0 +1,22 @@
+import * as i0 from "@angular/core";
+/**
+ * Marks an element as the label for a `mlv-menu-group`.
+ * The group applies `aria-labelledby` pointing to this element's generated id.
+ *
+ * @example
+ * ```html
+ * <mlv-menu-group>
+ *   <span mlvMenuGroupLabel>File actions</span>
+ *   <mlv-menu-item>Open</mlv-menu-item>
+ * </mlv-menu-group>
+ * ```
+ */
+export declare class MlvMenuGroupLabel {
+    /**
+     * Stable DOM id applied to the label element so the parent
+     * `mlv-menu-group` can reference it via `aria-labelledby`.
+     */
+    readonly id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvMenuGroupLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvMenuGroupLabel, "[mlvMenuGroupLabel]", never, {}, {}, never, never, true, never>;
+}

package/menu/lib/menu/menu-group.d.ts

@@ -0,0 +1,27 @@
+import { MlvMenuGroupLabel } from './menu-group-label';
+import * as i0 from "@angular/core";
+/**
+ * Groups related menu items with an optional label inside a `mlv-menu`.
+ *
+ * Use `[mlvMenuGroupLabel]` on a child element to provide an accessible label
+ * for the group. When present, the group's `role="group"` is named via
+ * `aria-labelledby` pointing at the label element.
+ *
+ * @example
+ * ```html
+ * <mlv-menu-group>
+ *   <span mlvMenuGroupLabel>File</span>
+ *   <mlv-menu-item (itemClick)="onNew()">New</mlv-menu-item>
+ *   <mlv-menu-item (itemClick)="onOpen()">Open</mlv-menu-item>
+ * </mlv-menu-group>
+ * ```
+ */
+export declare class MlvMenuGroup {
+    /**
+     * @protected Projected `[mlvMenuGroupLabel]` element, if any. Its generated
+     * id names this group via `aria-labelledby`.
+     */
+    protected readonly _label: import("@angular/core").Signal<MlvMenuGroupLabel | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvMenuGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvMenuGroup, "mlv-menu-group", never, {}, {}, ["_label"], ["*"], true, never>;
+}

package/menu/lib/menu/menu-item.d.ts

@@ -0,0 +1,76 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+/**
+ * Menu item directive — applied to `mlv-list-item` to give it menu-item semantics
+ * and behavior.
+ *
+ * Overrides the list item's default `role="listitem"` with `role="menuitem"`,
+ * wires into the parent menu's `FocusKeyManager` (via `focus()` / `disabledBoolean`),
+ * and closes the parent menu stack on activation.
+ *
+ * Use `[mlvListItemPrefix]` for leading icons and `[mlvListItemSuffix]` for
+ * trailing content (chevron, shortcut label, etc.).
+ *
+ * @example
+ * ```html
+ * <mlv-list-item mlvMenuItem (itemClick)="onSave()">Save</mlv-list-item>
+ *
+ * <mlv-list-item mlvMenuItem disabled>Unavailable</mlv-list-item>
+ *
+ * <mlv-list-item mlvMenuItem (itemClick)="onEdit()">
+ *   <svg mlvListItemPrefix lucideEdit [size]="14" />
+ *   Edit
+ * </mlv-list-item>
+ * ```
+ */
+export declare class MlvMenuItem {
+    /** @private Reference to parent menu, if any. Used to close on activation. */
+    private readonly _menu;
+    /** @private Host element used to call `focus()` for `FocusKeyManager`. */
+    private readonly _elementRef;
+    /**
+     * When true, disables the item — removes it from the tab order and
+     * prevents activation. Supports attribute syntax: `<mlv-list-item mlvMenuItem disabled>`.
+     */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<BooleanInput, string | boolean>;
+    /**
+     * Emits when the item is activated (click or Enter/Space key).
+     * The parent menu stack closes automatically after this event.
+     */
+    readonly itemClick: import("@angular/core").OutputEmitterRef<void>;
+    /**
+     * @private Tabindex managed by the parent menu's `FocusKeyManager`.
+     * `0` for the active (focused) item, `-1` for all others (roving tabindex).
+     * A signal so the host `[attr.tabindex]` binding updates under OnPush.
+     */
+    readonly _tabIndex: import("@angular/core").WritableSignal<number>;
+    /**
+     * Boolean getter for `FocusKeyManager.skipPredicate`.
+     * The key manager calls `item.disabledBoolean` so this bridges
+     * the signal API to the CDK interface.
+     */
+    get disabledBoolean(): boolean;
+    /**
+     * Focuses the host element.
+     * Required by CDK `FocusableOption` for `FocusKeyManager`.
+     */
+    focus(): void;
+    /**
+     * Returns the item's visible text label, used by the parent menu's
+     * `FocusKeyManager` type-ahead (type a letter to jump to the first matching
+     * item). Reads the host element's trimmed `textContent`.
+     * Required by CDK `FocusKeyManager.withTypeAhead()`.
+     */
+    getLabel(): string;
+    /**
+     * @protected Handles click activation.
+     */
+    protected _onClick(): void;
+    /**
+     * @protected Handles Enter / Space keyboard activation.
+     * Prevents default scroll on Space and triggers the same logic as a click.
+     */
+    protected _onActivate(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvMenuItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvMenuItem, "mlv-list-item[mlvMenuItem]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
+}

package/menu/lib/menu/menu-separator.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+/**
+ * A visual separator between groups of menu items in a `mlv-menu`.
+ *
+ * Renders as a horizontal rule (`<hr role="separator">`) styled to match
+ * `mlv-divider` visual design.
+ *
+ * @example
+ * ```html
+ * <mlv-menu-item (itemClick)="onEdit()">Edit</mlv-menu-item>
+ * <mlv-menu-separator />
+ * <mlv-menu-item (itemClick)="onDelete()">Delete</mlv-menu-item>
+ * ```
+ */
+export declare class MlvMenuSeparator {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvMenuSeparator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvMenuSeparator, "mlv-menu-separator", never, {}, {}, never, never, true, never>;
+}

package/menu/lib/menu/menu-trigger.d.ts

@@ -0,0 +1,255 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvMenu } from './menu';
+import * as i0 from "@angular/core";
+/**
+ * Trigger directive for `mlv-menu`.
+ *
+ * Attach to any element to open a `mlv-menu` panel on click. Uses `MlvPopupService`
+ * from `@malva-ui/core/popup` to create the CDK overlay with the popup component's
+ * template for visual chrome (background, border, radius, shadow, animations).
+ * The menu panel and items are declared inside `[mlvPopupContent]` in the menu's
+ * template and are rendered directly into the overlay — no DOM manipulation required.
+ *
+ * When used as a submenu trigger (`[isSubmenuTrigger]="true"`), the panel opens on
+ * mouseenter and the triangle-pointer-tracking algorithm keeps it open while the
+ * cursor moves diagonally toward it.
+ *
+ * Hover intent is resolved by what the pointer is over, with geometry used only
+ * for the ambiguous space between item and panel:
+ * - over the trigger item — stays open, whatever the trajectory;
+ * - over a different row of the same menu — closes;
+ * - in between (including the 8px `SUBMENU_POSITIONS` gap) — the safe cone
+ *   decides, and a short grace timer absorbs jitter and gap crossings.
+ *
+ * Once the cursor enters the submenu panel, triangle tracking stops and the
+ * panel's own `mouseleave` schedules the close.
+ *
+ * @example Simple trigger
+ * ```html
+ * <button [mlvMenuTrigger]="menu">Open menu</button>
+ * <mlv-menu #menu>
+ *   <mlv-menu-item (itemClick)="onEdit()">Edit</mlv-menu-item>
+ *   <mlv-menu-separator />
+ *   <mlv-menu-item (itemClick)="onDelete()">Delete</mlv-menu-item>
+ * </mlv-menu>
+ * ```
+ *
+ * @example Submenu trigger on a menu item
+ * ```html
+ * <mlv-menu-item [mlvMenuTrigger]="sub" [isSubmenuTrigger]="true">
+ *   More options
+ * </mlv-menu-item>
+ * <mlv-menu #sub>
+ *   <mlv-menu-item (itemClick)="onOption()">Option A</mlv-menu-item>
+ * </mlv-menu>
+ * ```
+ */
+export declare class MlvMenuTrigger {
+    /** @private Host element reference. */
+    private readonly _elementRef;
+    /** @private MlvPopupService for creating floating overlay panels. */
+    private readonly _popupService;
+    /** @private ViewContainerRef needed by MlvPopupService for template portal instantiation. */
+    private readonly _vcr;
+    /** @private NgZone for running change detection after async operations. */
+    private readonly _ngZone;
+    /** @private DestroyRef for cleanup on directive destruction. */
+    private readonly _destroyRef;
+    /** @private Parent menu for submenu triggers, if this trigger lives inside one. */
+    private readonly _parentMenu;
+    /**
+     * @private Parent menubar, if this trigger is a direct child of a `mlv-menubar`
+     * (i.e. a top-level File / Edit / View item). `null` for standalone triggers
+     * and submenu triggers.
+     */
+    private readonly _menubar;
+    /**
+     * @private Whether this trigger is a top-level menubar item. When `true` the
+     * host exposes `role="menuitem"` + a roving tabindex, and open/close state is
+     * coordinated with the parent `mlv-menubar`.
+     */
+    readonly _isMenubarChild: boolean;
+    /**
+     * The `mlv-menu` panel to open. Required.
+     */
+    readonly mlvMenuTrigger: import("@angular/core").InputSignal<MlvMenu>;
+    /**
+     * When true, treats this trigger as a submenu trigger:
+     * - Opens the panel using submenu positions (right-of-parent).
+     * - Activates triangle pointer tracking while the submenu is open.
+     * - Opens on `mouseenter` in addition to `click`.
+     */
+    readonly isSubmenuTrigger: import("@angular/core").InputSignalWithTransform<BooleanInput, string | boolean>;
+    /**
+     * When `true`, disables the trigger — no overlay will open.
+     */
+    readonly menuTriggerDisabled: import("@angular/core").InputSignalWithTransform<BooleanInput, string | boolean>;
+    /** Emits when the menu panel opens. */
+    readonly menuOpened: import("@angular/core").OutputEmitterRef<void>;
+    /** Emits when the menu panel closes. */
+    readonly menuClosed: import("@angular/core").OutputEmitterRef<void>;
+    /**
+     * @private Whether the menu overlay is currently open.
+     */
+    readonly _isOpen: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * @private Roving tabindex for menubar top-level items — `0` for the active
+     * item, `-1` otherwise. Written by the parent `mlv-menubar`; only reflected
+     * on the host when `_isMenubarChild` is `true`.
+     */
+    readonly _tabIndex: import("@angular/core").WritableSignal<number>;
+    /**
+     * @private Handle returned by `MlvPopupService.open()` for the open menu overlay.
+     */
+    private _overlayRef;
+    /**
+     * @private Subscriptions created on each `_openOverlay()` call.
+     * All are unsubscribed in `onClose` callback.
+     */
+    private _openSubscriptions;
+    /**
+     * @private State for triangle pointer tracking (submenu only).
+     */
+    private _triangleState;
+    /**
+     * @private Timer for delayed close when cursor leaves the trigger (submenu mode).
+     * Only used during the triangle-approach phase (before cursor enters submenu).
+     */
+    private _closeTimer;
+    /**
+     * @private Document mousemove listener cleanup function (submenu triangle tracking).
+     */
+    private _mousemoveCleanup;
+    constructor();
+    /**
+     * Opens the menu overlay programmatically.
+     * No-op if the overlay is already open or the trigger is disabled.
+     */
+    open(): void;
+    /**
+     * Closes the menu overlay programmatically.
+     * No-op if the overlay is not open.
+     */
+    close(): void;
+    /**
+     * Toggles the menu overlay open/closed.
+     */
+    toggle(): void;
+    /**
+     * Whether this trigger is disabled. Bridges the `menuTriggerDisabled` signal
+     * to the `MlvMenubarItem` / `FocusKeyManager.skipPredicate` contract.
+     */
+    get disabledBoolean(): boolean;
+    /**
+     * Focuses the trigger host element. Required by CDK `FocusableOption` for the
+     * menubar's `FocusKeyManager` roving tabindex.
+     */
+    focus(): void;
+    /**
+     * Returns the trigger's trimmed visible text, used by the menubar's
+     * `FocusKeyManager` type-ahead. Required by `FocusKeyManager.withTypeAhead()`.
+     */
+    getLabel(): string;
+    /** Whether this item's dropdown menu is currently open (`MlvMenubarItem`). */
+    isMenuOpen(): boolean;
+    /** Opens this item's dropdown without moving focus into the panel (`MlvMenubarItem`). */
+    openMenu(): void;
+    /** Closes this item's dropdown (`MlvMenubarItem`). */
+    closeMenu(): void;
+    /**
+     * Opens this item's dropdown and moves focus to its first item (`MlvMenubarItem`).
+     */
+    openMenuWithFirstItemFocused(): void;
+    /**
+     * Opens this item's dropdown and moves focus to its last item (`MlvMenubarItem`).
+     */
+    openMenuWithLastItemFocused(): void;
+    /**
+     * @protected Click handler — toggles the menu.
+     */
+    protected _onTriggerClick(): void;
+    /**
+     * @protected Mouseenter handler.
+     *
+     * - Menubar top-level item: delegates to the bar's hover-follow, which opens
+     *   this item's menu only while another dropdown in the bar is already open.
+     * - Submenu trigger: opens the submenu on hover (triangle tracking).
+     * - Standalone trigger: no-op (opens on click only).
+     */
+    protected _onTriggerMouseEnter(): void;
+    /**
+     * @protected Mouseleave handler — for submenu triggers, starts a delayed close
+     * unless the cursor is heading into the submenu triangle.
+     * Once the cursor has entered the submenu panel, the submenu overlay's own
+     * mouseleave listener handles closing — no triangle tracking needed here.
+     */
+    protected _onTriggerMouseLeave(event: MouseEvent): void;
+    /**
+     * @protected Keyboard handler — Enter/Space opens; Escape closes;
+     * ArrowDown/Up opens with keyboard focus.
+     */
+    protected _onKeydown(event: KeyboardEvent): void;
+    /**
+     * @private Creates and attaches the overlay using `MlvPopupService`.
+     *
+     * The popup component's template (including the `[mlvPopupContent]` menu list)
+     * is rendered directly via CDK TemplatePortal — no DOM manipulation required.
+     */
+    private _openOverlay;
+    /**
+     * @private Returns focus to the trigger element when the menu closes, but only
+     * if focus currently lives inside the (closing) overlay — this avoids yanking
+     * focus the user has deliberately moved elsewhere. For a submenu trigger this
+     * restores focus to the parent menu item that opened the submenu.
+     */
+    private _restoreFocusToTrigger;
+    /**
+     * @private Starts the leave animation which will eventually dispose the overlay
+     * via the `leaveAnimationDone$` subscription.
+     * Called by `close()` (trigger-side: Escape on trigger, programmatic close, toggle).
+     */
+    private _closeOverlay;
+    /**
+     * @private Sets up triangle tracking for a submenu after first render.
+     * Installs mousemove listener and submenu overlay mouse listeners.
+     */
+    private _setupSubmenuTracking;
+    /**
+     * @private Installs mouseenter/mouseleave listeners on the submenu overlay element.
+     *
+     * - `mouseenter`: cursor has entered submenu — stop triangle tracking, clear close timer.
+     * - `mouseleave`: cursor has left the submenu — schedule a delayed close.
+     *
+     * The delay is what makes the 8px gap between the parent item and its panel
+     * (`SUBMENU_POSITIONS` uses `offsetX: 8`) crossable in both directions.
+     */
+    private _installSubmenuOverlayListeners;
+    /**
+     * @private Installs a document-level mousemove listener for triangle tracking.
+     * Runs outside Angular's zone for performance; re-enters zone only when closing.
+     */
+    private _installMousemoveListener;
+    /**
+     * @private Whether the pointer is over a menu item that is a sibling of this
+     * trigger — i.e. another row of the menu this submenu was opened from.
+     *
+     * Scoped to the owning panel via `closest('[role="menu"]')` so rows of an
+     * unrelated menu, and the submenu's own rows, never match.
+     */
+    private _isPointerOnSiblingItem;
+    /**
+     * @private Removes the document mousemove listener if one is installed.
+     */
+    private _removeMousemoveListener;
+    /**
+     * @private Schedules a delayed close for submenu hover-out scenarios (150 ms delay).
+     * Only used during triangle-approach phase (before cursor enters submenu).
+     */
+    private _scheduleClose;
+    /**
+     * @private Clears any pending close timer.
+     */
+    private _clearCloseTimer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvMenuTrigger, "[mlvMenuTrigger]", never, { "mlvMenuTrigger": { "alias": "mlvMenuTrigger"; "required": true; "isSignal": true; }; "isSubmenuTrigger": { "alias": "isSubmenuTrigger"; "required": false; "isSignal": true; }; "menuTriggerDisabled": { "alias": "menuTriggerDisabled"; "required": false; "isSignal": true; }; }, { "menuOpened": "menuOpened"; "menuClosed": "menuClosed"; }, never, never, true, never>;
+}