@ahoo-wang/wow-view-engine 9.2.0-rc.0

package/dist/ui/record/headerRoving.d.ts

@@ -0,0 +1,57 @@
+import type * as React from 'react';
+/**
+ * The attribute one header's focusable item wears, so the group can find its
+ * members without anything above the cells holding a list of them.
+ */
+declare const STOP = "data-header-stop";
+/** What marks an element as this row's item, and what claims the stop. */
+export type RovingItem = {
+    [K in typeof STOP]: '';
+} & {
+    'aria-keyshortcuts'?: string;
+    onFocus(): void;
+};
+export interface RovingHeader {
+    /** Goes on the header's focusable element — the sort button, or the cell. */
+    attach(node: HTMLElement | null): void;
+    /** Spread on that same element. */
+    item: RovingItem;
+    /** Returns whether the key was the group's; the caller then stands down. */
+    onKeyDown(event: React.KeyboardEvent<HTMLElement>): boolean;
+}
+/**
+ * One header row as a single tab stop, with the arrows inside it.
+ *
+ * **Why.** Every column used to bring its own stops — a sort button and a
+ * resize handle — so a twenty-column table stood twenty-eight stops between
+ * the toolbar and the first row, and a keyboard reaching the rows had to
+ * pass every edge of every column. ARIA's answer to a row of peers is a
+ * roving tabindex, which is what `Toolbar` already gives the bar above this
+ * table: one stop for the row, ←/→ between the columns, Home/End to the
+ * ends.
+ *
+ * **Why the group organises itself.** The row is drawn in `RecordTable`,
+ * which maps the columns; the stop could have been decided there and passed
+ * down, but then every header would re-render whenever the focus moved, and
+ * the one number they would share is already written on the DOM as
+ * `tabindex`. So each header asks the row it is in: *does anybody hold the
+ * stop?* — if not, it takes it, and otherwise it stands at −1. That runs
+ * after every render, which is also what heals the group when a column is
+ * added, hidden or reordered: the holder leaving is a render of the row.
+ * The stop itself — who holds it, how it moves, where an arrow lands — is
+ * `roving.ts`, which the analysis result's rows are a column of peers
+ * under; what is left here is what makes this group a header row.
+ *
+ * **What Alt buys.** The plain arrows walk the columns, so the width needs a
+ * modifier: Alt+←/→ resizes the focused column by the handle's own contract
+ * (Shift for the long step, Alt+Enter back to automatic), which is what the
+ * handle answers to this day — it simply is not on the Tab route any more.
+ * The shortcut is on the item as `aria-keyshortcuts`, because a resize that
+ * is only in the documentation is a resize a reader never hears about.
+ */
+export declare function useRovingHeader({ onResize, }: {
+    /** Left out — an embedded table with no controller — Alt does nothing. */
+    onResize?(field: string, width: number | null): void;
+}): RovingHeader;
+export {};
+//# sourceMappingURL=headerRoving.d.ts.map

package/dist/ui/record/headerRoving.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headerRoving.d.ts","sourceRoot":"","sources":["../../../src/ui/record/headerRoving.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAKpC;;;GAGG;AACH,QAAA,MAAM,IAAI,qBAAqB,CAAC;AAKhC,0EAA0E;AAC1E,MAAM,MAAM,UAAU,GAAG;KAAG,CAAC,IAAI,OAAO,IAAI,GAAG,EAAE;CAAE,GAAG;IACpD,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,MAAM,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI,CAAC;IACvC,mCAAmC;IACnC,IAAI,EAAE,UAAU,CAAC;IACjB,4EAA4E;IAC5E,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC;CAC7D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,GACT,EAAE;IACD,0EAA0E;IAC1E,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;CACtD,GAAG,YAAY,CA+Cf"}

package/dist/ui/record/issueNames.d.ts

