@aceshooting/lyra-ui 2.1.0 → 2.2.0

package/dist/components/table/table.d.ts

@@ -1,199 +1,3 @@
-import { type TemplateResult, type PropertyValues } from 'lit';
-import { LyraElement } from '../../internal/lyra-element.js';
-import '../empty/empty.js';
-export interface TableColumn<T> {
-    key: string;
-    label: string;
-    sortable?: boolean;
-    align?: 'start' | 'end';
-    /** Responsive priority — `undefined` (the default) means "always visible".
-     *  `'low'` columns hide first (narrowest container), `'medium'` next, as
-     *  `[part='base']`'s container-query width shrinks; both can be forced back
-     *  on via `[part='reveal-columns-button']`. */
-    priority?: 'medium' | 'low';
-    /** Pins this column's header/cell to the inline-start edge with
-     *  `position: sticky` so it stays visible while the table scrolls
-     *  horizontally. */
-    sticky?: boolean;
-    cell: (row: T) => unknown;
-}
-/**
- * `<lyra-table>` — a presentational, sort/select-aware data table.
- *
- * Header/row activation is delegated: one `click` and one `keydown`
- * listener on `<table>` resolve the target via `closest('[data-col-key]'
- * | '[data-row-key]')` and a key→object lookup map, instead of allocating
- * fresh per-column/per-row closures on every render. Both listeners guard
- * against nested interactive `cell()` content first (see
- * `INTERACTIVE_SELECTOR`) so a button/link/input inside a cell owns its own
- * activation instead of triggering `lyra-row-click`.
- *
- * Keyboard focus follows a roving-tabindex pattern (one `tabindex="0"` stop
- * among the header cells, one among the body rows — see `focusedColKey()` /
- * `focusedRowKey()`), matching this repo's other `role="grid"`/composite
- * widgets. Left/Right/Home/End move within the header row; Up/Down/Home/End
- * move within the body; Down from the header enters the body's roving stop,
- * and Up from the body's first row returns to the header's roving stop.
- * Enter/Space still only sort/activate (see `activateColumn()` /
- * `activateRow()`).
- *
- * Set `aria-label` on the host to give the `role="grid"` element an
- * accessible name; it's forwarded into the shadow DOM's `<table>`.
- *
- * `columns[].priority` ('medium' | 'low') hides that column under
- * `[part='base']`'s `@container` breakpoints; `[part='reveal-columns-button']`
- * forces them all back into view. Rather than a *static* check of whether any
- * column merely declares a `priority`, the button (and the public
- * `columnsHidden` property, see below) reflects whether a `priority` column
- * is *actually* hidden right now — measured via `ResizeObserver` on
- * `[part='base']` plus a post-render DOM check — or `showAllColumns`
- * force-visible mode is currently active (so there's still a way to toggle
- * it back off). `columns[].sticky` pins a column's header/cells to the
- * inline-start edge while the table scrolls horizontally.
- *
- * @customElement lyra-table
- * @event lyra-sort - A sortable header was activated. `detail: { key }`.
- * @event lyra-row-click - A row was activated. `detail: { row }`.
- * @event lyra-load-more - The "load more" control was activated.
- * @event lyra-columns-hidden-change - `columnsHidden` actually changed value
- *   (a `priority` column just became hidden/un-hidden by the `@container`
- *   rules, or `showAllColumns` force-visible mode was toggled while a
- *   `priority` column was hidden). `detail: { hidden: boolean }`.
- * @csspart base - The root wrapper around the `<table>` and its footer controls.
- * @csspart table - The `<table role="grid">` element.
- * @csspart head - The `<thead>` element.
- * @csspart header-cell - Each `<th>` header cell.
- * @csspart row - Each body `<tr>`.
- * @csspart cell - Each body `<td>`.
- * @csspart more-button - The "load more" control, shown when `hasMore` is true.
- * @csspart sort-icon - The chevron shown in the active sortable column's header cell.
- * @csspart reveal-columns-button - The button that toggles `priority`-hidden columns back into view.
- */
-export declare class LyraTable<T = unknown> extends LyraElement {
-    static styles: import("lit").CSSResultGroup[];
-    columns: TableColumn<T>[];
-    rows: T[];
-    sortKey: string;
-    sortDir: 'asc' | 'desc';
-    /** Derives each row's stable identity for `repeat()`'s DOM-reconciliation
-     *  key and the delegated click/keydown row lookup (`rowsByKey`,
-     *  `data-row-key`). When omitted, `keyOf()` falls back to the row's index
-     *  in `rows`, which is only a safe identity while `rows` never reorders —
-     *  provide `rowKey` whenever `rows` can be sorted, filtered, or otherwise
-     *  re-ordered across renders, or row identity (selection, focus, click
-     *  targets) can silently attach to the wrong row. */
-    rowKey?: (row: T) => string | number;
-    selectedKey: string | number | null;
-    hasMore: boolean;
-    moreLabel: string;
-    emptyHeading: string;
-    emptyDescription: string;
-    noColumnsHeading: string;
-    noColumnsDescription: string;
-    revealColumnsLabel: string;
-    hideColumnsLabel: string;
-    /** Whether a `priority` column is *actually* hidden right now by
-     *  table.styles.ts's `@container` rules, or `showAllColumns` force-visible
-     *  mode is currently active — the same computed value that gates whether
-     *  `[part='reveal-columns-button']` renders at all (see `render()`), kept
-     *  in sync by `recomputeColumnsHidden()`. Computed/read-only by
-     *  convention: consumers may read it (and listen for
-     *  `lyra-columns-hidden-change`), but setting it directly has no lasting
-     *  effect, since it's recomputed on the very next render or
-     *  `[part='base']` resize. */
-    columnsHidden: boolean;
-    /** Forces `priority`-hidden columns back into view, overriding the
-     *  `@container` hide rules in table.styles.ts. Toggled by
-     *  `[part='reveal-columns-button']`. */
-    private showAllColumns;
-    /** Roving-tabindex position among header cells; `null` until a header is
-     *  clicked/navigated to, at which point `focusedColKey()` falls back to
-     *  the first column. */
-    private activeColKey;
-    /** Roving-tabindex position among body rows; `null` until a row is
-     *  clicked/navigated to, at which point `focusedRowKey()` falls back to
-     *  `selectedKey` (if it matches a row) or the first row. */
-    private activeRowKey;
-    private rowsByKey;
-    private columnsByKey;
-    /** Watches `[part='base']`'s own inline-size — the `@container` query
-     *  container table.styles.ts's priority-hide rules react to — so a
-     *  `priority` column flipping hidden/visible from an *external* width
-     *  change (a window resize, an ancestor flex-layout reflow, ...) is caught
-     *  even though no Lit-tracked property changed. Mirrors
-     *  lite-chart.ts's connectedCallback()/disconnectedCallback() ResizeObserver
-     *  lifecycle. */
-    private resizeObserver?;
-    /** The `[part='base']` element `resizeObserver` is currently observing —
-     *  `render()`'s columns/rows-empty branches swap in `<lyra-empty>` instead,
-     *  a different template shape that gives `[part='base']` a fresh DOM
-     *  identity on the next non-empty render, so `updated()` re-observes
-     *  whenever this no longer matches the live element. */
-    private observedBase?;
-    private readonly observedHeaders;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    private observeBase;
-    private observeHeaders;
-    /** Recomputes `columnsHidden` from the live DOM (mirrors `visibleHeaders()`'s
-     *  own `offsetParent !== null` technique for detecting `@container`-hidden
-     *  cells) and dispatches `lyra-columns-hidden-change` only on a real
-     *  transition. Called from `updated()` (covers a change driven by
-     *  `columns`/`rows`/`showAllColumns` rather than a container resize) and
-     *  from the `ResizeObserver` callback (covers a container resize with no
-     *  Lit-tracked property change at all). */
-    private recomputeColumnsHidden;
-    private rehomeFocusedColumn;
-    private keyOf;
-    /** The header cell that currently owns `tabindex="0"`. */
-    private focusedColKey;
-    /** The body row that currently owns `tabindex="0"`. */
-    private focusedRowKey;
-    protected willUpdate(changed: PropertyValues): void;
-    /** Each sticky column's cumulative inline-start offset — the sum of the *rendered
-     *  width* of every earlier sticky column — so multiple sticky columns
-     *  stack left-to-right instead of all pinning to inset-inline-start: 0 and
-     *  overlapping. Table columns are intrinsically sized (not fixed-width), so
-     *  this can't be computed in CSS alone; it requires measuring the actual
-     *  laid-out `offsetWidth` of each earlier sticky column's header cell. */
-    private stickyOffsets;
-    private applyStickyOffsets;
-    /** Applies stickyOffsets()'s measured per-column offsets as an inline
-     *  `--lyra-table-sticky-offset` custom property on every header cell and
-     *  body cell in that column (addressed by the shared `data-col-key`
-     *  attribute). This is a post-render DOM measurement — column widths
-     *  aren't known until after the browser has laid out this update's
-     *  render() output — so it runs from `updated()`, not `willUpdate()`,
-     *  intentionally kept as a separate pass from the rowsByKey/columnsByKey
-     *  rebuild above: those two must stay in `willUpdate()` so `render()`'s
-     *  own `focusedRowKey()` call sees the current update's identity maps
-     *  (e.g. a freshly-assigned `selectedKey` resolving to the correct
-     *  roving-tabindex row on the very first paint), whereas the sticky-offset
-     *  measurement can only run after that same paint has happened. Only runs
-     *  when `hasSticky` is true (opt-in) and simply recomputes on every
-     *  update; a future optimization pass could cache column widths instead of
-     *  re-querying every time — out of scope for this correctness fix. */
-    protected updated(changed: PropertyValues): void;
-    private activateColumn;
-    private activateRow;
-    /** Header cells currently in the tab sequence — excludes columns hidden by
-     *  a `priority`-driven `@container` rule (table.styles.ts), so Left/Right/
-     *  Home/End never strand the roving tab stop on a `display: none` cell
-     *  that `.focus()` would silently no-op on. Scoped to `th` — body `<td>`s
-     *  now carry the same `data-col-key` attribute (for the sticky-offset
-     *  measurement pass) but must never be treated as header cells here. */
-    private visibleHeaders;
-    private focusHeader;
-    private focusRow;
-    private toggleColumns;
-    private onTableClick;
-    private onTableKeyDown;
-    private onHeaderKeyDown;
-    private onRowKeyDown;
-    render(): TemplateResult;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'lyra-table': LyraTable;
-    }
-}
+export * from './table.class.js';
+import "../empty/empty.js";
+//# sourceMappingURL=table.d.ts.map

package/dist/components/table/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../src/components/table/table.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AAGjC,OAAO,mBAAmB,CAAC"}