@star-ng/ui 0.0.0-stage → 0.2.0

package/types/star-ng-ui-table.d.ts

@@ -0,0 +1,885 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { StarOptionKey } from "@star-ng/ui/core";
+export interface StarColumn<T> {
+  /** Unique column id; also the property read when `value` is not set. */
+  readonly field: string;
+  readonly header: string;
+  /** Cell value accessor (default: `row[field]`). Used for display, sort and filter. */
+  readonly value?: (row: T) => unknown;
+  /** Display text (default: `String(value)`). */
+  readonly format?: (row: T) => string;
+  readonly sortable?: boolean;
+  readonly width?: string;
+  readonly align?: 'start' | 'center' | 'end';
+  /**
+   * Column filter, shown in a second header row.
+   * - `'text'`: the display text contains the query (case- and accent-insensitive).
+   * - `'select'`: the display text equals the choice.
+   * - `'multiselect'`: the display text is one of the choices (value: text list).
+   * - `'number'`: the cell value is in a range (value: `{ min, max }` numbers).
+   * - `'date'`: the cell day is in a range (value: `{ min, max }` as `yyyy-mm-dd`).
+   */
+  readonly filter?: 'text' | 'select' | 'multiselect' | 'number' | 'date';
+  /** Choices of a `'select'` or `'multiselect'` filter (default: the distinct display texts in `value`, sorted). */
+  readonly filterOptions?: readonly string[];
+  /** `false` leaves the column out of every export (CSV, Excel, print). */
+  readonly exportable?: boolean;
+  /**
+   * Cell value in an export. Use it for a column with a custom cell template, where the
+   * display text is not what the user sees. A number stays a number in Excel.
+   */
+  readonly exportValue?: (row: T) => string | number | null | undefined;
+  /**
+   * Keeps the column in view when the table scrolls sideways. Frozen columns come first.
+   * The table measures the frozen columns to position the next one, so `width` is optional.
+   */
+  readonly frozen?: boolean;
+  /** `false`: the user cannot hide the column in the Columns panel. */
+  readonly hideable?: boolean;
+  /**
+   * The user can change the cell in place. The table does not change `value`: it emits
+   * `cellEdit`, and the owner stores the new value.
+   */
+  readonly editable?: boolean | ((row: T) => boolean);
+  /** Editor of an editable cell (default `'text'`). `'number'` emits a number or `null`. */
+  readonly editor?: 'text' | 'number' | 'select';
+  /** Choices of a `'select'` editor. */
+  readonly editOptions?: readonly string[];
+  /**
+   * Footer cell: fixed text, or a function of the filtered rows (all pages), for a total or
+   * an average. The table has a footer row when one column has a footer.
+   */
+  readonly footer?: string | ((rows: readonly T[]) => string);
+}
+export interface StarCellEditEvent<T> {
+  readonly row: T;
+  readonly field: string;
+  /** New value: text, or a number / `null` for the `'number'` editor. */
+  readonly value: string | number | null;
+  readonly previous: unknown;
+}
+/** Range of a `'number'` filter (numbers) or a `'date'` filter (`yyyy-mm-dd` text). */
+export interface StarRangeFilter {
+  readonly min?: number | string | null;
+  readonly max?: number | string | null;
+}
+/** Text (`'text'`, `'select'`), text list (`'multiselect'`) or range (`'number'`, `'date'`). */
+export type StarFilterValue = string | readonly string[] | StarRangeFilter;
+/** Column filter values by column `field`. An empty or missing value means "no filter". */
+export type StarColumnFilters = Readonly<Record<string, StarFilterValue>>;
+export interface StarExportOptions<T = unknown> {
+  /** File name without extension (default `export`). */
+  readonly fileName?: string;
+  /** Export the selected rows only (default: all filtered rows, in the current sort order). */
+  readonly selectionOnly?: boolean;
+  /**
+   * Rows to export instead of the table rows. Use it in lazy mode, where the table holds one
+   * page: load all rows from the server and pass them here.
+   */
+  readonly rows?: readonly T[];
+  /** Sheet name (Excel) or heading (print). Default: the table `ariaLabel`. */
+  readonly title?: string;
+}
+export interface StarCsvOptions<T = unknown> extends StarExportOptions<T> {
+  /** Field separator (default `,`). */
+  readonly separator?: string;
+}
+/** One line of the table body: a spacer, a group heading, or a row with its detail row. */
+type BodyEntry<T> = {
+  readonly kind: 'spacer';
+  readonly key: string;
+  readonly height: number;
+} | {
+  readonly kind: 'group';
+  readonly key: string;
+  readonly label: string;
+  readonly count: number;
+  /** `aria-rowindex`, or null without virtual scroll. */
+  readonly aria: number | null;
+  /** Index in the virtual list (`data-vi`), or null without virtual scroll. */
+  readonly item: number | null;
+} | {
+  readonly kind: 'row';
+  readonly key: unknown;
+  readonly row: T;
+  readonly index: number;
+  readonly aria: number | null;
+  readonly item: number | null;
+};
+export type StarSortOrder = 1 | -1;
+export interface StarSortState {
+  readonly field: string | null;
+  readonly order: StarSortOrder;
+}
+export interface StarLazyLoadEvent extends StarSortState {
+  readonly first: number;
+  readonly rows: number;
+  readonly filter: string;
+  readonly filters: StarColumnFilters;
+  /** All sort columns in priority order (one entry without `multiSort`). */
+  readonly sorts: readonly StarSortState[];
+}
+/** The user asked to move a row. The table does not change `value`: the owner moves the row. */
+export interface StarRowReorderEvent<T> {
+  readonly row: T;
+  /** Index of the row in `value` now, and the index it must get. */
+  readonly from: number;
+  readonly to: number;
+}
+export interface StarCellContext<T> {
+  readonly $implicit: T;
+  readonly value: unknown;
+  readonly index: number;
+}
+/** Custom cell: `<ng-template starCell="status" let-row let-value="value">…</ng-template>`. */
+export declare class StarCellTemplate<T = unknown> {
+  readonly starCell: import("@angular/core").InputSignal<string>;
+  /** Optional: pass the table rows to type `let-row` in strict templates. */
+  readonly starCellOf: import("@angular/core").InputSignal<readonly T[] | null>;
+  readonly template: TemplateRef<StarCellContext<T>>;
+  static ngTemplateContextGuard<T>(_dir: StarCellTemplate<T>, _ctx: unknown): _ctx is StarCellContext<T>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StarCellTemplate<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StarCellTemplate<any>, "ng-template[starCell]", never, {
+    "starCell": {
+      "alias": "starCell";
+      "required": true;
+      "isSignal": true;
+    };
+    "starCellOf": {
+      "alias": "starCellOf";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export interface StarRowContext<T> {
+  readonly $implicit: T;
+  readonly index: number;
+}
+/**
+ * Detail content of an expanded row. When the table has this template, each row gets an
+ * expand button: `<ng-template starRowExpansion let-row>…</ng-template>`.
+ */
+export declare class StarRowExpansionTemplate<T = unknown> {
+  /** Optional: pass the table rows to type `let-row` in strict templates. */
+  readonly starRowExpansionOf: import("@angular/core").InputSignal<readonly T[] | null>;
+  readonly template: TemplateRef<StarRowContext<T>>;
+  static ngTemplateContextGuard<T>(_dir: StarRowExpansionTemplate<T>, _ctx: unknown): _ctx is StarRowContext<T>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StarRowExpansionTemplate<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StarRowExpansionTemplate<any>, "ng-template[starRowExpansion]", never, {
+    "starRowExpansionOf": {
+      "alias": "starRowExpansionOf";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Data table (PrimeNG `p-table` essentials): typed columns, custom cell templates, sorting,
+ * global filter, column filters, CSV / Excel / print export, client or lazy (server) pagination, single / multiple row selection with
+ * checkboxes, row expansion, inline cell edit, column resize / reorder / hide / freeze, virtual scroll, row groups, multi-column sort,
+ * footer row, row reorder, saved state, loading skeleton, empty state, sticky header and row click.
+ *
+ * ```html
+ * <star-table [value]="rows()" [columns]="columns" dataKey="id" selectionMode="multiple"
+ *            [(selection)]="selected" paginator [rows]="10" [globalFilter]="query()">
+ *   <ng-template starCell="status" let-row><star-tag [value]="row.status" /></ng-template>
+ * </star-table>
+ * ```
+ */
+export declare class StarTable<T> {
+  protected readonly text: import("@star-ng/ui/core").StarUiText;
+  private readonly document;
+  private readonly host;
+  private readonly injector;
+  private readonly appRef;
+  readonly value: import("@angular/core").InputSignal<readonly T[]>;
+  readonly columns: import("@angular/core").InputSignal<readonly StarColumn<T>[]>;
+  /** Row identity for tracking and selection (default: the row object). */
+  readonly dataKey: import("@angular/core").InputSignal<StarOptionKey<T> | null>;
+  readonly loading: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly emptyMessage: import("@angular/core").InputSignal<string | null>;
+  readonly striped: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly size: import("@angular/core").InputSignal<"sm" | "md">;
+  readonly stickyHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly scrollHeight: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Layout when the table is narrower than 40rem (a phone). `'scroll'`: the table scrolls
+   * sideways. `'stack'`: each row is a block with one line per column, "label: value"; the
+   * sortable headers stay as a row of buttons. With `virtualScroll`, `'stack'` turns on rows of
+   * different heights.
+   */
+  readonly responsiveLayout: import("@angular/core").InputSignal<"scroll" | "stack">;
+  /**
+   * Renders only the rows in view (plus 5 above and below), for long lists. Needs
+   * `scrollHeight`. Rows have one fixed height (`virtualRowHeight`, text on one line) unless
+   * `virtualRowHeights` turns on rows of different heights.
+   */
+  readonly virtualScroll: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Row height in pixels with `virtualScroll`. With rows of different heights it is the
+   * estimated height of a row that was not measured yet.
+   */
+  readonly virtualRowHeight: import("@angular/core").InputSignal<number>;
+  /**
+   * Row heights with `virtualScroll`. `'auto'`: one fixed height, unless the table has row
+   * expansion, `groupBy` or the stacked layout, which need rows of different heights.
+   * `'variable'`: rows of different heights always, for cell text on more than one line. The
+   * table measures each rendered row and keeps the heights.
+   */
+  readonly virtualRowHeights: import("@angular/core").InputSignal<"auto" | "variable">;
+  readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+  readonly paginator: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly first: import("@angular/core").ModelSignal<number>;
+  readonly rows: import("@angular/core").ModelSignal<number>;
+  readonly rowsPerPageOptions: import("@angular/core").InputSignal<readonly number[]>;
+  readonly sortField: import("@angular/core").ModelSignal<string | null>;
+  readonly sortOrder: import("@angular/core").ModelSignal<StarSortOrder>;
+  /** Case- and accent-insensitive text search over all columns. */
+  readonly globalFilter: import("@angular/core").InputSignal<string>;
+  /** Column filter values by column `field` (columns with `filter` set). Two-way. */
+  readonly filters: import("@angular/core").ModelSignal<Readonly<Record<string, StarFilterValue>>>;
+  /** Server mode: the table only renders `value`; it emits `lazyLoad` for every change. */
+  readonly lazy: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Total rows on the server (lazy mode). */
+  readonly totalRecords: import("@angular/core").InputSignal<number>;
+  readonly selectionMode: import("@angular/core").InputSignal<"single" | "multiple" | null>;
+  readonly selection: import("@angular/core").ModelSignal<readonly T[]>;
+  /**
+   * Keys (`dataKey`) of the expanded rows. Two-way. Rows expand only when the table has an
+   * `starRowExpansion` template.
+   */
+  readonly expandedKeys: import("@angular/core").ModelSignal<readonly unknown[]>;
+  /** `'single'`: opening a row closes the other rows. */
+  readonly rowExpandMode: import("@angular/core").InputSignal<"single" | "multiple">;
+  /** Shows a Columns button: the user can hide columns (and move them, with `reorderableColumns`). */
+  readonly columnToggle: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The user can move a column: drag its header, or use the Columns panel. */
+  readonly reorderableColumns: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The user can change a column width: drag the header edge, or use the arrow keys on it. */
+  readonly resizableColumns: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Column `field`s in display order. Columns not in the list keep their place after it. Two-way. */
+  readonly columnOrder: import("@angular/core").ModelSignal<readonly string[]>;
+  /** `field`s of the hidden columns. Two-way. */
+  readonly hiddenColumns: import("@angular/core").ModelSignal<readonly string[]>;
+  /** Column widths in pixels by `field`, set by the user. Two-way. */
+  readonly columnWidths: import("@angular/core").ModelSignal<Readonly<Record<string, number>>>;
+  /**
+   * Sort by more than one column: Shift + click (or Shift + Enter) on a header adds it as the
+   * next sort column. A plain click sorts by that column only.
+   */
+  readonly multiSort: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Sort columns in priority order with `multiSort`. Two-way. */
+  readonly sortMeta: import("@angular/core").ModelSignal<readonly StarSortState[]>;
+  /**
+   * Group heading of a row (property name or function). Rows with the same heading show
+   * together under it, in the order in which the headings first appear after sorting.
+   * With `virtualScroll`, the rows of a closed group take no space.
+   */
+  readonly groupBy: import("@angular/core").InputSignal<StarOptionKey<T> | null>;
+  /** Headings of the closed groups. Two-way. */
+  readonly collapsedGroups: import("@angular/core").ModelSignal<readonly string[]>;
+  /**
+   * Adds "Move up" / "Move down" buttons to each row. The buttons work while the table shows
+   * `value` in its own order (no sort, no filter, no groups).
+   */
+  readonly reorderableRows: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Remembers sort, filters, column order, hidden columns, column widths, page size and
+   * closed groups in the browser under this key, and restores them on the next visit.
+   */
+  readonly stateKey: import("@angular/core").InputSignal<string | null>;
+  readonly stateStorage: import("@angular/core").InputSignal<"local" | "session">;
+  readonly rowClick: import("@angular/core").OutputEmitterRef<T>;
+  readonly rowReorder: import("@angular/core").OutputEmitterRef<StarRowReorderEvent<T>>;
+  /** The user changed an editable cell (see `StarColumn.editable`). */
+  readonly cellEdit: import("@angular/core").OutputEmitterRef<StarCellEditEvent<T>>;
+  readonly lazyLoad: import("@angular/core").OutputEmitterRef<StarLazyLoadEvent>;
+  /** The cell in edit mode: `<row key>|<field>` text, or `null`. */
+  private readonly editing;
+  private readonly cellTemplates;
+  private readonly expansion;
+  protected readonly expansionTemplate: import("@angular/core").Signal<TemplateRef<StarRowContext<T>> | null>;
+  protected readonly expandable: import("@angular/core").Signal<boolean>;
+  protected readonly radioName: string;
+  protected readonly clickable: import("@angular/core").Signal<boolean>;
+  /** All columns in display order: frozen columns first, then `columnOrder`. */
+  protected readonly orderedColumns: import("@angular/core").Signal<StarColumn<T>[]>;
+  protected readonly visibleColumns: import("@angular/core").Signal<StarColumn<T>[]>;
+  protected readonly dragField: import("@angular/core").WritableSignal<string | null>;
+  protected readonly dropField: import("@angular/core").WritableSignal<string | null>;
+  private resizing;
+  protected readonly hasColumnFilters: import("@angular/core").Signal<boolean>;
+  /** Columns that have a filter value now, with that value. */
+  private readonly activeFilters;
+  private readonly filtered;
+  /** Sort columns in priority order. */
+  private readonly sorts;
+  private readonly sorted;
+  /** First row index of each group on the page, with the heading and the row count. */
+  private readonly groupStarts;
+  protected readonly hasFooter: import("@angular/core").Signal<boolean>;
+  /** Rows can move while the table shows `value` in its own order. */
+  private readonly rowOrderIsOwn;
+  private restoredKey;
+  protected readonly total: import("@angular/core").Signal<number>;
+  protected readonly pageRows: import("@angular/core").Signal<readonly T[]>;
+  private readonly scrollTop;
+  private readonly viewportHeight;
+  private readonly scroller;
+  private readonly body;
+  /**
+   * Rows of different heights: on with `virtualRowHeights="variable"`, and with the features that
+   * cannot have one fixed height (row expansion, groups, stacked layout).
+   */
+  protected readonly variableHeights: import("@angular/core").Signal<boolean>;
+  /** Header rows: the column headings, and the filter row when there is one. */
+  private readonly headerRows;
+  /** `aria-rowcount` with virtual scroll: header, body (headings, rows, detail rows) and footer. */
+  protected readonly ariaRowCount: import("@angular/core").Signal<number | null>;
+  /** Expanded row keys, for a fast look-up per row. */
+  private readonly expandedSet;
+  /**
+   * Measured heights by row key (`dataKey` value, else the row object). A row with its detail
+   * row open has its own entry, so closing it again needs no new measure. Group headings use
+   * their item key. The maps are not signals: `measured` counts their changes.
+   */
+  private readonly rowHeights;
+  private readonly expandedHeights;
+  /** Counts up when a measured height changes the height tree. */
+  private readonly measured;
+  /** Counts up when the measured heights are no longer valid (the table width changed). */
+  private readonly heightEpoch;
+  /** Top of the table body in the scroll area (below the sticky header), in pixels. */
+  private readonly bodyOffset;
+  /** Items (group headings and rows) and their heights, with rows of different heights. */
+  private readonly layout;
+  /** Measured height of an item, else the estimate (a row with its detail: two rows). */
+  private estimateOf;
+  /** Last layout and scroll offset of `variableWindow`, to keep the view on a layout change. */
+  private anchorMemo;
+  /** Scroll offset that the next render must apply (see `variableWindow`). */
+  private pendingScroll;
+  /** Rendered items with rows of different heights. */
+  private readonly variableWindow;
+  /** Key of the row (or heading) that has the focus, kept rendered outside the window. */
+  private readonly focusedKey;
+  /** Index of the focused item in the virtual list, or -1. */
+  private readonly focusedIndex;
+  /** The lines of the body: spacers, group headings and rows, in display order. */
+  protected readonly bodyEntries: import("@angular/core").Signal<readonly BodyEntry<T>[]>;
+  /**
+   * Entries of the window `[start, end)` and of the focused item outside it, with a spacer for
+   * each gap, so the body keeps the full height.
+   */
+  private windowEntries;
+  /** First rendered row and the heights of the rows left out before and after the window. */
+  protected readonly virtualWindow: import("@angular/core").Signal<{
+    start: number;
+    end: number;
+    before: number;
+    after: number;
+  }>;
+  protected onScroll(event: Event): void;
+  /** Rendered rows that the ResizeObserver watches (rows of different heights only). */
+  private readonly observedRows;
+  private rowObserver;
+  /**
+   * Measures the rendered items, stores their heights, and moves the scroll offset by the change
+   * of the items above the first item in view, so the rows in view do not move (scroll
+   * anchoring). Runs after a render and when the ResizeObserver reports a row size change.
+   */
+  private measureRendered;
+  /** Watches the rendered rows and the body for size changes (content, fonts, images). */
+  private observeRows;
+  /** Index in the virtual list of the item that holds an element, or -1. */
+  private itemOf;
+  /** Key of an item of the virtual list. */
+  private keyOfItem;
+  protected onBodyFocusIn(event: FocusEvent): void;
+  protected onBodyFocusOut(event: FocusEvent): void;
+  /**
+   * Tab and Shift + Tab from a row to a row that is not rendered (the focused row is kept
+   * outside the window): scroll that row in, then focus its first (or last) control.
+   */
+  protected onBodyKeydown(event: KeyboardEvent): void;
+  private focusablesOf;
+  /** Scrolls an item of the virtual list to the middle of the view. */
+  private revealItem;
+  protected readonly skeletonRows: import("@angular/core").Signal<number[]>;
+  protected readonly colspan: import("@angular/core").Signal<number>;
+  /** Selection state of the rows on the current page, for the header checkbox. */
+  protected readonly pageState: import("@angular/core").Signal<boolean | "mixed">;
+  constructor();
+  private storage;
+  private restoreState;
+  /** Removes the saved state of this table (`stateKey`). The current view does not change. */
+  clearState(): void;
+  protected groupOf(row: T): string;
+  protected isGroupCollapsed(label: string): boolean;
+  protected isRowCollapsed(row: T): boolean;
+  protected toggleGroup(label: string): void;
+  protected footerText(column: StarColumn<T>): string;
+  protected canMoveRow(row: T, step: 1 | -1): boolean;
+  protected moveRow(row: T, step: 1 | -1): void;
+  protected trackKey(row: T): unknown;
+  protected cellTemplate(field: string): TemplateRef<StarCellContext<T>> | null;
+  protected cellValue(row: T, column: StarColumn<T>): unknown;
+  protected cellText(row: T, column: StarColumn<T>): string;
+  protected isHidden(column: StarColumn<T>): boolean;
+  /** A column can hide unless it is locked or it is the last visible column. */
+  protected canHide(column: StarColumn<T>): boolean;
+  protected setColumnVisible(column: StarColumn<T>, visible: boolean): void;
+  /** Moves a column to the place of another column. */
+  moveColumn(field: string, targetField: string): void;
+  protected moveColumnBy(column: StarColumn<T>, delta: 1 | -1): void;
+  /** Identifies a move button of the Columns panel, for `focusMoveButton`. */
+  protected moveKey(column: StarColumn<T>, delta: 1 | -1): string;
+  private focusMoveButton;
+  protected onDragStart(column: StarColumn<T>, event: DragEvent): void;
+  protected onDragOver(column: StarColumn<T>, event: DragEvent): void;
+  protected onDrop(column: StarColumn<T>, event: DragEvent): void;
+  protected endDrag(): void;
+  protected widthOf(column: StarColumn<T>): string | null;
+  protected resizedWidth(column: StarColumn<T>): string | null;
+  /** Rendered width in pixels of each frozen header cell, by column `field`. */
+  private readonly frozenWidths;
+  /** Rendered width in pixels of each header cell, by column `field` (resizable tables only). */
+  private readonly headerWidths;
+  /** The scroll area has content outside its box, so it must take the focus to scroll by key. */
+  protected readonly scrollable: import("@angular/core").WritableSignal<boolean>;
+  protected readonly minColumnWidth = 48;
+  /** `aria-valuenow` of a resize handle: the width of the column in pixels. */
+  protected resizeNow(column: StarColumn<T>): number | null;
+  protected resizeMax(column: StarColumn<T>): number;
+  /** Counts up when the table element changes size, so the frozen columns are measured again. */
+  private readonly resized;
+  /** Measures the frozen header cells after a render that can change their width. */
+  private measureFrozen;
+  /**
+   * Offset of a frozen column: the widths of the frozen columns before it. Uses the measured
+   * widths; before the first measure (and where layout is not available) the declared widths.
+   */
+  protected frozenOffset(column: StarColumn<T>): string | null;
+  private setWidth;
+  protected startResize(column: StarColumn<T>, event: PointerEvent): void;
+  protected onResizeKey(column: StarColumn<T>, event: KeyboardEvent): void;
+  protected editKey(row: T, column: StarColumn<T>): string;
+  protected isEditable(row: T, column: StarColumn<T>): boolean;
+  protected isEditing(row: T, column: StarColumn<T>): boolean;
+  /** Text in the editor: the raw value, so a formatted cell (date, currency) edits its data. */
+  protected editText(row: T, column: StarColumn<T>): string;
+  protected startEdit(row: T, column: StarColumn<T>): void;
+  protected commitEdit(row: T, column: StarColumn<T>, text: string): void;
+  protected cancelEdit(event: Event): void;
+  private closeEditor;
+  private focusAfterRender;
+  protected isExpanded(row: T): boolean;
+  protected detailId(index: number): string;
+  /** Opens or closes the detail of one row. */
+  toggleExpansion(row: T): void;
+  /** Opens the detail of every row on the current page. */
+  expandAll(): void;
+  /** Closes every row detail. */
+  collapseAll(): void;
+  private matchesColumnFilter;
+  protected filterValue(field: string): string;
+  protected filterList(field: string): readonly string[];
+  protected filterBound(field: string, bound: 'min' | 'max'): string;
+  protected setBound(column: StarColumn<T>, bound: 'min' | 'max', text: string): void;
+  protected filterChoices(column: StarColumn<T>): readonly string[];
+  protected setFilter(field: string, value: StarFilterValue): void;
+  /** Removes every column filter. */
+  clearFilters(): void;
+  /** Columns and rows of an export: visible columns in display order, without `exportable: false`. */
+  private exportData;
+  /** Export text of a cell: `exportValue`, else the display text (`format` / `value`). */
+  private exportText;
+  /** A number cell stays a number in a spreadsheet when the column has no text format. */
+  private exportCell;
+  /**
+   * CSV text of the table: a header row, then the filtered rows in the current sort order
+   * (all pages), or the selected rows, with the visible columns in display order. Cells use
+   * the column `exportValue`, else the display text (`format` / `value`); custom cell
+   * templates are not exported. In lazy mode only the loaded rows are available: pass all
+   * rows with `options.rows`.
+   *
+   * Text that a spreadsheet would read as a formula (it starts with `=`, `+`, `-` or `@`)
+   * gets a leading apostrophe, so exported user data cannot run as a formula.
+   */
+  toCsv(options?: StarCsvOptions<T>): string;
+  /** Downloads `toCsv()` as `<fileName>.csv` (UTF-8 with a byte order mark, for Excel). */
+  exportCsv(options?: StarCsvOptions<T>): void;
+  /**
+   * Excel workbook (`.xlsx`) bytes of the table: same columns and rows as `toCsv()`. Number
+   * cells stay numbers; text cells are plain text, never formulas.
+   */
+  toXlsx(options?: StarExportOptions<T>): Uint8Array;
+  /** Downloads `toXlsx()` as `<fileName>.xlsx`. */
+  exportExcel(options?: StarExportOptions<T>): void;
+  /**
+   * Opens the browser print dialog with a plain table of the same columns and rows. The user
+   * can print it or choose "Save as PDF". The table always fits the paper the user chooses: a
+   * table that is too wide wraps its text, then gets smaller text (down to 6 pt), and last breaks
+   * long words inside a cell. No column is cut off.
+   */
+  print(options?: StarExportOptions<T>): void;
+  private download;
+  /** Sorts by a column. With `multiSort`, `event.shiftKey` adds the column to the sort. */
+  sortBy(column: StarColumn<T>, event?: MouseEvent | KeyboardEvent): void;
+  private sortOf;
+  /** `aria-sort` goes on one column only: the first sort column. */
+  protected ariaSort(column: StarColumn<T>): string | null;
+  protected sortIcon(column: StarColumn<T>): string;
+  /** Position of a column in a sort by two or more columns, else `null`. */
+  protected sortRank(column: StarColumn<T>): number | null;
+  /** Keys of the selected rows: a look-up per row stays fast with 50,000 selected rows. */
+  private readonly selectedKeys;
+  protected isSelected(row: T): boolean;
+  protected toggleRow(row: T): void;
+  protected selectOnly(row: T): void;
+  protected togglePage(checked: boolean): void;
+  protected onRowClick(row: T, event: MouseEvent): void;
+  protected emitLazy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StarTable<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StarTable<any>, "star-table", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "columns": {
+      "alias": "columns";
+      "required": true;
+      "isSignal": true;
+    };
+    "dataKey": {
+      "alias": "dataKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyMessage": {
+      "alias": "emptyMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "striped": {
+      "alias": "striped";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "stickyHeader": {
+      "alias": "stickyHeader";
+      "required": false;
+      "isSignal": true;
+    };
+    "scrollHeight": {
+      "alias": "scrollHeight";
+      "required": false;
+      "isSignal": true;
+    };
+    "responsiveLayout": {
+      "alias": "responsiveLayout";
+      "required": false;
+      "isSignal": true;
+    };
+    "virtualScroll": {
+      "alias": "virtualScroll";
+      "required": false;
+      "isSignal": true;
+    };
+    "virtualRowHeight": {
+      "alias": "virtualRowHeight";
+      "required": false;
+      "isSignal": true;
+    };
+    "virtualRowHeights": {
+      "alias": "virtualRowHeights";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "paginator": {
+      "alias": "paginator";
+      "required": false;
+      "isSignal": true;
+    };
+    "first": {
+      "alias": "first";
+      "required": false;
+      "isSignal": true;
+    };
+    "rows": {
+      "alias": "rows";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowsPerPageOptions": {
+      "alias": "rowsPerPageOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "sortField": {
+      "alias": "sortField";
+      "required": false;
+      "isSignal": true;
+    };
+    "sortOrder": {
+      "alias": "sortOrder";
+      "required": false;
+      "isSignal": true;
+    };
+    "globalFilter": {
+      "alias": "globalFilter";
+      "required": false;
+      "isSignal": true;
+    };
+    "filters": {
+      "alias": "filters";
+      "required": false;
+      "isSignal": true;
+    };
+    "lazy": {
+      "alias": "lazy";
+      "required": false;
+      "isSignal": true;
+    };
+    "totalRecords": {
+      "alias": "totalRecords";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectionMode": {
+      "alias": "selectionMode";
+      "required": false;
+      "isSignal": true;
+    };
+    "selection": {
+      "alias": "selection";
+      "required": false;
+      "isSignal": true;
+    };
+    "expandedKeys": {
+      "alias": "expandedKeys";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowExpandMode": {
+      "alias": "rowExpandMode";
+      "required": false;
+      "isSignal": true;
+    };
+    "columnToggle": {
+      "alias": "columnToggle";
+      "required": false;
+      "isSignal": true;
+    };
+    "reorderableColumns": {
+      "alias": "reorderableColumns";
+      "required": false;
+      "isSignal": true;
+    };
+    "resizableColumns": {
+      "alias": "resizableColumns";
+      "required": false;
+      "isSignal": true;
+    };
+    "columnOrder": {
+      "alias": "columnOrder";
+      "required": false;
+      "isSignal": true;
+    };
+    "hiddenColumns": {
+      "alias": "hiddenColumns";
+      "required": false;
+      "isSignal": true;
+    };
+    "columnWidths": {
+      "alias": "columnWidths";
+      "required": false;
+      "isSignal": true;
+    };
+    "multiSort": {
+      "alias": "multiSort";
+      "required": false;
+      "isSignal": true;
+    };
+    "sortMeta": {
+      "alias": "sortMeta";
+      "required": false;
+      "isSignal": true;
+    };
+    "groupBy": {
+      "alias": "groupBy";
+      "required": false;
+      "isSignal": true;
+    };
+    "collapsedGroups": {
+      "alias": "collapsedGroups";
+      "required": false;
+      "isSignal": true;
+    };
+    "reorderableRows": {
+      "alias": "reorderableRows";
+      "required": false;
+      "isSignal": true;
+    };
+    "stateKey": {
+      "alias": "stateKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "stateStorage": {
+      "alias": "stateStorage";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "first": "firstChange";
+    "rows": "rowsChange";
+    "sortField": "sortFieldChange";
+    "sortOrder": "sortOrderChange";
+    "filters": "filtersChange";
+    "selection": "selectionChange";
+    "expandedKeys": "expandedKeysChange";
+    "columnOrder": "columnOrderChange";
+    "hiddenColumns": "hiddenColumnsChange";
+    "columnWidths": "columnWidthsChange";
+    "sortMeta": "sortMetaChange";
+    "collapsedGroups": "collapsedGroupsChange";
+    "rowClick": "rowClick";
+    "rowReorder": "rowReorder";
+    "cellEdit": "cellEdit";
+    "lazyLoad": "lazyLoad";
+  }, ["cellTemplates", "expansion"], ["[starTableCaption]"], true, never>;
+}
+/**
+ * File builders for `star-table` export. No third-party library: an `.xlsx` file is a ZIP of
+ * small XML parts, written here without compression.
+ */
+/** One exported cell: text, or a number that a spreadsheet can sum. */
+export type StarExportCell = string | number;
+/**
+ * Excel workbook (`.xlsx`) with one sheet: a bold header row, then the rows. Text cells are
+ * inline strings, which a spreadsheet never reads as a formula; numbers stay numbers.
+ */
+export declare function buildXlsx(headers: readonly string[], rows: readonly (readonly StarExportCell[])[], sheetName?: string): Uint8Array;
+/** One step of the fit ladder: how a print table gives way when it is wider than the paper. */
+export interface StarPrintFitStep {
+  /** Text size in CSS pixels. The normal size is 12 px (9 pt). */
+  readonly size: number;
+  /** A cell of one short word may wrap too (at a hyphen). */
+  readonly wrap: boolean;
+  /** A word may break at any character. Last resort: it sets no minimum width on a column. */
+  readonly anywhere: boolean;
+}
+/**
+ * What a table gives way to, in this order, until its minimum width fits the paper: first the
+ * cells of one short word may wrap (the text keeps its size), then the text gets smaller
+ * (11, 10, 9 and 8 px; 8 px is 6 pt, the floor), and last a word may break at any character.
+ * Step 0 is the table as it is built: no rule changes, short words never wrap.
+ */
+export declare const PRINT_FIT_STEPS: readonly StarPrintFitStep[];
+/**
+ * Style sheet that makes the print table fit any paper. `widths[i]` is the minimum width in
+ * pixels of the table at step `i` of `PRINT_FIT_STEPS`; `columns` are the minimum widths of its
+ * columns at the last step that keeps words whole. Step `i` applies when the content width of
+ * the page is less than the minimum width of every step before it. The query is a container
+ * query on the wrapper of the table, so it is answered with the real width of the page, which
+ * the print dialog (paper, margins, scale) decides after the document is built. A step that is
+ * not narrower than a step before it is left out.
+ */
+export declare function printFitStyle(widths: readonly number[], columns?: readonly number[]): string;
+/** Widths measured by `fitPrintDocument`. */
+export interface StarPrintFitMeasure {
+  /** Minimum width of the table at each step of `PRINT_FIT_STEPS`. */
+  readonly widths: readonly number[];
+  /** Minimum width of each column at the last step that keeps words whole. */
+  readonly columns: readonly number[];
+}
+/** A style sheet of the print document that can be changed and removed again. */
+export interface StarPrintStyle {
+  /** Replaces the rules of the sheet. */
+  set(css: string): void;
+  /** Takes the sheet out of the document. */
+  remove(): void;
+}
+/**
+ * Adds a style sheet to `doc`. The sheet is a constructed style sheet (`new CSSStyleSheet()`,
+ * created in the realm of the document, then `adoptedStyleSheets`). A policy whose `style-src`
+ * has no `'unsafe-inline'` blocks an inline `style` element, but it does not block a constructed
+ * sheet. An environment without constructed style sheets (or one where they fail) gets a
+ * `style` element instead: that is the only fallback, and a strict policy blocks it.
+ */
+export declare function addPrintStyle(doc: Document, css?: string): StarPrintStyle;
+/**
+ * Adds the base style of the print document (see `buildPrintDocument`) to `doc`. The document
+ * has no `style` element and no `style` attribute, so a Content-Security-Policy without
+ * `'unsafe-inline'` in `style-src` does not unstyle it. Call it when the frame has loaded,
+ * before `fitPrintDocument` measures the table.
+ */
+export declare function stylePrintDocument(doc: Document): void;
+/**
+ * Measures the minimum width of the print table at each fit step, in the layout of `doc`, and
+ * adds the style sheet of `printFitStyle` to it (a constructed style sheet, see
+ * `addPrintStyle`). Call it when the frame has loaded and has its base style
+ * (`stylePrintDocument`), before the print dialog opens. The widths are read in the real fonts
+ * of the document, so the text of any font, wide or narrow, gets the steps it needs.
+ */
+export declare function fitPrintDocument(doc: Document): StarPrintFitMeasure;
+/** Alignment of a print column. `start` and `end` follow the direction of the document. */
+export type StarPrintAlign = 'start' | 'center' | 'end';
+/**
+ * Alignment of a print column. The column definition decides: an explicit `align` wins. Without
+ * it a column in which every value is a number (and there is at least one) is `end`, and any
+ * other column is `start`. The type of the printed text does not matter: a number that a
+ * `format` function turned into a string still sits in a number column. `values` are the cell
+ * values before formatting.
+ */
+export declare function printColumnAlign(align: StarPrintAlign | undefined, values: readonly unknown[]): StarPrintAlign;
+/** Language and direction of the print document. */
+export interface StarPrintContext {
+  readonly lang?: string;
+  readonly dir?: 'ltr' | 'rtl';
+}
+/**
+ * `lang` and `dir` for the print document: the nearest ancestor of `host` (the element itself
+ * first) that has the attribute with a usable value, else the `<html>` element of `doc`. An
+ * empty `lang` and a `dir` other than `ltr` or `rtl` (such as `auto`) are skipped.
+ */
+export declare function printContext(host: Element | null, doc: Document): StarPrintContext;
+/** Options of `buildPrintDocument`. */
+export interface StarPrintOptions extends StarPrintContext {
+  /** Alignment of each column, in column order (see `printColumnAlign`). */
+  readonly align?: readonly StarPrintAlign[];
+}
+/** Base style of the print document. It is added with `stylePrintDocument`, not inline. */
+export declare const PRINT_STYLE = "body{font:12px/1.4 system-ui,sans-serif;color:#000;margin:16px}\nh1{font-size:16px;margin:0 0 12px;overflow-wrap:anywhere}\n.fit{container-type:inline-size}\ntable{width:100%;border-collapse:collapse}\nth,td{padding:4px 8px;border:1px solid #999;text-align:start;vertical-align:top;overflow-wrap:break-word}\nth{background:#eee}\nth.c,td.c{text-align:center}\nth.e,td.e{text-align:end}\ntd.s{white-space:nowrap}\nthead{display:table-header-group}\ntr{break-inside:avoid}";
+/**
+ * HTML document with one table, for the browser print dialog ("Save as PDF"). The markup has
+ * no `style` element and no `style` attribute: the style is added to the loaded document by
+ * `stylePrintDocument`, as a constructed style sheet, so that it works under a policy without
+ * `'unsafe-inline'` in `style-src`. The table is built to print at the normal size. When the
+ * paper is too narrow for it, call `fitPrintDocument` on the loaded document: the table then
+ * wraps, shrinks or breaks words (see `PRINT_FIT_STEPS`) so that no column is cut off.
+ *
+ * `options.align` sets the alignment of each column (cells and header). `options.lang` and
+ * `options.dir` go on the `html` element.
+ */
+export declare function buildPrintDocument(title: string, headers: readonly string[], rows: readonly (readonly StarExportCell[])[], options?: StarPrintOptions): string;
+export {};