@@ -0,0 +1,25 @@
+import { FieldDefinition, Issue, RecordLayout } from '../../model/index.js';
+import { MessageKey } from '../kit/messages.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+/** Wording per layout, so an unhandled one cannot be silently unlabelled. */
+export declare const LAYOUT_LABEL: Record<RecordLayout, MessageKey>;
+/**
+ * A record view's finding as a reader is told it, in the words the screen
+ * uses — the analysis view's rule (`analysisIssueNamer`) for the other kind.
+ * The kernel names what it has: a field's path, a summary and an operator as
+ * the protocol spells them, a layout by its key. Only the catalogue knows
+ * what those are called, so they are said here:
+ *
+ * - a field (`field`) by its label, as the column header and the filter's
+ *   field picker say it; an element's field by the element's own label;
+ * - a summary (`fn`) as the column's summary select says it, the latest of
+ *   a moment 「最晚」;
+ * - an operator (`operator`) as the condition's operator select says it;
+ * - a layout (`layout`) as the layout switch says it.
+ *
+ * Anything the definition does not have is left as it is: it has no name on
+ * screen, and the finding is usually that it is missing. Findings of every
+ * other family pass through untouched.
+ */
+export declare function recordIssueNamer(fields: readonly FieldDefinition[], messages: MessageFormatters): (found: Issue) => Issue;
+//# sourceMappingURL=issueNames.d.ts.map

package/dist/ui/record/issueNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issueNames.d.ts","sourceRoot":"","sources":["../../../src/ui/record/issueNames.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,eAAe,EACf,KAAK,EACL,YAAY,EACb,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,6EAA6E;AAC7E,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAGzD,CAAC;AAKF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,eAAe,EAAE,EAClC,QAAQ,EAAE,iBAAiB,GAC1B,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,CA6CzB"}

package/dist/ui/record/offscreenSummaries.d.ts

@@ -0,0 +1,81 @@
+import { RecordColumnView, SummaryCell, SummaryRow } from '../../record/index.js';
+import { StickyPin } from './sticky.js';
+import { TablePins } from './columns.js';
+/**
+ * Which way a summarised column lies from the part of the table in view.
+ */
+export type OffscreenSide = 'left' | 'right';
+/**
+ * The summarised columns the reader cannot see, by field, and on which side
+ * of the view each one is. A column in view is simply absent.
+ */
+export type OffscreenColumns = ReadonlyMap<string, OffscreenSide>;
+/**
+ * What a summary row says about the numbers it holds out of view (D51).
+ */
+export interface OffscreenHint {
+    /** The column named, and the one the hint scrolls to. */
+    column: RecordColumnView;
+    /** Its first summary in this row — the one the hint reads out. */
+    cell: SummaryCell;
+    side: OffscreenSide;
+    /** How many summarised columns are out of view, the named one included. */
+    count: number;
+}
+/**
+ * The hint a summary row gives, or `null` when every column it summarises is
+ * in view.
+ *
+ * The one named is the nearest way to go: the first hidden column to the
+ * right in the columns' order, which is the direction a table is read and
+ * the one a table opened at its left edge hides; where nothing is hidden on
+ * the right, the hidden column closest on the left. A column the row holds
+ * no summary for is not counted, whatever its visibility.
+ */
+export declare function offscreenHint(row: SummaryRow, columns: readonly RecordColumnView[], offscreen: OffscreenColumns): OffscreenHint | null;
+/**
+ * How a row's hint words whose number it is (R2-79). Two rows naming the
+ * same column's same function, with as many more out of view, say it once
+ * — 「申请金额 总和 等 2 项」 — over the first row's number:
+ * `leads` writes it on a line of its own above that row's scope and number,
+ * `follows` leaves it to that line and keeps to one line of its own — the
+ * footer of a laptop-height workbench is a line shorter, and nothing it
+ * said is gone. `own` is a row whose hint names its number alone.
+ */
+export type HintCaption = 'own' | 'leads' | 'follows';
+/** Each row's caption, by whether its neighbours name the same number. */
+export declare function hintCaptions(hints: readonly (OffscreenHint | null)[]): HintCaption[];
+/**
+ * The footer cell that carries the hint, as the summary rows lay it out.
+ *
+ * `at` is {@link SELECT_HOST} for the selection column's cell, otherwise a field.
+ * `withScope` — the hint shares the cell with the row's scope label, and so
+ * carries the scope inside it. `pin` — what the cell holds against, where
+ * the table itself would let it scroll: the hint has to stay at the left end
+ * while the columns move, or it scrolls away with the first of them.
+ */
+export interface HintHost {
+    at: string;
+    withScope: boolean;
+    pin?: StickyPin;
+}
+/** The key the selection column's cell answers to in a {@link HintHost}. */
+export declare const SELECT_HOST = "\0select";
+/**
+ * Where the hint goes: the widest room at the left end that holds nothing
+ * else.
+ *
+ * - A first column that carries the scope, holds no summary and is pinned
+ *   left already is that room.
+ * - Otherwise the first column pinned left that holds no summary: in a
+ *   workbench that is usually the row key beside the narrow selection
+ *   column, which has the room the selection column lacks.
+ * - Otherwise the scope's own cell. Where nothing is pinned left it is held
+ *   against the edge for the footer alone — the selection column, or a first
+ *   column with no summary of its own. A first column that summarises
+ *   something is left to scroll: holding it would hold its numbers away from
+ *   the column they belong to, so there the hint is readable only while that
+ *   column is.
+ */
+export declare function hintHost(columns: readonly RecordColumnView[], selectable: boolean, pins: TablePins, summarised: ReadonlySet<string>): HintHost | null;
+//# sourceMappingURL=offscreenSummaries.d.ts.map

