@eagami/ui 5.54.0 → 5.55.0

package/types/eagami-ui.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from "@angular/core";
-import { AfterContentChecked, ElementRef, EnvironmentProviders, InjectionToken, OnDestroy, OnInit, Signal, TemplateRef, Type } from "@angular/core";
+import { AfterContentChecked, ElementRef, EnvironmentProviders, InjectionToken, Injector, OnDestroy, OnInit, Signal, TemplateRef, Type } from "@angular/core";
 import { AbstractControl, ControlValueAccessor } from "@angular/forms";
 /**
  * BCP 47 locale tags supported out of the box. Consumers select one of these
@@ -2629,6 +2629,479 @@ export declare class ColorPickerComponent implements ControlValueAccessor {
     "changed": "changed";
   }, never, never, true, never>;
 }
+/**
+ * Placement of the popover relative to its anchor. Each outside placement names
+ * the side of the anchor the popover attaches to, optionally followed by a corner
+ * suffix (`-start` or `-end`) that decides the alignment along the perpendicular
+ * axis. The plain side names (`top`, `bottom`, `left`, `right`) centre the
+ * popover on that axis. The `inside-` placements sit over the anchor instead,
+ * see {@link PopoverInsidePlacement}.
+ */
+export type PopoverPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'right' | PopoverInsidePlacement;
+/**
+ * Placements that sit over the anchor rather than beside it: pinned inside one of
+ * its corners (`inside-top-start`), centred along one of its edges (`inside-top`,
+ * `inside-start`), or centred on it (`inside-center`). `start` and `end` follow the
+ * reading direction, so `inside-top-start` is the top-left corner in LTR and the
+ * top-right corner in RTL. The offset insets the popover from the edges it is
+ * pinned to, and it never flips.
+ */
+export type PopoverInsidePlacement = 'inside-top-start' | 'inside-top' | 'inside-top-end' | 'inside-start' | 'inside-center' | 'inside-end' | 'inside-bottom-start' | 'inside-bottom' | 'inside-bottom-end';
+/** A point in viewport coordinates, such as a pointer event's `clientX` and `clientY`. */
+export interface PopoverAnchorPoint {
+  readonly x: number;
+  readonly y: number;
+}
+export interface PopoverPositionResult {
+  /** Top coordinate in viewport (px); pairs with `position: fixed`. */
+  readonly top: number;
+  /** Left coordinate in viewport (px). */
+  readonly left: number;
+  /** Width hint when the popover should match the anchor's width. */
+  readonly width?: number;
+  /** The anchor's measured width, for a caller capping the popover against it. */
+  readonly anchorWidth: number;
+  /** Effective placement after any flip logic ran. */
+  readonly placement: PopoverPlacement;
+}
+export interface PopoverPositionOptions {
+  readonly placement: PopoverPlacement;
+  /** Gap in px between the anchor and the popover. Default 4. */
+  readonly offset?: number;
+  /** Flip to the opposite side when the requested side overflows the viewport. Default true. */
+  readonly flip?: boolean;
+  /** Clamp inside the viewport when the popover still overflows after any flip. Default true. */
+  readonly clamp?: boolean;
+  /** Margin from the viewport edge in px when clamping. Default 8. */
+  readonly margin?: number;
+  /** Set the popover's width to match the anchor's. Useful for dropdown-style menus. */
+  readonly matchAnchorWidth?: boolean;
+  /** Right-to-left context. Swaps `-start`/`-end` alignment so they track the reading direction. */
+  readonly rtl?: boolean;
+  /**
+   * Viewport point to position against instead of the anchor's box, as a zero-size
+   * anchor. The anchor still supplies the width for `matchAnchorWidth`.
+   */
+  readonly point?: PopoverAnchorPoint | null;
+}
+interface Rect {
+  readonly width: number;
+  readonly height: number;
+}
+interface AnchorRect extends Rect {
+  readonly top: number;
+  readonly bottom: number;
+  readonly left: number;
+  readonly right: number;
+}
+interface Viewport {
+  readonly width: number;
+  readonly height: number;
+}
+/**
+ * Computes the viewport-space top/left for a popover anchored to `anchorRect`,
+ * applying optional flip-on-overflow and edge-clamp logic. Pure function, no
+ * DOM access. Both `<ea-popover>` and `[eaTooltip]` consume this.
+ *
+ * @param anchorRect  The anchor element's `getBoundingClientRect()`.
+ * @param popoverRect Width and height of the popover (post-render measurement).
+ * @param viewport    Viewport dimensions (`window.innerWidth/Height`).
+ * @param options     Placement and behavior flags.
+ */
+export declare function computePopoverPosition(anchorRect: AnchorRect, popoverRect: Rect, viewport: Viewport, options: PopoverPositionOptions): PopoverPositionResult;
+/** Placement of the menu list relative to its trigger. */
+export type MenuPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+/** Visual size of the menu, shared by all of its items. */
+export type MenuSize = EaSize;
+/**
+ * Popup action menu attached to any focusable element via the
+ * `[eaMenuTrigger]` directive. Supports keyboard navigation
+ * (arrow keys, Home/End), closes on outside click or Escape, and restores
+ * focus to the trigger on close. Positioning, dismissal, and SSR-safe scroll
+ * handling are provided by `<ea-popover>`.
+ */
+export declare class MenuComponent {
+  private readonly injector;
+  private readonly i18n;
+  private readonly listEl;
+  readonly placement: import("@angular/core").InputSignal<MenuPlacement>;
+  /** Visual size of the menu; every item inherits it. */
+  readonly size: import("@angular/core").InputSignal<EaSize>;
+  /** Max height of the scrollable list as a CSS length; tall menus scroll past it. */
+  readonly maxHeight: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly id: import("@angular/core").InputSignal<string>;
+  /** Accessible label for the menu, falling back to the active locale. */
+  readonly resolvedAriaLabel: import("@angular/core").Signal<string>;
+  readonly open: import("@angular/core").ModelSignal<boolean>;
+  /** Fires when the menu opens. */
+  readonly opened: import("@angular/core").OutputEmitterRef<void>;
+  /** Fires when the menu closes. */
+  readonly closed: import("@angular/core").OutputEmitterRef<void>;
+  /** Trigger element currently anchoring the menu. Signal-typed so `<ea-popover>` reacts when it changes. */
+  protected readonly triggerEl: import("@angular/core").WritableSignal<HTMLElement | undefined>;
+  protected readonly asContextMenu: import("@angular/core").WritableSignal<boolean>;
+  protected readonly anchorPoint: import("@angular/core").WritableSignal<PopoverAnchorPoint | null>;
+  readonly activeItemId: import("@angular/core").WritableSignal<string | null>;
+  constructor();
+  /** Toggles the menu open state, anchoring it to the given trigger element. */
+  toggleAt(triggerEl: HTMLElement): void;
+  /** Opens the menu anchored to the given trigger element and focuses the first item. */
+  openAt(triggerEl: HTMLElement): void;
+  /**
+   * Opens the menu as the context menu of `anchorEl`: at `point` when given (a
+   * pointer position, in viewport coordinates), else at its placement against the
+   * anchor. Focuses the first item, closes on any click or context-menu request
+   * outside the menu, and hands focus back to wherever it was on close.
+   */
+  openAsContextMenu(anchorEl: HTMLElement, point?: PopoverAnchorPoint | null): void;
+  private show;
+  /**
+   * Closes the menu if it is open. Pass `restoreFocus: true` to return focus
+   * to the trigger element (used when closing via Escape or item activation;
+   * not used on outside click, where the user has chosen a new focus target).
+   */
+  close(restoreFocus?: boolean): void;
+  /** Called by `<ea-popover>` when the user clicks outside the menu. */
+  onPopoverCloseRequested(): void;
+  private getEnabledItems;
+  /**
+   * `preventScroll: true` is critical here. The menu list is `position: fixed`
+   * but its DOM ancestor is whatever element hosts the menu (often a sticky
+   * header). When `.focus()` is called without `preventScroll`, Chromium uses
+   * the focused element's DOM-tree position (inside the sticky ancestor) rather
+   * than its rendered fixed position to decide whether to scroll, which on a
+   * scrolled page nudges the document up by a few pixels per open, until the
+   * trigger reaches the top edge. The same guard applies to keyboard navigation
+   * and restoring focus on close.
+   */
+  private focusFirstItem;
+  private focusItem;
+  onKeydown(event: KeyboardEvent): void;
+  onEscape(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "ea-menu", never, {
+    "placement": {
+      "alias": "placement";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxHeight": {
+      "alias": "maxHeight";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "aria-label";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "open": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "open": "openChange";
+    "opened": "opened";
+    "closed": "closed";
+  }, never, ["*"], true, never>;
+}
+/** What a trigger such as `[eaContextMenuTrigger]` asked for when requesting the popover open. */
+export interface PopoverOpenRequest {
+  /** Viewport point to open at, for the parent to bind to `[anchorPoint]`; `null` places it against the anchor. */
+  readonly point: PopoverAnchorPoint | null;
+}
+/** ARIA role to apply to the popover surface. */
+export type PopoverRole = 'menu' | 'listbox' | 'dialog' | 'tooltip' | 'grid';
+/**
+ * How the popover should respond to scroll / resize events while open.
+ *
+ * - `reposition` (default): re-measure the anchor and update the popover's
+ *   coordinates so it stays attached. Suitable for menus and tooltips.
+ * - `close`: request close. Suitable for dropdown lists and the colour-picker
+ *   popover, where re-tracking a tall popover during a scroll feels intrusive.
+ * - `ignore`: do nothing. The popover stays at its initial coordinates and
+ *   may visually detach from a scrolling anchor; useful when the anchor is
+ *   guaranteed not to move (e.g. inside a non-scrolling region).
+ */
+export type PopoverScrollBehavior = 'reposition' | 'close' | 'ignore';
+/** Width cap for a popover surface: px, or the anchor's own width. */
+export type PopoverMaxWidth = number | 'anchor';
+/**
+ * Floating-element primitive. Renders projected content as `position: fixed`
+ * anchored to an external element, with flip-on-overflow, viewport clamping,
+ * outside-click and Escape dismissal, and SSR-safe scroll / resize handling.
+ *
+ * The primitive is intentionally low-level: a parent component drives the
+ * `[open]` state and listens for `(closeRequested)` to mirror it back. Internal
+ * library components (`<ea-menu>`, `<ea-dropdown>`, `<ea-color-picker>`,
+ * `<ea-date-picker>`, `[eaTooltip]`) compose on top of it; downstream apps can
+ * use it directly to build their own popover-based UI. Set `contextMenu` and
+ * pair it with `[eaContextMenuTrigger]` to open it as a context menu.
+ *
+ * @example
+ * ```html
+ * <button #trigger (click)="open.set(!open())">Open</button>
+ * <ea-popover [anchor]="trigger" [open]="open()" (closeRequested)="open.set(false)">
+ *   <div>Popover content</div>
+ * </ea-popover>
+ * ```
+ */
+export declare class PopoverComponent {
+  private readonly destroyRef;
+  private readonly press;
+  private readonly surfaceEl;
+  /** Anchor element the popover positions itself against. */
+  readonly anchor: import("@angular/core").InputSignal<HTMLElement | ElementRef<HTMLElement> | undefined>;
+  /** Whether the popover is currently open. */
+  readonly open: import("@angular/core").InputSignal<boolean>;
+  /** Where the popover attaches relative to the anchor. */
+  readonly placement: import("@angular/core").InputSignal<PopoverPlacement>;
+  /**
+   * Viewport point to position against instead of the anchor's box, such as where
+   * a context menu was requested. The placement applies around the point, which
+   * keeps its offset from the anchor as the page scrolls.
+   */
+  readonly anchorPoint: import("@angular/core").InputSignal<PopoverAnchorPoint | null>;
+  /** ARIA role applied to the popover surface. */
+  readonly role: import("@angular/core").InputSignal<PopoverRole>;
+  /** Accessible label. Falls back to nothing; consumers should provide one when no visible heading is in the popover. */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Id of the element that labels the popover surface, forwarded as `aria-labelledby`. */
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string | undefined>;
+  /** Keep Tab and Shift+Tab cycling within the surface while open (dialog pattern). */
+  readonly trapFocus: import("@angular/core").InputSignal<boolean>;
+  /** DOM id for the surface so trigger elements can reference it via aria-controls. */
+  readonly surfaceId: import("@angular/core").InputSignal<string>;
+  /**
+   * Gap in px between the anchor and the popover. Defaults to 2 so an open panel
+   * clears the anchor's active focus ring instead of sitting flush over it.
+   */
+  readonly offset: import("@angular/core").InputSignal<number>;
+  /** Flip to the opposite side when the requested side overflows the viewport. */
+  readonly flip: import("@angular/core").InputSignal<boolean>;
+  /** Clamp the popover inside the viewport when it would otherwise overflow. */
+  readonly clamp: import("@angular/core").InputSignal<boolean>;
+  /** Set the popover's `min-width` to match the anchor's width (dropdown pattern). */
+  readonly matchAnchorWidth: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Widest the surface may grow: a px value, or `anchor` to cap it at the
+   * anchor's own width so long content truncates instead of widening the panel.
+   */
+  readonly maxWidth: import("@angular/core").InputSignal<PopoverMaxWidth | undefined>;
+  /** Close on click outside the popover and the anchor. */
+  readonly closeOnOutsideClick: import("@angular/core").InputSignal<boolean>;
+  /** Close on Escape. */
+  readonly closeOnEscape: import("@angular/core").InputSignal<boolean>;
+  /** What to do on scroll / resize while open. */
+  readonly scrollBehavior: import("@angular/core").InputSignal<PopoverScrollBehavior>;
+  /**
+   * Behaves as a context menu: moves focus to the first focusable element once
+   * shown and hands it back on close, and treats clicks on the anchor and
+   * context-menu requests anywhere outside the surface as outside clicks.
+   */
+  readonly contextMenu: import("@angular/core").InputSignal<boolean>;
+  /** Requested close. The parent should mirror this into `[open]`. */
+  readonly closeRequested: import("@angular/core").OutputEmitterRef<void>;
+  /**
+   * Requested open, from a trigger such as `[eaContextMenuTrigger]`. The parent
+   * should mirror this into `[open]`, and the point into `[anchorPoint]`.
+   */
+  readonly openRequested: import("@angular/core").OutputEmitterRef<PopoverOpenRequest>;
+  private readonly position;
+  private latched;
+  private pointOffset;
+  private focusReturn;
+  /** True placement after flip, for class-based styling (e.g. arrow direction). */
+  readonly effectivePlacement: import("@angular/core").Signal<PopoverPlacement>;
+  /** Latches true once the post-rAF reposition has run, so the surface is
+   * only revealed after its dimensions are guaranteed stable. Reset on close. */
+  private readonly stable;
+  /** True once the first `reposition()` has resolved a placement on a
+   * laid-out surface. Drives the `--positioned` class. */
+  readonly isPositioned: import("@angular/core").Signal<boolean>;
+  /** Class list for the surface. Computed in TS so the placement key (with
+   * its interpolated suffix) and the positioned modifier compose cleanly. */
+  readonly surfaceClass: import("@angular/core").Signal<string>;
+  /** Inline style applied to the surface element. */
+  readonly surfaceStyle: import("@angular/core").Signal<Record<string, string>>;
+  constructor();
+  requestOpen(point: PopoverAnchorPoint | null): void;
+  private resolveAnchor;
+  private reposition;
+  onDocumentClick(event: MouseEvent): void;
+  onSurfaceKeydown(event: KeyboardEvent): void;
+  private focusableElements;
+  private focusFirstElement;
+  private trackFocusReturn;
+  onEscape(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PopoverComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PopoverComponent, "ea-popover", never, {
+    "anchor": {
+      "alias": "anchor";
+      "required": true;
+      "isSignal": true;
+    };
+    "open": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+    "placement": {
+      "alias": "placement";
+      "required": false;
+      "isSignal": true;
+    };
+    "anchorPoint": {
+      "alias": "anchorPoint";
+      "required": false;
+      "isSignal": true;
+    };
+    "role": {
+      "alias": "role";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "aria-label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "aria-labelledby";
+      "required": false;
+      "isSignal": true;
+    };
+    "trapFocus": {
+      "alias": "trapFocus";
+      "required": false;
+      "isSignal": true;
+    };
+    "surfaceId": {
+      "alias": "surfaceId";
+      "required": false;
+      "isSignal": true;
+    };
+    "offset": {
+      "alias": "offset";
+      "required": false;
+      "isSignal": true;
+    };
+    "flip": {
+      "alias": "flip";
+      "required": false;
+      "isSignal": true;
+    };
+    "clamp": {
+      "alias": "clamp";
+      "required": false;
+      "isSignal": true;
+    };
+    "matchAnchorWidth": {
+      "alias": "matchAnchorWidth";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxWidth": {
+      "alias": "maxWidth";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeOnOutsideClick": {
+      "alias": "closeOnOutsideClick";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeOnEscape": {
+      "alias": "closeOnEscape";
+      "required": false;
+      "isSignal": true;
+    };
+    "scrollBehavior": {
+      "alias": "scrollBehavior";
+      "required": false;
+      "isSignal": true;
+    };
+    "contextMenu": {
+      "alias": "contextMenu";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "closeRequested": "closeRequested";
+    "openRequested": "openRequested";
+  }, never, ["*"], true, never>;
+}
+/**
+ * Where `[eaContextMenuTrigger]` opens its target: at the pointer (below the
+ * focused element for a keyboard request), or at the target's own placement
+ * against the host.
+ */
+export type ContextMenuPosition = 'pointer' | 'anchor';
+/** An overlay `[eaContextMenuTrigger]` can open as a context menu. */
+export type ContextMenuTarget = MenuComponent | PopoverComponent;
+/**
+ * Opens an `<ea-menu>` or `<ea-popover>` as the context menu of its host: on a
+ * right-click or long press, or from the keyboard with Shift+F10 or the
+ * context-menu key while focus is on the host or inside it. The browser's own
+ * menu is suppressed only when the target opens, so a `null` target, a disabled
+ * menu, or a request something inside the host has already handled leaves it be.
+ *
+ * A menu opens straight away. A popover's parent drives its `[open]` state, so it
+ * emits `openRequested` with the point to bind to `[anchorPoint]` instead; give it
+ * `[contextMenu]="true"` so it takes focus and dismisses like a context menu.
+ *
+ * @example
+ * ```html
+ * <article [eaContextMenuTrigger]="actions">Right-click me</article>
+ * <ea-menu #actions>
+ *   <ea-menu-item>Rename</ea-menu-item>
+ * </ea-menu>
+ * ```
+ */
+export declare class ContextMenuTriggerDirective {
+  private readonly el;
+  /** The menu or popover to open; `null` or `undefined` leaves the browser's own menu. */
+  readonly target: import("@angular/core").InputSignal<ContextMenuTarget | null | undefined>;
+  /**
+   * Opens at the pointer, or below the focused element for a keyboard request;
+   * `anchor` opens at the target's placement against the host instead.
+   */
+  readonly contextMenuPosition: import("@angular/core").InputSignal<ContextMenuPosition>;
+  onContextMenu(event: MouseEvent): void;
+  onKeydown(event: KeyboardEvent): void;
+  private request;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuTriggerDirective, "[eaContextMenuTrigger]", never, {
+    "target": {
+      "alias": "eaContextMenuTrigger";
+      "required": false;
+      "isSignal": true;
+    };
+    "contextMenuPosition": {
+      "alias": "contextMenuPosition";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
 /** Vertical density preset for table rows and header cells. */
 export type DataTableDensity = 'compact' | 'comfortable' | 'spacious';
 /** Visual size of the table's text, paddings, and icons. */
@@ -2650,6 +3123,22 @@ export interface DataTableColumn<T = Record<string, unknown>> {
   headerTemplate?: TemplateRef<{
     $implicit: DataTableColumn<T>;
   }>;
+  /** Shown in this column's cells while the table is `loading`, in place of a skeleton bar. */
+  placeholderTemplate?: TemplateRef<{
+    $implicit: DataTableColumn<T>;
+    index: number;
+  }>;
+}
+/** A body row's context-menu request, as `rowContextMenu` emits it. */
+export interface DataTableRowContextMenuEvent<T = Record<string, unknown>> {
+  /** The row's data. */
+  readonly row: T;
+  /** The row's `<tr>`, for anchoring a menu or popover to the row. */
+  readonly rowElement: HTMLElement;
+  /** Where to open a menu: the pointer, or below the focused row or cell for a keyboard request. */
+  readonly point: PopoverAnchorPoint;
+  /** The originating event; call `preventDefault()` on it to suppress the browser's own menu. */
+  readonly event: MouseEvent | KeyboardEvent;
 }
 /** Current sort state: which column is sorted and in which direction. */
 export interface DataTableSortState {
@@ -2667,6 +3156,7 @@ export declare class DataTableComponent<T = Record<string, unknown>> {
   private readonly host;
   private readonly activeCell;
   private static readonly PAGE_JUMP;
+  private keyboardRequestPending;
   readonly columns: import("@angular/core").InputSignal<DataTableColumn<T>[]>;
   readonly data: import("@angular/core").InputSignal<T[]>;
   /**
@@ -2702,14 +3192,30 @@ export declare class DataTableComponent<T = Record<string, unknown>> {
    * A row given `null` is inert: no link, hover highlight, focus or activation.
    */
   readonly rowHref: import("@angular/core").InputSignal<((row: T) => string | null) | undefined>;
+  /**
+   * Shows placeholder rows in place of the data while it loads, and marks the table
+   * busy for assistive technology. A placeholder row stands as tall as a row of text,
+   * and `sizingRows` keep the columns at their loaded widths.
+   */
+  readonly loading: import("@angular/core").InputSignal<boolean>;
+  /** How many placeholder rows to show while `loading`. */
+  readonly loadingRowCount: import("@angular/core").InputSignal<number>;
   readonly sort: import("@angular/core").ModelSignal<DataTableSortState>;
   /** Fires whenever the sort column or direction changes via header click. */
   readonly sorted: import("@angular/core").OutputEmitterRef<DataTableSortState>;
   /** Fires with the row's data when a body row is activated by click or Enter/Space while `clickable` is set. */
   readonly rowActivate: import("@angular/core").OutputEmitterRef<T>;
+  /**
+   * Fires when a body row's context menu is requested: by right-click or long press,
+   * or by Shift+F10 or the context-menu key with focus in the row. Call
+   * `event.preventDefault()` when opening a menu of your own.
+   */
+  readonly rowContextMenu: import("@angular/core").OutputEmitterRef<DataTableRowContextMenuEvent<T>>;
   readonly noDataTemplate: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
   /** Empty-state text, falling back to the active locale's translation. */
   readonly resolvedNoDataText: import("@angular/core").Signal<string>;
+  readonly placeholderRows: import("@angular/core").Signal<number[]>;
+  private readonly bodyRowCount;
   readonly hostClasses: import("@angular/core").Signal<{
     [x: string]: boolean;
     'ea-data-table--sticky': boolean;
@@ -2732,6 +3238,8 @@ export declare class DataTableComponent<T = Record<string, unknown>> {
   isInert(row: T): boolean;
   rowTabindex(row: T): number | null;
   onRowActivate(row: T, event?: Event): void;
+  onRowContextMenu(row: T, rowElement: HTMLElement, event: MouseEvent | KeyboardEvent): void;
+  clearKeyboardRequest(): void;
   onCellFocus(row: number, col: number): void;
   onGridKeydown(event: KeyboardEvent): void;
   private focusCell;
@@ -2822,6 +3330,16 @@ export declare class DataTableComponent<T = Record<string, unknown>> {
       "required": false;
       "isSignal": true;
     };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadingRowCount": {
+      "alias": "loadingRowCount";
+      "required": false;
+      "isSignal": true;
+    };
     "sort": {
       "alias": "sort";
       "required": false;
@@ -2831,6 +3349,7 @@ export declare class DataTableComponent<T = Record<string, unknown>> {
     "sort": "sortChange";
     "sorted": "sorted";
     "rowActivate": "rowActivate";
+    "rowContextMenu": "rowContextMenu";
   }, ["noDataTemplate"], ["ea-paginator"], true, never>;
 }
 /** Visual size of each digit cell. */
@@ -3234,6 +3753,10 @@ export type DialogWidth = EaWidth;
  * `--ea-dialog-body-padding`, and `--ea-dialog-status-padding`; an
  * edge-to-edge media surface zeroes the inset, radius, and paddings.
  *
+ * The first dialog rendered by a component opened through `DialogService`
+ * answers to its `DialogRef`: it opens as soon as it renders, and a dismissal
+ * closes the ref with `undefined`.
+ *
  * Specs running under jsdom need `installNativeDialogShim()` from
  * `@eagami/ui/testing` before opening one.
  */
@@ -3246,6 +3769,7 @@ export declare class DialogComponent implements AfterContentChecked {
   private readonly press;
   private readonly scrollLock;
   private holdsScroll;
+  private boundRef;
   readonly width: import("@angular/core").InputSignal<EaWidth>;
   /**
    * Modal by default: shown via `showModal()`, with the backdrop overlay and
@@ -3289,6 +3813,7 @@ export declare class DialogComponent implements AfterContentChecked {
   protected readonly hasHeader: import("@angular/core").WritableSignal<boolean>;
   ngAfterContentChecked(): void;
   constructor();
+  private closeSurface;
   private holdScroll;
   private dropScroll;
   handleClose(): void;
@@ -3357,6 +3882,64 @@ export declare class DialogComponent implements AfterContentChecked {
     "closeRequested": "closeRequested";
   }, never, ["[slot=header]", "*", "[slot=status]", "[slot=footer]"], true, never>;
 }
+/**
+ * Handle on one dialog opened through `DialogService`. The component it opened
+ * injects it to close with an answer, which settles `result` for whoever
+ * opened it; a dismissal (Escape, the backdrop, the close button) closes it
+ * with `undefined`. Construct one directly to stand in for the service in a
+ * spec.
+ */
+export declare class DialogRef<R = unknown> {
+  private readonly isClosed;
+  private settler;
+  /** Whether the dialog has closed. */
+  readonly closed: Signal<boolean>;
+  /**
+   * Settles when the dialog closes: with the value passed to `close`, or with
+   * `undefined` when it was dismissed.
+   */
+  readonly result: Promise<R | undefined>;
+  /** Closes the dialog and settles `result` with `value`. Only the first call has any effect. */
+  close(value?: R): void;
+}
+/** Options for {@link DialogService.open}. */
+export interface DialogOptions {
+  /** Values for the component's inputs, keyed by input name and set before it first renders. */
+  inputs?: Readonly<Record<string, unknown>>;
+  /**
+   * Injector the component resolves its dependencies through, such as the
+   * opener's own so providers scoped to it reach the dialog. Defaults to the
+   * application's root injector.
+   */
+  injector?: Injector;
+}
+/**
+ * Opens dialogs from code. `open` renders a component at the end of `<body>`
+ * and returns its {@link DialogRef}. The component lays out its own
+ * `<ea-dialog>`, which shows itself straight away and closes the ref with
+ * `undefined` on any dismissal, and injects the ref to close it with an
+ * answer. Closing the ref takes the component down and hands focus back to
+ * wherever it was when the dialog opened. A dialog opened while another is up
+ * stacks on top of it.
+ *
+ * On the server nothing is rendered and the ref closes at once.
+ */
+export declare class DialogService {
+  private readonly appRef;
+  private readonly document;
+  private readonly injector;
+  private readonly isBrowser;
+  private readonly openDialogs;
+  /** Dialogs currently open, oldest first. */
+  readonly dialogs: Signal<readonly DialogRef<unknown>[]>;
+  constructor();
+  /** Opens `component` as a dialog and returns its ref, whose `result` settles when it closes. */
+  open<R = unknown>(component: Type<unknown>, options?: DialogOptions): DialogRef<R>;
+  /** Closes every open dialog, newest first, settling each `result` with `undefined`. */
+  closeAll(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
 /** Orientation of the divider rule. */
 export type DividerOrientation = 'horizontal' | 'vertical';
 /**
@@ -4973,126 +5556,22 @@ export declare class LineChartComponent {
       "alias": "animationDuration";
       "required": false;
       "isSignal": true;
-    };
-    "formatValue": {
-      "alias": "formatValue";
-      "required": false;
-      "isSignal": true;
-    };
-    "ariaLabel": {
-      "alias": "aria-label";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {
-    "pointClick": "pointClick";
-    "activePointChange": "activePointChange";
-    "visibleRangeChange": "visibleRangeChange";
-  }, never, never, true, never>;
-}
-/** Placement of the menu list relative to its trigger. */
-export type MenuPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
-/** Visual size of the menu, shared by all of its items. */
-export type MenuSize = EaSize;
-/**
- * Popup action menu attached to any focusable element via the
- * `[eaMenuTrigger]` directive. Supports keyboard navigation
- * (arrow keys, Home/End), closes on outside click or Escape, and restores
- * focus to the trigger on close. Positioning, dismissal, and SSR-safe scroll
- * handling are provided by `<ea-popover>`.
- */
-export declare class MenuComponent {
-  private readonly injector;
-  private readonly i18n;
-  private readonly listEl;
-  readonly placement: import("@angular/core").InputSignal<MenuPlacement>;
-  /** Visual size of the menu; every item inherits it. */
-  readonly size: import("@angular/core").InputSignal<EaSize>;
-  /** Max height of the scrollable list as a CSS length; tall menus scroll past it. */
-  readonly maxHeight: import("@angular/core").InputSignal<string>;
-  readonly disabled: import("@angular/core").InputSignal<boolean>;
-  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
-  readonly id: import("@angular/core").InputSignal<string>;
-  /** Accessible label for the menu, falling back to the active locale. */
-  readonly resolvedAriaLabel: import("@angular/core").Signal<string>;
-  readonly open: import("@angular/core").ModelSignal<boolean>;
-  /** Fires when the menu opens. */
-  readonly opened: import("@angular/core").OutputEmitterRef<void>;
-  /** Fires when the menu closes. */
-  readonly closed: import("@angular/core").OutputEmitterRef<void>;
-  /** Trigger element currently anchoring the menu. Signal-typed so `<ea-popover>` reacts when it changes. */
-  protected readonly triggerEl: import("@angular/core").WritableSignal<HTMLElement | undefined>;
-  readonly activeItemId: import("@angular/core").WritableSignal<string | null>;
-  constructor();
-  /** Toggles the menu open state, anchoring it to the given trigger element. */
-  toggleAt(triggerEl: HTMLElement): void;
-  /** Opens the menu anchored to the given trigger element and focuses the first item. */
-  openAt(triggerEl: HTMLElement): void;
-  /**
-   * Closes the menu if it is open. Pass `restoreFocus: true` to return focus
-   * to the trigger element (used when closing via Escape or item activation;
-   * not used on outside click, where the user has chosen a new focus target).
-   */
-  close(restoreFocus?: boolean): void;
-  /** Called by `<ea-popover>` when the user clicks outside the menu. */
-  onPopoverCloseRequested(): void;
-  private getEnabledItems;
-  /**
-   * `preventScroll: true` is critical here. The menu list is `position: fixed`
-   * but its DOM ancestor is whatever element hosts the menu (often a sticky
-   * header). When `.focus()` is called without `preventScroll`, Chromium uses
-   * the focused element's DOM-tree position (inside the sticky ancestor) rather
-   * than its rendered fixed position to decide whether to scroll, which on a
-   * scrolled page nudges the document up by a few pixels per open, until the
-   * trigger reaches the top edge. The same guard applies to keyboard navigation
-   * and restoring focus on close.
-   */
-  private focusFirstItem;
-  private focusItem;
-  onKeydown(event: KeyboardEvent): void;
-  onEscape(event: Event): void;
-  static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "ea-menu", never, {
-    "placement": {
-      "alias": "placement";
-      "required": false;
-      "isSignal": true;
-    };
-    "size": {
-      "alias": "size";
-      "required": false;
-      "isSignal": true;
-    };
-    "maxHeight": {
-      "alias": "maxHeight";
-      "required": false;
-      "isSignal": true;
-    };
-    "disabled": {
-      "alias": "disabled";
-      "required": false;
-      "isSignal": true;
-    };
-    "ariaLabel": {
-      "alias": "aria-label";
-      "required": false;
-      "isSignal": true;
-    };
-    "id": {
-      "alias": "id";
+    };
+    "formatValue": {
+      "alias": "formatValue";
       "required": false;
       "isSignal": true;
     };
-    "open": {
-      "alias": "open";
+    "ariaLabel": {
+      "alias": "aria-label";
       "required": false;
       "isSignal": true;
     };
   }, {
-    "open": "openChange";
-    "opened": "opened";
-    "closed": "closed";
-  }, never, ["*"], true, never>;
+    "pointClick": "pointClick";
+    "activePointChange": "activePointChange";
+    "visibleRangeChange": "visibleRangeChange";
+  }, never, never, true, never>;
 }
 /** Visual style of a menu item; `danger` for destructive actions. */
 export type MenuItemVariant = 'default' | 'danger';
@@ -5148,252 +5627,6 @@ export declare class MenuTriggerDirective {
     };
   }, {}, never, never, true, never>;
 }
-/**
- * Placement of the popover relative to its anchor. Each placement names the
- * side of the anchor the popover attaches to, optionally followed by a corner
- * suffix (`-start` or `-end`) that decides the alignment along the perpendicular
- * axis. The plain side names (`top`, `bottom`, `left`, `right`) centre the
- * popover on that axis.
- */
-export type PopoverPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'right';
-export interface PopoverPositionResult {
-  /** Top coordinate in viewport (px); pairs with `position: fixed`. */
-  readonly top: number;
-  /** Left coordinate in viewport (px). */
-  readonly left: number;
-  /** Width hint when the popover should match the anchor's width. */
-  readonly width?: number;
-  /** The anchor's measured width, for a caller capping the popover against it. */
-  readonly anchorWidth: number;
-  /** Effective placement after any flip logic ran. */
-  readonly placement: PopoverPlacement;
-}
-export interface PopoverPositionOptions {
-  readonly placement: PopoverPlacement;
-  /** Gap in px between the anchor and the popover. Default 4. */
-  readonly offset?: number;
-  /** Flip to the opposite side when the requested side overflows the viewport. Default true. */
-  readonly flip?: boolean;
-  /** Clamp inside the viewport when the popover still overflows after any flip. Default true. */
-  readonly clamp?: boolean;
-  /** Margin from the viewport edge in px when clamping. Default 8. */
-  readonly margin?: number;
-  /** Set the popover's width to match the anchor's. Useful for dropdown-style menus. */
-  readonly matchAnchorWidth?: boolean;
-  /** Right-to-left context. Swaps `-start`/`-end` alignment so they track the reading direction. */
-  readonly rtl?: boolean;
-}
-interface Rect {
-  readonly width: number;
-  readonly height: number;
-}
-interface AnchorRect extends Rect {
-  readonly top: number;
-  readonly bottom: number;
-  readonly left: number;
-  readonly right: number;
-}
-interface Viewport {
-  readonly width: number;
-  readonly height: number;
-}
-/**
- * Computes the viewport-space top/left for a popover anchored to `anchorRect`,
- * applying optional flip-on-overflow and edge-clamp logic. Pure function, no
- * DOM access. Both `<ea-popover>` and `[eaTooltip]` consume this.
- *
- * @param anchorRect  The anchor element's `getBoundingClientRect()`.
- * @param popoverRect Width and height of the popover (post-render measurement).
- * @param viewport    Viewport dimensions (`window.innerWidth/Height`).
- * @param options     Placement and behavior flags.
- */
-export declare function computePopoverPosition(anchorRect: AnchorRect, popoverRect: Rect, viewport: Viewport, options: PopoverPositionOptions): PopoverPositionResult;
-/** ARIA role to apply to the popover surface. */
-export type PopoverRole = 'menu' | 'listbox' | 'dialog' | 'tooltip' | 'grid';
-/**
- * How the popover should respond to scroll / resize events while open.
- *
- * - `reposition` (default): re-measure the anchor and update the popover's
- *   coordinates so it stays attached. Suitable for menus and tooltips.
- * - `close`: request close. Suitable for dropdown lists and the colour-picker
- *   popover, where re-tracking a tall popover during a scroll feels intrusive.
- * - `ignore`: do nothing. The popover stays at its initial coordinates and
- *   may visually detach from a scrolling anchor; useful when the anchor is
- *   guaranteed not to move (e.g. inside a non-scrolling region).
- */
-export type PopoverScrollBehavior = 'reposition' | 'close' | 'ignore';
-/** Width cap for a popover surface: px, or the anchor's own width. */
-export type PopoverMaxWidth = number | 'anchor';
-/**
- * Floating-element primitive. Renders projected content as `position: fixed`
- * anchored to an external element, with flip-on-overflow, viewport clamping,
- * outside-click and Escape dismissal, and SSR-safe scroll / resize handling.
- *
- * The primitive is intentionally low-level: a parent component drives the
- * `[open]` state and listens for `(closeRequested)` to mirror it back. Internal
- * library components (`<ea-menu>`, `<ea-dropdown>`, `<ea-color-picker>`,
- * `<ea-date-picker>`, `[eaTooltip]`) compose on top of it; downstream apps can
- * use it directly to build their own popover-based UI.
- *
- * @example
- * ```html
- * <button #trigger (click)="open.set(!open())">Open</button>
- * <ea-popover [anchor]="trigger" [open]="open()" (closeRequested)="open.set(false)">
- *   <div>Popover content</div>
- * </ea-popover>
- * ```
- */
-export declare class PopoverComponent {
-  private readonly destroyRef;
-  private readonly press;
-  private readonly surfaceEl;
-  /** Anchor element the popover positions itself against. */
-  readonly anchor: import("@angular/core").InputSignal<HTMLElement | ElementRef<HTMLElement> | undefined>;
-  /** Whether the popover is currently open. */
-  readonly open: import("@angular/core").InputSignal<boolean>;
-  /** Where the popover attaches relative to the anchor. */
-  readonly placement: import("@angular/core").InputSignal<PopoverPlacement>;
-  /** ARIA role applied to the popover surface. */
-  readonly role: import("@angular/core").InputSignal<PopoverRole>;
-  /** Accessible label. Falls back to nothing; consumers should provide one when no visible heading is in the popover. */
-  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
-  /** Id of the element that labels the popover surface, forwarded as `aria-labelledby`. */
-  readonly ariaLabelledby: import("@angular/core").InputSignal<string | undefined>;
-  /** Keep Tab and Shift+Tab cycling within the surface while open (dialog pattern). */
-  readonly trapFocus: import("@angular/core").InputSignal<boolean>;
-  /** DOM id for the surface so trigger elements can reference it via aria-controls. */
-  readonly surfaceId: import("@angular/core").InputSignal<string>;
-  /**
-   * Gap in px between the anchor and the popover. Defaults to 2 so an open panel
-   * clears the anchor's active focus ring instead of sitting flush over it.
-   */
-  readonly offset: import("@angular/core").InputSignal<number>;
-  /** Flip to the opposite side when the requested side overflows the viewport. */
-  readonly flip: import("@angular/core").InputSignal<boolean>;
-  /** Clamp the popover inside the viewport when it would otherwise overflow. */
-  readonly clamp: import("@angular/core").InputSignal<boolean>;
-  /** Set the popover's `min-width` to match the anchor's width (dropdown pattern). */
-  readonly matchAnchorWidth: import("@angular/core").InputSignal<boolean>;
-  /**
-   * Widest the surface may grow: a px value, or `anchor` to cap it at the
-   * anchor's own width so long content truncates instead of widening the panel.
-   */
-  readonly maxWidth: import("@angular/core").InputSignal<PopoverMaxWidth | undefined>;
-  /** Close on click outside the popover and the anchor. */
-  readonly closeOnOutsideClick: import("@angular/core").InputSignal<boolean>;
-  /** Close on Escape. */
-  readonly closeOnEscape: import("@angular/core").InputSignal<boolean>;
-  /** What to do on scroll / resize while open. */
-  readonly scrollBehavior: import("@angular/core").InputSignal<PopoverScrollBehavior>;
-  /** Requested close. The parent should mirror this into `[open]`. */
-  readonly closeRequested: import("@angular/core").OutputEmitterRef<void>;
-  private readonly position;
-  private latched;
-  /** True placement after flip, for class-based styling (e.g. arrow direction). */
-  readonly effectivePlacement: import("@angular/core").Signal<PopoverPlacement>;
-  /** Latches true once the post-rAF reposition has run, so the surface is
-   * only revealed after its dimensions are guaranteed stable. Reset on close. */
-  private readonly stable;
-  /** True once the first `reposition()` has resolved a placement on a
-   * laid-out surface. Drives the `--positioned` class. */
-  readonly isPositioned: import("@angular/core").Signal<boolean>;
-  /** Class list for the surface. Computed in TS so the placement key (with
-   * its interpolated suffix) and the positioned modifier compose cleanly. */
-  readonly surfaceClass: import("@angular/core").Signal<string>;
-  /** Inline style applied to the surface element. */
-  readonly surfaceStyle: import("@angular/core").Signal<Record<string, string>>;
-  constructor();
-  private resolveAnchor;
-  private reposition;
-  onDocumentClick(event: MouseEvent): void;
-  onSurfaceKeydown(event: KeyboardEvent): void;
-  onEscape(event: Event): void;
-  static ɵfac: i0.ɵɵFactoryDeclaration<PopoverComponent, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<PopoverComponent, "ea-popover", never, {
-    "anchor": {
-      "alias": "anchor";
-      "required": true;
-      "isSignal": true;
-    };
-    "open": {
-      "alias": "open";
-      "required": false;
-      "isSignal": true;
-    };
-    "placement": {
-      "alias": "placement";
-      "required": false;
-      "isSignal": true;
-    };
-    "role": {
-      "alias": "role";
-      "required": false;
-      "isSignal": true;
-    };
-    "ariaLabel": {
-      "alias": "aria-label";
-      "required": false;
-      "isSignal": true;
-    };
-    "ariaLabelledby": {
-      "alias": "aria-labelledby";
-      "required": false;
-      "isSignal": true;
-    };
-    "trapFocus": {
-      "alias": "trapFocus";
-      "required": false;
-      "isSignal": true;
-    };
-    "surfaceId": {
-      "alias": "surfaceId";
-      "required": false;
-      "isSignal": true;
-    };
-    "offset": {
-      "alias": "offset";
-      "required": false;
-      "isSignal": true;
-    };
-    "flip": {
-      "alias": "flip";
-      "required": false;
-      "isSignal": true;
-    };
-    "clamp": {
-      "alias": "clamp";
-      "required": false;
-      "isSignal": true;
-    };
-    "matchAnchorWidth": {
-      "alias": "matchAnchorWidth";
-      "required": false;
-      "isSignal": true;
-    };
-    "maxWidth": {
-      "alias": "maxWidth";
-      "required": false;
-      "isSignal": true;
-    };
-    "closeOnOutsideClick": {
-      "alias": "closeOnOutsideClick";
-      "required": false;
-      "isSignal": true;
-    };
-    "closeOnEscape": {
-      "alias": "closeOnEscape";
-      "required": false;
-      "isSignal": true;
-    };
-    "scrollBehavior": {
-      "alias": "scrollBehavior";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {
-    "closeRequested": "closeRequested";
-  }, never, ["*"], true, never>;
-}
 /** Visual size of the multi-select trigger. */
 export type MultiSelectSize = EaSize;
 /**