package/dist/ui/record/offscreenSummaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offscreenSummaries.d.ts","sourceRoot":"","sources":["../../../src/ui/record/offscreenSummaries.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,gBAAgB,EAChB,WAAW,EACX,UAAU,EACX,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAW,SAAS,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,OAAO,CAAC;AAE7C;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,MAAM,EAAE,gBAAgB,CAAC;IACzB,kEAAkE;IAClE,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;IACpB,2EAA2E;IAC3E,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,SAAS,EAAE,gBAAgB,GAC1B,aAAa,GAAG,IAAI,CAgBtB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,OAAO,GAAG,SAAS,CAAC;AAEtD,0EAA0E;AAC1E,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,CAAC,aAAa,GAAG,IAAI,CAAC,EAAE,GACvC,WAAW,EAAE,CAcf;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,SAAS,CAAC;CACjB;AAED,4EAA4E;AAC5E,eAAO,MAAM,WAAW,aAAiB,CAAC;AAE1C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,UAAU,EAAE,OAAO,EACnB,IAAI,EAAE,SAAS,EACf,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,GAC9B,QAAQ,GAAG,IAAI,CA+BjB"}

package/dist/ui/record/openRows.d.ts

@@ -0,0 +1,43 @@
+import { RecordRow } from '../../record/index.js';
+import { RovingAxis } from '../kit/roving.js';
+import type * as React from 'react';
+/**
+ * Rows a reader opens: a press on the row's own ground, or Enter/Space on
+ * the row the keyboard is on.
+ *
+ * There is no "open" button in the row. One would have to be a column of
+ * its own, or crowd the host's commands out of the pinned action column,
+ * for something the row already is — the record. A pointer presses the
+ * row; a keyboard reaches the rows as one Tab stop (`roving.ts`, as the
+ * analysis result's rows do), moves with the arrows, and opens with Enter
+ * or Space; a screen reader hears what those keys do from the hint the
+ * surface renders once (`hintId`) and every row points at.
+ *
+ * `null` for `open` gives rows that are not members of anything: no stop,
+ * no hint, no cursor — the surface without a detail reads as it did.
+ */
+export interface OpenRows {
+    /** The id of the one hint the surface renders, while rows open. */
+    readonly hintId: string | undefined;
+    /** The props that make one row open. */
+    row(row: RecordRow): OpenRowProps;
+}
+export interface OpenRowProps {
+    'data-openable'?: '';
+    /**
+     * The row's key, as text: where the detail hands focus back when it
+     * closes on a record it was not opened from (a link, `useRecordDetail`'s
+     * `open`), and a row on the page holds that record.
+     */
+    'data-row-key'?: string;
+    'aria-describedby'?: string;
+    onClick?(event: React.MouseEvent<HTMLElement>): void;
+    onFocus?(event: React.FocusEvent<HTMLElement>): void;
+    onKeyDown?(event: React.KeyboardEvent<HTMLElement>): void;
+}
+/**
+ * `container` is the element the rows live in — the caller's ref, so what
+ * this hands back is only what render reads.
+ */
+export declare function useOpenRows(container: React.RefObject<HTMLElement | null>, open: ((row: RecordRow) => void) | undefined, ...axes: readonly RovingAxis[]): OpenRows;
+//# sourceMappingURL=openRows.d.ts.map

package/dist/ui/record/openRows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openRows.d.ts","sourceRoot":"","sources":["../../../src/ui/record/openRows.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,QAAQ;IACvB,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,wCAAwC;IACxC,GAAG,CAAC,GAAG,EAAE,SAAS,GAAG,YAAY,CAAC;CACnC;AAED,MAAM,WAAW,YAAY;IAC3B,eAAe,CAAC,EAAE,EAAE,CAAC;IACrB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;IACrD,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;IACrD,SAAS,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;CAC3D;AAKD;;;GAGG;AACH,wBAAgB,WAAW,CACzB,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EAC9C,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,SAAS,KAAK,IAAI,CAAC,GAAG,SAAS,EAC5C,GAAG,IAAI,EAAE,SAAS,UAAU,EAAE,GAC7B,QAAQ,CAsCV"}

package/dist/ui/record/overflow.d.ts

@@ -0,0 +1,39 @@
+import { RefObject } from 'react';
+/**
+ * Whether the table is wider than the port it stands in — the one fact the
+ * frozen columns' edges depend on (P-23, D13 as amended 2026-09-22).
+ *
+ * The edge of a held column says "the middle scrolls under here". While the
+ * table fits, nothing scrolls under anything: the line then only cut the
+ * row's surplus off the last column, and the filler read as an empty column
+ * (user, 2026-09-22). So the port says on itself whether it overflows, and
+ * the edges are drawn against that word rather than always.
+ *
+ * Measured after layout and again whenever the port or the table changes
+ * size — a column resized, a column shown, the window narrowed. The moment
+ * overflow begins is the moment the filler's width reaches zero, so a held
+ * column's natural place and its pinned place coincide and nothing jumps.
+ */
+export declare function useOverflowing(port: RefObject<HTMLElement | null>, table: RefObject<HTMLElement | null>, 
+/**
+ * Whether the port is its own scroller (`stickyPort`): only then is what
+ * lies hidden past each side its scroll position's to say.
+ */
+scrolls?: boolean): Overflow;
+/**
+ * Whether the table overflows its port, and which sides have columns
+ * scrolled out of sight past them (second review R2-76): a held column's
+ * edge fades the content passing under it only while there is content
+ * under it — 「PO202609210(」 cut by the held 最近更新 read as a damaged
+ * number. The edge itself answers to `overflowing` alone (D13, P-23).
+ */
+export interface Overflow {
+    overflowing: boolean;
+    /** Columns scrolled out of sight before the start. */
+    start: boolean;
+    /** Columns not yet scrolled into sight past the end. */
+    end: boolean;
+}
+/** One reading of the port. */
+export declare function measureOverflow(node: HTMLElement, scrolls: boolean): Overflow;
+//# sourceMappingURL=overflow.d.ts.map

package/dist/ui/record/overflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overflow.d.ts","sourceRoot":"","sources":["../../../src/ui/record/overflow.ts"],"names":[],"mappings":"AAaA,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAElE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC;AACpC;;;GAGG;AACH,OAAO,UAAQ,GACd,QAAQ,CAkCV;AAED;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,sDAAsD;IACtD,KAAK,EAAE,OAAO,CAAC;IACf,wDAAwD;IACxD,GAAG,EAAE,OAAO,CAAC;CACd;AAID,+BAA+B;AAC/B,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,GAAG,QAAQ,CAS7E"}

package/dist/ui/record/pinCap.d.ts

@@ -0,0 +1,68 @@
+import { RefObject } from 'react';
+/**
+ * One column the table holds against an edge, as the cap weighs it.
+ *
+ * The two chrome columns are in here beside the data columns, because the
+ * width that eats the middle is the width of the whole held group: on the
+ * 420px column that produced this rule, the selection box and the host's
+ * action column were 146 of the 232 pixels held.
+ */
+export interface PinnedSlot {
+    /**
+     * How the header cell is found: `data-column` for the two chrome columns,
+     * `data-field` for a data column.
+     */
+    key: string;
+    kind: 'select' | 'actions' | 'column';
+    /**
+     * True where the pin is not the cap's to take. The row key is the only
+     * one: it says which record a row is, so a row scrolled sideways without
+     * it is a row nobody can read (D17-4).
+     */
+    fixed: boolean;
+}
+/** Which pins the cap has taken back. Nothing here is stored in a config. */
+export interface ReleasedPins {
+    /** Data columns, by field. */
+    fields: ReadonlySet<string>;
+    select: boolean;
+    actions: boolean;
+}
+/** Nothing released — what a table that fits, or one nobody measured, gets. */
+export declare const NO_RELEASE: ReleasedPins;
+/** The result area as the cap reads it: what is visible, and what is in it. */
+export interface PinPort {
+    /** `clientWidth` — the visible width, a scrollbar not counted as room. */
+    visible: number;
+    /** `scrollWidth` — how wide the columns are altogether. */
+    content: number;
+}
+/**
+ * The held group capped against the result area's own visible width.
+ *
+ * Measured rather than declared, for the reason `usePinnedOffsets` measures:
+ * a column's width comes from its content, the two chrome columns declare
+ * none at all, and the number this rule turns on is the one on screen. The
+ * port is the table's own box — `clientWidth` against `scrollWidth`, so a
+ * scrollbar is not counted as room to read in and a table that fits is left
+ * alone — and the columns are the header cells, the same cells the offsets
+ * are added up from.
+ *
+ * It runs in a **layout** effect, so the first measurement lands before the
+ * first paint: a table that has to give up a pin has given it up by the time
+ * anything is drawn, rather than flashing the wrong layout and correcting
+ * it. What is watched is the port *and* the held cells, so the pins come
+ * back as the port widens and go as it narrows — and a column that grows
+ * under a loading web font is weighed again as well.
+ *
+ * **Keyed on the slots, not run every render.** With no dependency list this
+ * re-read the header and rebuilt its `ResizeObserver` on every render of the
+ * table, which on the twenty-column fixture is a forced layout per hover,
+ * per row picked, per keystroke in the editor above. What it has to survive
+ * is a column appearing, disappearing or moving, and `slots` is exactly
+ * that: the caller projects it from the columns and the layout, so a new
+ * list is a new set of cells to weigh and to watch, and anything else is the
+ * same table drawn again.
+ */
+export declare function usePinnedCap(port: RefObject<HTMLElement | null>, table: RefObject<HTMLTableElement | null>, slots: readonly PinnedSlot[]): ReleasedPins;
+//# sourceMappingURL=pinCap.d.ts.map

package/dist/ui/record/pinCap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinCap.d.ts","sourceRoot":"","sources":["../../../src/ui/record/pinCap.ts"],"names":[],"mappings":"AAaA,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAGlE;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IACtC;;;;OAIG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,6EAA6E;AAC7E,MAAM,WAAW,YAAY;IAC3B,8BAA8B;IAC9B,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5B,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,+EAA+E;AAC/E,eAAO,MAAM,UAAU,EAAE,YAIxB,CAAC;AAaF,+EAA+E;AAC/E,MAAM,WAAW,OAAO;IACtB,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAC;CACjB;AAuDD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,EACzC,KAAK,EAAE,SAAS,UAAU,EAAE,GAC3B,YAAY,CAiBd"}

package/dist/ui/record/queryAnnouncement.d.ts

@@ -0,0 +1,47 @@
+import { RecordTableController } from '../../react/index.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+import { OwnAnnouncer } from '../kit/Announcer.js';
+/**
+ * What a query says about itself, or nothing at all.
+ *
+ * A record view answers with rows, and rows are the one thing a reader who
+ * is not looking at the table never learns about: the toolbar, the pagination
+ * and the empty state all change under a reader who is told none of it. The
+ * sentences are the ones already on screen — the pagination's count and the
+ * empty result's title — because a second wording for the same fact is a
+ * second fact to reconcile.
+ *
+ * A failure says nothing here. `QueryStrip` draws it as an `error` status
+ * strip, which is `role="alert"` and interrupts on its own; saying it twice
+ * is the reader hearing the same failure from two directions. Nothing is
+ * not silence kept over the last sentence, though: the region is emptied,
+ * so 「running」 does not outlive the query (#3603).
+ */
+export declare function querySentence(table: RecordTableController, messages: MessageFormatters, 
+/**
+ * The empty result's title as the screen is drawing it — a host may put
+ * the case in its own words ("no orders are waiting"). Said as heard,
+ * because the two are one sentence and not two.
+ */
+emptyTitle?: string): string | null;
+/**
+ * Says each query out loud once: that one is running, and what came back.
+ *
+ * The sentence is derived rather than pushed from the controller, so a
+ * re-render on any other account cannot repeat it — the effect speaks only
+ * when the sentence itself is new. Which is also what makes a result that
+ * matches the previous one exactly say nothing a second time: the
+ * "running" sentence sits between two landings, so every query the reader
+ * waited through is read back, and a render that changed nothing is not.
+ *
+ * What it returns says a sentence that leads the next result: a command's
+ * outcome, said at once and kept, so the refresh the command asked for
+ * does not say 「正在查询」 and then its count over it — a polite region is
+ * read for its last words, and the outcome was the one worth hearing. The
+ * result that lands next is said after it, in one sentence
+ * (「发货 · SO-1003 已完成；共 4 条记录」).
+ */
+export declare function useQueryAnnouncement(table: RecordTableController, messages: MessageFormatters, voice: Pick<OwnAnnouncer, 'say' | 'clear'>, 
+/** What the empty result is titled on screen, when the host titles it. */
+emptyTitle?: string): (lead: string) => void;
+//# sourceMappingURL=queryAnnouncement.d.ts.map

package/dist/ui/record/queryAnnouncement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryAnnouncement.d.ts","sourceRoot":"","sources":["../../../src/ui/record/queryAnnouncement.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,qBAAqB,EAC5B,QAAQ,EAAE,iBAAiB;AAC3B;;;;GAIG;AACH,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,GAAG,IAAI,CAYf;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,qBAAqB,EAC5B,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,GAAG,OAAO,CAAC;AAC1C,0EAA0E;AAC1E,UAAU,CAAC,EAAE,MAAM,GAClB,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CA6BxB"}

package/dist/ui/record/roomBelowRows.d.ts

@@ -0,0 +1,24 @@
+import { RefObject } from 'react';
+/**
+ * How much of the port the rows leave empty, so the summaries can be drawn
+ * at its bottom rather than straight after the last row.
+ *
+ * A workbench fills its container and its footer stays at the bottom
+ * (`styles.css`, "A workbench fills its container"): the port takes the
+ * room the parts above it left, three rows or thirty. The summary rows are the
+ * table's own footer, and they are sticky to the port's bottom only while
+ * the rows overflow it — with three rows they sat under the third, and the
+ * two footers of one result, the totals and the pagination, came apart with
+ * blank space between them (the user's 2026-09-23 review). The room between
+ * is given to a row of its own that draws nothing (`RecordTable`), which
+ * puts the totals where the pagination is.
+ *
+ * Measured, because a table cannot be told to push its footer down: height
+ * a table has beyond its rows is shared out among the rows, which would
+ * stretch every row instead. What is measured is the port's inner height
+ * against the table's without the room row, so the room it adds is never
+ * counted as rows. `0` while the rows fill the port, where nothing is empty,
+ * and wherever nothing can be measured (jsdom).
+ */
+export declare function useRoomBelowRows(port: RefObject<HTMLElement | null>, table: RefObject<HTMLElement | null>, enabled: boolean): number;
+//# sourceMappingURL=roomBelowRows.d.ts.map

package/dist/ui/record/roomBelowRows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roomBelowRows.d.ts","sourceRoot":"","sources":["../../../src/ui/record/roomBelowRows.ts"],"names":[],"mappings":"AAaA,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EACpC,OAAO,EAAE,OAAO,GACf,MAAM,CAyBR"}

package/dist/ui/record/sticky.d.ts

@@ -0,0 +1,227 @@
+import { CSSProperties } from 'react';
+/**
+ * Everything about the table that stays put while the rest of it scrolls,
+ * in one place: the two bands at the ends, and the cells of a held column.
+ *
+ * **Why one place.** A sticky column is sticky one cell at a time — a
+ * `<col>` cannot carry position, so the same recipe has to go on the header
+ * cell, the body cell, the summary cell and the skeleton's — and the recipe
+ * was spelled out five times over `RecordTable`, `columns.ts`,
+ * `SummaryRows`, `SkeletonRows` and `Filler`. Five copies of `sticky z-10
+ * bg-inherit` plus an inset hairline is five chances for one layer to drift
+ * from the others, and a header that holds while its cells slide away is
+ * worse than no pinning at all (`docs/design/ui/record.md`). So every cell
+ * of this table — held or not, in whichever layer — is built by
+ * {@link stickyCell} or {@link stickyHead}, and whether it is held is the
+ * pin it is handed.
+ *
+ * **What is said on the element.** The classes alone cannot be read back: a
+ * test that asserts `sticky` asserts a spelling, and the offsets only exist
+ * in a browser that lays the table out. So each held cell also says what it
+ * is — `data-pin` for the edge it is held against, `data-pin-edge` for the
+ * one facing the scrolling middle, `data-pin-index` on the header cell whose
+ * width names the offset — and `usePinnedOffsets`, `usePinnedCap`, the jsdom
+ * suites and the browser stories all read those rather than the class list.
+ *
+ * Two of those words are the *port*'s and not a cell's, and they are the
+ * two the cells read back through a variant: `data-sticky` on each band,
+ * and `data-overflowing` on the scroll area (`overflow.ts`, P-23), which
+ * is what decides whether the boundary's edge is drawn at all. A cell says
+ * what it *is*; the port says what there is to hold against.
+ */
+/** Which edge the table holds something against. */
+export type PinSide = 'left' | 'right';
+/**
+ * A column held against the **left** edge: the one side with a chain on it.
+ *
+ * Several columns can be held there — the selection box, then the row key,
+ * then whatever else the config pinned — so each has to stop where the ones
+ * before it end, and each of those places is measured.
+ */
+export interface LeftPin {
+    side: 'left';
+    /**
+     * The column's place in the result, which names its measured offset. The
+     * selection column has none — it sits against the port's own edge.
+     */
+    index?: number;
+    /**
+     * Where the column stops: the offsets of the held columns before it, as
+     * `usePinnedOffsets` measures them with the config's own arithmetic as the
+     * fallback. Absent means the edge itself.
+     */
+    offset?: string;
+    /**
+     * Whether this is the held column facing the scrolling middle, and so the
+     * one that draws the edge (D13). Two held columns never have anything
+     * pass between them, so a line there would be a lie.
+     */
+    edge: boolean;
+}
+/**
+ * The one column held against the **right** edge, which is all that side
+ * ever has (D19): the host's action column, or the table's own last column
+ * where there is none.
+ *
+ * It carries neither an index nor an offset, and the type is why: with one
+ * column there, its place is the edge itself — a flat `right-0` — and there
+ * is no chain for a second column to stop against. The two-sided version of
+ * this interface outlived D19 by a batch, and what it bought was an offset
+ * chain that computed `right: var(--fve-pin-right-N, 0px)` and was `0px`
+ * every time it ran.
+ */
+export interface RightPin {
+    side: 'right';
+    /** Always true: the right side has nothing else on it to face (D19). */
+    edge: boolean;
+}
+/**
+ * One column the table holds against an edge, as every layer's cell needs
+ * it. `columns.ts` decides which columns get one; this file decides what
+ * wearing one looks like.
+ */
+export type StickyPin = LeftPin | RightPin;
+/** What one cell of the table wears, held or not. */
+export interface StickyCellProps {
+    className: string;
+    style?: CSSProperties;
+    'data-pin'?: PinSide;
+    'data-pin-edge'?: '';
+    'data-pin-index'?: number;
+}
+/** Anything the cell carries for reasons of its own: width, alignment, … */
+export interface CellStyling {
+    className?: string;
+    style?: CSSProperties;
+}
+/**
+ * One cell of a table row — a body cell, a summary cell, a skeleton's — with
+ * the column's own styling and, where the column is held, the sticky recipe
+ * over it.
+ *
+ * `pin` left out is the ordinary case and not an oversight: a column that
+ * scrolls, the trailing filler that is not a column at all, a skeleton row
+ * whose query has not answered yet. Saying it here rather than by omission
+ * is what keeps "not held" in the same place as "held".
+ */
+export declare function stickyCell(pin: StickyPin | undefined, styling?: CellStyling): StickyCellProps;
+/**
+ * The same, for a header cell — which also publishes the offset it owns.
+ *
+ * The header is what the offsets are measured from: a table with no rows
+ * still has a header, and column widths come from the content rather than
+ * from the config, so `usePinnedOffsets` adds up these cells and writes the
+ * result back as `--_fve-pin-left-{index}`. The selection column takes part
+ * in that sum without owning a variable — it is against the edge — and the
+ * one column held on the right owns none either, for the same reason.
+ */
+export declare function stickyHead(pin: StickyPin | undefined, styling?: CellStyling): StickyCellProps;
+/**
+ * What an *unheld* header cell must be so that the resize handle inside it
+ * stays inside it.
+ *
+ * The handle is `absolute z-20`, and in a cell that is merely `relative` —
+ * no stacking context of its own — that 20 competed at the row's level and
+ * beat the held cells' `z-10`: scrolled sideways, a column's edge line
+ * painted through the frozen header it had slid under (user, 2026-09-22).
+ * `isolate` scopes it to the cell. A held cell needs none of this — `sticky`
+ * with a `z-index` is already a stacking context — and two `position`
+ * classes on one element is a race between stylesheet rules rather than a
+ * choice, so this is the alternative to a pin and never an addition to one.
+ */
+export declare const OWN_LAYER = "fve:relative fve:isolate";
+/**
+ * A band at one end of the table: the header at the top, the summaries at
+ * the bottom. Each is a role of the theme's (`table-header`, `totals`;
+ * theme-architecture.md 4.2), and both are `--muted` until a theme parts
+ * them, because the two of them being **the same grey** is the whole point
+ * (P-21) — they bracket the rows, and the data is the only thing left drawn
+ * on the rows' own ground. Before this the header
+ * was `--background` like the rows, parted from them by one hairline and a
+ * grey label, and the user's 2026-09-22 review read the first row as part
+ * of the header. (`HeaderBand*` measures the two fills and compares them
+ * byte for byte.)
+ *
+ * The colour is on the **row** as well as on the group because a held cell
+ * takes its fill from the row it is in (`bg-inherit`, see {@link held}): a
+ * band painted on the `<thead>` alone leaves those cells transparent, and
+ * the columns scrolling under them show through. `hover:` is said again
+ * because the registry hovers every `<tr>` to `bg-muted/50`, and neither
+ * band is hovered as a row — in the header only the button in it is.
+ */
+export declare const BAND: {
+    readonly top: "fve:bg-table-header";
+    readonly bottom: "fve:bg-totals";
+};
+/**
+ * The same fill on a band's row, per end: the header's row and a summary
+ * row. Each band is a role of its own (`--_fve-table-header`,
+ * `--_fve-totals`, theme-architecture.md 4.2), both `--muted` until a theme
+ * parts them.
+ */
+export declare const BAND_ROW: {
+    readonly top: "fve:bg-table-header fve:hover:bg-table-header";
+    readonly bottom: "fve:bg-totals fve:hover:bg-totals";
+};
+/** What a band wears, and which end of the scroll port it holds. */
+export interface StickyBandProps {
+    className: string;
+    'data-sticky': 'top' | 'bottom';
+}
+/**
+ * The `<thead>` or `<tfoot>` as a layer that stays while the rows move.
+ *
+ * `z-20`, one above the held cells, because a band crosses them: the header
+ * cell of a frozen column is part of both layers and has to be drawn over
+ * the rows passing beneath *and* over the columns sliding under the freeze.
+ * Which end it holds is said on the element as well — jsdom lays nothing
+ * out, so `data-sticky` is what a suite can read, while the browser stories
+ * measure the computed `position` instead.
+ */
+export declare function stickyBand(at: 'top' | 'bottom'): StickyBandProps;
+/**
+ * What a band holds against: the scroll port, which is the table's own
+ * wrapper or something around it. One recipe for both tables — the record
+ * table and the analysis table — because the bands only stay where the
+ * wrapper is the box that really scrolls, and a second copy of this choice
+ * is how the analysis table's header and totals came to scroll away with a
+ * dashboard panel's body (2026-09-25).
+ */
+export interface StickyPortProps {
+    className: string;
+    /**
+     * Said on the element rather than left to the class list: the workbench,
+     * a `fill` embed and an expanded view hand the remaining height to the
+     * table that is its own port, and must not hand it to one holding on
+     * against a panel.
+     */
+    'data-scrolls'?: '';
+}
+/**
+ * `scrolls` — the table is its own scroll port: the header stays while the
+ * rows move under it, the foot band stays at the bottom, and both scroll
+ * sideways with their columns. The registry's own container is taken out of
+ * the way — with two nested scrollports the bands resolve against the inner
+ * one, which never scrolls. How tall the port is depends on where it
+ * stands: in a workbench, a `fill` embed or an expanded view it takes the
+ * height it is handed (`styles.css`); anywhere else — an embed laid out at
+ * its content's height — it is capped at the host's
+ * `--fve-record-table-max-h`, or 70vh.
+ *
+ * Not `scrolls` — something around the table scrolls instead: a dashboard
+ * panel's body. `overflow` cannot be had on one axis alone — a box that
+ * scrolls sideways is a scrollport both ways — so a wrapper that never needs
+ * to scroll must not be one at all, or the bands would hold against a box
+ * nobody scrolls while the panel moved them off its top. Left visible, the
+ * bands and the held columns hold against whatever really scrolls.
+ */
+export declare function stickyPort(scrolls: boolean): StickyPortProps;
+/**
+ * The custom property carrying one held column's measured offset. The cells
+ * read it with the config's own arithmetic as the fallback, so they are
+ * placed before anything has been measured and corrected after.
+ *
+ * Left only, because the chain is (see {@link RightPin}).
+ */
+export declare function pinVar(index: number): string;
+//# sourceMappingURL=sticky.d.ts.map