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

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

@@ -0,0 +1,30 @@
+import { RecordRow } from '../../record/index.js';
+import { RecordTableController } from '../../react/index.js';
+import type * as React from 'react';
+export interface RowCheckboxProps {
+    table: RecordTableController;
+    row: RecordRow;
+    /** The surface's one {@link RangeHint}, which every row checkbox names. */
+    hintId: string;
+}
+/**
+ * One row's checkbox, table and cards alike: a press toggles the row, and
+ * Shift extends the selection from the last plain toggle to it
+ * (`RecordTableController.toggle`, `{ range }`).
+ *
+ * The keyboard needs nothing of its own. Base UI's checkbox turns a Space on
+ * the root into a click carrying the modifiers held (`useButton`), and that
+ * click reaches its hidden input — whose change event is what
+ * `onCheckedChange` reports, native event and all. So Shift+Space and
+ * Shift+click are read off the one event, by the one handler.
+ */
+export declare function RowCheckbox({ table, row, hintId }: RowCheckboxProps): React.JSX.Element;
+/**
+ * What Shift does to a row checkbox, said once per surface and drawn
+ * nowhere; every row checkbox points at it (`aria-describedby`), the way
+ * the rows point at the opening hint (`openRows.ts`).
+ */
+export declare function RangeHint({ id }: {
+    id: string;
+}): React.JSX.Element;
+//# sourceMappingURL=RowCheckbox.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RowCheckbox.d.ts","sourceRoot":"","sources":["../../../src/ui/record/RowCheckbox.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AACpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAIlE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,qBAAqB,CAAC;IAC7B,GAAG,EAAE,SAAS,CAAC;IACf,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,gBAAgB,qBAenE;AAmBD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,qBAO/C"}

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

@@ -0,0 +1,26 @@
+import { RecordBulkActionContext, RecordTableController } from '../../react/index.js';
+import { RecordViewRuntime } from '../../runtime/index.js';
+import type * as React from 'react';
+/** What the selection's bar hands its actions: the selection itself. */
+export type SelectionContext = Omit<RecordBulkActionContext, 'run' | 'busy'>;
+/** What the selection shows: its count, the way to drop it, its actions. */
+interface SelectionProps {
+    table: RecordTableController;
+    runtime: RecordViewRuntime;
+    /** The declared actions over the selection, then the host's bulk slot. */
+    bulkActions?(context: SelectionContext): React.ReactNode;
+}
+/**
+ * The selection's part of a toolbar, inside a `Toolbar` of the caller's:
+ * the result toolbar's left end, and a dashboard's record panel's own bar
+ * (`SelectionBar`, D39).
+ */
+export declare function SelectionGroup({ table, runtime, bulkActions, }: SelectionProps): React.JSX.Element;
+/**
+ * The selection on a surface with no result toolbar — a dashboard's record
+ * panel whose host brought a bulk action (D39): the count, the way to drop
+ * it and the host's bulk slot, one toolbar, only while rows are picked.
+ */
+export declare function SelectionBar(props: SelectionProps): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=SelectionBar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionBar.d.ts","sourceRoot":"","sources":["../../../src/ui/record/SelectionBar.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EACV,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,sBAAsB,CAAC;AAE9B,wEAAwE;AACxE,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,uBAAuB,EAAE,KAAK,GAAG,MAAM,CAAC,CAAC;AAC7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAQhE,4EAA4E;AAC5E,UAAU,cAAc;IACtB,KAAK,EAAE,qBAAqB,CAAC;IAC7B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,0EAA0E;IAC1E,WAAW,CAAC,CAAC,OAAO,EAAE,gBAAgB,GAAG,KAAK,CAAC,SAAS,CAAC;CAC1D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAC7B,KAAK,EACL,OAAO,EACP,WAAW,GACZ,EAAE,cAAc,qBAmEhB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,4BAYjD"}

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

@@ -0,0 +1,11 @@
+/**
+ * The cards of a query that is running with nothing on screen to keep.
+ *
+ * The same answer the table gives with `SkeletonRows`: one bar per field
+ * the card will hold, so the shape the answer will take is already on
+ * screen. A first load has no card layout yet, and draws three bars.
+ */
+export declare function SkeletonCards({ fields }: {
+    fields: number;
+}): import('react').JSX.Element;
+//# sourceMappingURL=SkeletonCards.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SkeletonCards.d.ts","sourceRoot":"","sources":["../../../src/ui/record/SkeletonCards.tsx"],"names":[],"mappings":"AAoBA;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,+BAsB3D"}

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

@@ -0,0 +1,33 @@
+import { RecordColumnView } from '../../record/index.js';
+/** How many rows a running query is drawn as. */
+export declare const SKELETON_ROWS = 3;
+/**
+ * How wide one column's bar is, in characters of its own name.
+ *
+ * A column name is the only thing known about a column whose values have
+ * not arrived, and it is a fair guess at them: a table lays out by content,
+ * so a short-named column is a narrow column. It is bounded at both ends —
+ * a two-letter name still gets a bar wide enough to read as one, and a
+ * sentence of a label does not get a bar the width of the screen.
+ */
+export declare function barWidth(label: string): string;
+export interface SkeletonRowsProps {
+    /** The last known columns; empty on a first load, which has none yet. */
+    columns: readonly RecordColumnView[];
+    selectable: boolean;
+    actions: boolean;
+}
+/**
+ * The rows of a query that is running with nothing on screen to keep.
+ *
+ * Where the columns are known the skeleton is drawn **by column**, each bar
+ * as wide as the name above it: three equal bars across the whole table said
+ * only "something is loading", while a row of unequal bars under the real
+ * headers says *this* table is loading, and the shape the answer will take
+ * is already on screen. Where they are not — a first load, which has no
+ * result and so no columns and draws no header either (#1585) — one bar per
+ * row is all there is to say, and inventing column names from the draft
+ * would be heading rows with columns the result has not agreed to.
+ */
+export declare function SkeletonRows({ columns, selectable, actions, }: SkeletonRowsProps): import('react').JSX.Element[];
+//# sourceMappingURL=SkeletonRows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SkeletonRows.d.ts","sourceRoot":"","sources":["../../../src/ui/record/SkeletonRows.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAO9D,iDAAiD;AACjD,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,MAAM,WAAW,iBAAiB;IAChC,yEAAyE;IACzE,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACrC,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,EAC3B,OAAO,EACP,UAAU,EACV,OAAO,GACR,EAAE,iBAAiB,iCAkDnB"}

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

@@ -0,0 +1,75 @@
+import { RecordSort } from '../../model/index.js';
+import { RecordColumnView } from '../../record/index.js';
+import { StickyPin } from './sticky.js';
+export interface SortableHeaderProps {
+    column: RecordColumnView;
+    /**
+     * Every sorted column in priority order, which is what a header needs to
+     * show its own place in the sort rather than only its direction.
+     */
+    sort: readonly RecordSort[];
+    /**
+     * The sort the next press is worked out from: the draft's, which differs
+     * from `sort` while a sort waits for Apply. Left out, it is `sort`.
+     */
+    drafted?: readonly RecordSort[];
+    /**
+     * The sort one plain press on a column leaves, where it is not the
+     * record table's cycle over `drafted` (off → ascending → descending →
+     * off): an analysis's third press goes back to the order the presses
+     * began from (`headerSorted`).
+     */
+    upcoming?(field: string): readonly RecordSort[];
+    /**
+     * Cycles a column's sort. A plain click is `exclusive` — order the rows
+     * by this column alone; Shift, Ctrl or ⌘ held makes it join the others.
+     */
+    onToggle(field: string, options?: {
+        exclusive?: boolean;
+    }): void;
+    /**
+     * Commits a width in pixels, or `null` to let the column size itself
+     * again. Left out, the header's edge is a line rather than a handle — an
+     * embedded table whose host has no controller to write to.
+     */
+    onResize?(field: string, width: number | null): void;
+    pin?: StickyPin;
+    /**
+     * The id of the sentence saying how to add a column to the sort rather
+     * than replace it. One sentence serves the whole header row, so the table
+     * writes it once and every sortable header points at it; a column that
+     * cannot be sorted has no button and points at nothing.
+     */
+    additiveId: string;
+    /**
+     * A word about the column its name does not say, and the id of the span a
+     * reader hears it from — an analysis percentile's 「近似值」, which Wow
+     * computes approximately. It follows the name into the tooltip, describes
+     * the header's focusable element beside the additive rule, and the cell
+     * says it carries one (`data-note`).
+     */
+    note?: {
+        id: string;
+        text: string;
+    };
+}
+/**
+ * One column header, and the whole of the sorting interaction.
+ *
+ * Three things are said rather than drawn. `aria-sort` on the cell is how a
+ * table says which column it is ordered by, and it goes on the column that
+ * decides that order and on no other. The button's name is what the *next*
+ * click does — ascending, then descending, then off — because a control is
+ * named by its action, and the column's own label is inside that sentence, so
+ * what is heard still contains what is seen. And a column that could be
+ * sorted but is not wears a neutral mark, so the affordance does not appear
+ * only after it is used.
+ *
+ * A second sorted column joins the first rather than replacing it (see
+ * `useRecordTable.toggleSort`), so while more than one is sorted each header
+ * also carries its position, drawn as a number and spoken in its name: two
+ * arrows say what the table is ordered by but not in which order, and ARIA
+ * has one attribute where this has several columns.
+ */
+export declare function SortableHeader({ column, sort, drafted, upcoming, onToggle, onResize, pin, additiveId, note, }: SortableHeaderProps): import('react').JSX.Element;
+//# sourceMappingURL=SortableHeader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SortableHeader.d.ts","sourceRoot":"","sources":["../../../src/ui/record/SortableHeader.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAiB,MAAM,sBAAsB,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAS9D,OAAO,EAAyB,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAIpE,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,gBAAgB,CAAC;IACzB;;;OAGG;IACH,IAAI,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5B;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,UAAU,EAAE,CAAC;IAChD;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACjE;;;;OAIG;IACH,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IACrD,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EACN,IAAI,EACJ,OAAc,EACd,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,GAAG,EACH,UAAU,EACV,IAAI,GACL,EAAE,mBAAmB,+BAmMrB"}

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

@@ -0,0 +1,43 @@
+import { RecordColumnView, SummaryCell, SummaryRow } from '../../record/index.js';
+import { TablePins } from './columns.js';
+export interface SummaryRowsProps {
+    /**
+     * One row per scope, in reading order: the rows on screen first, then
+     * everything the conditions match. One alone is the page, which is what is
+     * left when the totals query fails.
+     */
+    rows: readonly SummaryRow[];
+    columns: readonly RecordColumnView[];
+    selectable: boolean;
+    /** Whether the rows carry an action column the footer has to match. */
+    actions: boolean;
+    /** What is held against the edges, the cap's answer included. */
+    pins: TablePins;
+}
+/**
+ * The summary rows: this page, and every record the conditions match.
+ *
+ * Their scope is part of the number, not a detail. A `total` comes from its
+ * own aggregation over everything the conditions select, while a `page` is
+ * the visible rows added up; an average over twenty rows presented as the
+ * average over forty thousand is the one mistake these rows could make, so
+ * each says which it is in a label cell of its own rather than sharing one.
+ * They are shown together because the answer to "is this page representative"
+ * is the other row, and putting them side by side is the whole point.
+ */
+export declare function SummaryRows({ rows, columns, selectable, actions, pins, }: SummaryRowsProps): import('react').JSX.Element;
+/**
+ * One number under its column: the function it came from, then the value,
+ * both ending at the column's right edge where the digits line up with the
+ * cells above. The function is named rather than coded — `SUM` is a token
+ * from the config, and a reader is owed a word.
+ */
+export declare function SummaryValue({ cell, reading, }: {
+    cell: SummaryCell;
+    /**
+     * Under a table column: marked for the watch on which columns are out of
+     * view (`useOffscreenColumns`). The cards have no columns to scroll to.
+     */
+    reading?: boolean;
+}): import('react').JSX.Element;
+//# sourceMappingURL=SummaryRows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SummaryRows.d.ts","sourceRoot":"","sources":["../../../src/ui/record/SummaryRows.tsx"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,gBAAgB,EAChB,WAAW,EACX,UAAU,EACX,MAAM,uBAAuB,CAAC;AAO/B,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AA+BtB,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,IAAI,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5B,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACrC,UAAU,EAAE,OAAO,CAAC;IACpB,uEAAuE;IACvE,OAAO,EAAE,OAAO,CAAC;IACjB,iEAAiE;IACjE,IAAI,EAAE,SAAS,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,EAC1B,IAAI,EACJ,OAAO,EACP,UAAU,EACV,OAAO,EACP,IAAI,GACL,EAAE,gBAAgB,+BA0ClB;AA4HD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,OAAe,GAChB,EAAE;IACD,IAAI,EAAE,WAAW,CAAC;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,+BA6BA"}

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

@@ -0,0 +1,41 @@
+import { DisplayContext, DisplayField } from '../kit/display.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+import type * as React from 'react';
+/**
+ * What a renderer knows about the field a value came from — which is what any
+ * reading of a value needs, `cellText` in a CSV included, so it is that type
+ * under the name this side uses for it.
+ */
+export type CellField = DisplayField;
+/**
+ * Where the reading is drawn, which is the one thing the two surfaces
+ * disagree about: **how many lines a value may take**.
+ *
+ * A table is read down a column — the eye runs a straight line to find the
+ * row it wants — and a row that is two lines tall wherever a note happens to
+ * be long makes that line a staircase. On the twenty-column fixture the rows
+ * measured 41, 61 and 77 pixels, three heights in one table, because a note
+ * clamped to three lines and a pair of tags wrapped to two. A card has no
+ * column to line up with and all the room it wants downwards, so it keeps
+ * the three lines.
+ *
+ * Nothing else differs, which is the point of there being one function: a
+ * card's status is the same badge as the column it was folded out of.
+ */
+export type CellSurface = 'table' | 'card' | 'detail';
+/**
+ * One value as its field reads it.
+ *
+ * The table and the cards both come through here, so a card can never
+ * disagree with the column it was folded out of. What the field declares
+ * decides: `status` and `tags` wear badges, `link` is a guarded external
+ * link, `text` is a paragraph as long as the surface allows, `copyable` is
+ * the value with the means to take it away, an array of objects is its
+ * elements by the title the field names (or how many it holds, never its
+ * JSON), and a field that declares nothing falls through to the kind's own
+ * rendering — a date in the
+ * surface's zone, a number in its format, a boolean in the catalogue's
+ * words.
+ */
+export declare function cellValue(value: unknown, field: CellField, messages: MessageFormatters, display: DisplayContext, surface: CellSurface): React.ReactNode;
+//# sourceMappingURL=cells.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cells.d.ts","sourceRoot":"","sources":["../../../src/ui/record/cells.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAKpC,OAAO,EAML,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAUpE;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,YAAY,CAAC;AAWrC;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEtD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,WAAW,GACnB,KAAK,CAAC,SAAS,CAqJjB"}

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

@@ -0,0 +1,190 @@
+import { CSSProperties, RefObject } from 'react';
+import { RecordColumnView } from '../../record/index.js';
+import { PinnedSlot, ReleasedPins } from './pinCap.js';
+import { LeftPin, RightPin, StickyPin } from './sticky.js';
+/**
+ * Marks the two columns that are not a field, so the header can be measured
+ * by what each cell is rather than by counting from the ends.
+ */
+export declare const SELECT_COLUMN = "select";
+export declare const ACTIONS_COLUMN = "actions";
+/**
+ * Keeps the pinned columns' offsets equal to what the header really measures.
+ *
+ * Column widths come from the content, not from the config: a declared
+ * `width` is a suggestion an auto-laid-out table may exceed, the selection
+ * and action columns declare nothing at all, and a column placed by the
+ * arithmetic alone lands on top of its neighbour — the selection column
+ * renders half as wide again as its class asks for, because the scope label
+ * sits in it.
+ *
+ * It writes the numbers straight onto the table as custom properties rather
+ * than through state: this is a layout the DOM already knows and React does
+ * not, so reading it back into a render would only buy a second pass. The
+ * header is measured rather than a body row because a table with no rows
+ * still has one.
+ *
+ * What is watched is each of those header cells and not the table, because
+ * the offsets follow the cells: a web font that finishes loading or an action
+ * button that grows changes a column's width inside a table whose own box
+ * never moves, and offsets published from the last layout would then hold the
+ * pinned columns over their neighbours.
+ *
+ * **Keyed on what is held, not run every render.** With no dependency list
+ * at all this re-measured the header and tore down its `ResizeObserver` on
+ * every render of the table — every hover, every row picked, every keystroke
+ * in the editor above — and each of those measurements is a forced layout on
+ * a table the reader is in the middle of using. What it has to survive is a
+ * column appearing, disappearing or moving, and a pin coming or going with
+ * the cap (D17-4): that is exactly when {@link TablePins} changes, since it
+ * is projected from the columns, the layout and the cap's answer.
+ */
+export declare function usePinnedOffsets(table: RefObject<HTMLTableElement | null>, pins: TablePins): void;
+/**
+ * The action column's own cell, whether or not it is held.
+ *
+ * `w-0` because the buttons are all the width it needs and the surplus
+ * belongs to the trailing filler; `whitespace-nowrap` so a row's actions
+ * stay on one line. The freeze is not in here — it comes from
+ * `TablePins.actions` through `stickyCell`, and the cap takes it away on a
+ * narrow port, at which point the buttons scroll with their row and the
+ * right edge goes with them: a frame's end is worth less than a middle
+ * nobody can read (D17-4).
+ */
+export declare const ACTION_CELL = "fve:w-0 fve:bg-inherit fve:whitespace-nowrap";
+/**
+ * The table's border model, and the hairlines drawn under it.
+ *
+ * Preflight collapses table borders, and in collapsed mode Chromium paints
+ * no outer `box-shadow` on a cell at all: the edges above computed fine and
+ * drew nothing, so a held column sat on the page with the shadow D13 asked
+ * for existing only in `getComputedStyle`. Separate borders paint it. But a
+ * `<tr>` — and a `<thead>`/`<tfoot>` — has no border of its own in that
+ * model, so the hairline between rows moves from the row onto its cells;
+ * the last summary row leaves it off, since the frame's pagination draws
+ * that line as its own top.
+ */
+export declare const TABLE_CELLS = "fve:border-separate fve:border-spacing-0 fve:[&_th]:border-b fve:[&_td]:border-b fve:[&_tfoot_tr:last-child_td]:border-b-0";
+/**
+ * A column header is metadata about the column rather than content in it —
+ * but it is not quieter than the values under it: it is the same ink on a
+ * grey of its own. `text-muted-foreground` measured **4.34:1** on that grey
+ * (the same number `--_fve-quiet-foreground` exists because of, see
+ * `styles.css`), under 1.4.3's 4.5 at a size that is already the smallest
+ * on the surface; the registry's own `text-foreground font-medium` on
+ * `<th>` measures 18.15:1 light and 14.48:1 dark. So this class no longer
+ * overrides either of them — what is left is the one small type size and
+ * the two rules about the button in the cell.
+ */
+export declare const HEAD_CELL = "fve:text-[length:var(--_fve-text-ui)] fve:leading-[1.125rem] fve:[&>button]:max-w-[calc(var(--_fve-table-cell-padding-inline)*2+100%)] fve:[&>button]:hover:bg-background";
+/** Numbers line up on their last digit, in the cells and in the header. */
+export declare const NUMERIC_CELL = "fve:text-right fve:tabular-nums";
+/**
+ * The face an identifier is read in: monospace, so `0` and `O`, `l` and `1`
+ * do not look alike and a column of ids lines up under itself, at 0.9em
+ * because a monospace face at the text's own size reads a size larger (see
+ * `cells.tsx`, the copyable reading). The analysis table's key dimensions
+ * wear the same one.
+ */
+export declare const IDENTIFIER_FACE = "fve:font-mono fve:text-[0.9em]";
+/**
+ * A column that was given a width keeps it: the cell is capped as well as
+ * sized, and what does not fit is cut with an ellipsis rather than pushing
+ * the column back out. Without the cap the width is only a suggestion — an
+ * auto-laid-out table grows a column to its widest cell whatever the header
+ * asked for, so a column dragged narrower would spring back on the next
+ * render.
+ *
+ * With the prefix every class in `src` wears (D66): written bare, it
+ * compiled to nothing, and a column narrower than its values spilled them
+ * over the next column — a copy button included, which then stood under
+ * the neighbour's ground when focused (WCAG 2.4.11, the accessibility
+ * review).
+ */
+export declare const CLIPPED_CELL = "fve:truncate";
+/**
+ * The width one column asks for, as every cell of it has to carry it.
+ *
+ * **All three properties, and on the cells.** A `width` on its own is a
+ * suggestion: an auto-laid-out table sizes a column by its content and then
+ * shares out whatever room is left over, so a column asked for 200px comes
+ * out wider on a roomy table and wider still under a long value. The floor
+ * and the ceiling are what make it a width — with `min-width` and
+ * `max-width` equal, the column's minimum and maximum contributions are the
+ * same number and there is nothing left for either step to decide. A `<col>`
+ * cannot say any of this, any more than it can say pinning: it carries a
+ * width the table treats as a hint, and nothing that clips the cell drawn
+ * in it.
+ */
+export declare function columnWidth(column: RecordColumnView): CSSProperties | undefined;
+/**
+ * Whether a column's values are numbers, and so read from the right. The
+ * projection resolves `cell` to the kind's own renderer when the field names
+ * none, so the renderer key alone answers it.
+ */
+export declare function isNumeric(column: RecordColumnView): boolean;
+/** What the table adds to the columns, and what it holds of them. */
+export interface TableLayout {
+    /** Whether the rows carry the selection column. */
+    selectable: boolean;
+    /** Whether the rows carry the host's action column. */
+    actions: boolean;
+    /**
+     * Whether the table's own last column is held against the right edge —
+     * D13's end. On unless the table stands where it is read at rest (a
+     * dashboard panel): a column held on the right covers the middle
+     * whenever the table overflows, *before* anything has scrolled, so on a
+     * surface nobody scrolls sideways what the reader gets is half a column
+     * under the end — 「已重试次数」 read as 「已重试次」. A pin on the left
+     * covers nothing until the rows are scrolled, so this is the right side
+     * alone.
+     */
+    end?: boolean;
+}
+/** What the table holds against its two edges, once the cap has had its say. */
+export interface TablePins {
+    /** The pin each data column draws, by field; absent means it scrolls. */
+    columns: ReadonlyMap<string, StickyPin>;
+    /**
+     * The selection column's pin, against the left edge itself — absent where
+     * there is nothing pinned left for it to sit beside, or where the cap has
+     * let it go. It is never a boundary: a column pinned left always follows
+     * it.
+     */
+    select?: LeftPin;
+    /**
+     * The host's action column, against the right edge itself. Always the
+     * boundary while it is held, because the right side has nothing else on
+     * it (D19).
+     */
+    actions?: RightPin;
+}
+/**
+ * Every column the table would hold, in the order the cap lets them go.
+ *
+ * **Outermost first, and the right side before the left.** What is furthest
+ * out is what the layout added rather than what the config chose: the host's
+ * action column at one end, the selection box at the other. The left block
+ * goes last because it is the row's identity — the checkbox and the key
+ * beside it are "which row is this, and is it picked" — and the key itself
+ * is never in the cap's hands at all.
+ */
+export declare function pinnedSlots(columns: readonly RecordColumnView[], layout: TableLayout): PinnedSlot[];
+/**
+ * Each column's pin, by field, for the columns the layout holds — and
+ * whether the two chrome columns are held along with them.
+ *
+ * The offset is the measured one the effect above writes, with the config's
+ * own arithmetic as the fallback: declared widths added up from the left
+ * edge, so a column is placed sensibly before anything has been measured and
+ * exactly afterwards. A pinned column with no declared width contributes
+ * nothing to that fallback — the one after it would start at the same place
+ * until the measurement lands. Only the left has a chain: one column at most
+ * is ever held on the right (D19), and its place is the edge.
+ *
+ * `released` is the cap's answer (D17-4). It is a rendering decision and
+ * never an edit: the config still says the column is pinned, and the pin
+ * comes back the moment the port has room for it.
+ */
+export declare function tablePins(columns: readonly RecordColumnView[], layout: TableLayout, released?: ReleasedPins): TablePins;
+//# sourceMappingURL=columns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"columns.d.ts","sourceRoot":"","sources":["../../../src/ui/record/columns.ts"],"names":[],"mappings":"AAaA,OAAO,EAAmB,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAC5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,EAAc,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,EAEL,KAAK,OAAO,EAEZ,KAAK,QAAQ,EACb,KAAK,SAAS,EACf,MAAM,aAAa,CAAC;AAWrB;;;GAGG;AACH,eAAO,MAAM,aAAa,WAAW,CAAC;AACtC,eAAO,MAAM,cAAc,YAAY,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,EACzC,IAAI,EAAE,SAAS,GACd,IAAI,CAON;AAwCD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,iDAAiD,CAAC;AAE1E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,+HACsG,CAAC;AAmD/H;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,8KAA4C,CAAC;AAEnE,2EAA2E;AAC3E,eAAO,MAAM,YAAY,oCAAoC,CAAC;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,mCAAmC,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAE3C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,gBAAgB,GACvB,aAAa,GAAG,SAAS,CAO3B;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAE3D;AAED,qEAAqE;AACrE,MAAM,WAAW,WAAW;IAC1B,mDAAmD;IACnD,UAAU,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;;;;;OASG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,gFAAgF;AAChF,MAAM,WAAW,SAAS;IACxB,yEAAyE;IACzE,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACxC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,OAAO,CAAC,EAAE,QAAQ,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,MAAM,EAAE,WAAW,GAClB,UAAU,EAAE,CA8Bd;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,MAAM,EAAE,WAAW,EACnB,QAAQ,GAAE,YAAyB,GAClC,SAAS,CA+CX"}

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

@@ -0,0 +1,24 @@
+import { RecordDetailSection } from '../../react/index.js';
+import { DetailSection } from '../../record/index.js';
+/** One section of a record's detail, the engine's or the host's. */
+export type PlacedSection = {
+    host: false;
+    section: DetailSection;
+} | {
+    host: true;
+    section: RecordDetailSection;
+};
+/**
+ * The engine's field sections and the host's, in reading order.
+ *
+ * The engine's keep the definition's order; each host section goes where its
+ * `placement` says — before them all, after one field group by its id, or
+ * (by default, and for a group the definition does not have) after them all
+ * — and host sections that land in one place keep the order they were given.
+ *
+ * A field a host section shows itself (`fields`) leaves the engine's groups,
+ * and a group it empties is not drawn; a section placed after that group
+ * still stands where the group stood.
+ */
+export declare function placeSections(fields: readonly DetailSection[], hosts: readonly RecordDetailSection[]): PlacedSection[];
+//# sourceMappingURL=detailPlacement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"detailPlacement.d.ts","sourceRoot":"","sources":["../../../src/ui/record/detailPlacement.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,oEAAoE;AACpE,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,aAAa,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,mBAAmB,CAAA;CAAE,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,KAAK,EAAE,SAAS,mBAAmB,EAAE,GACpC,aAAa,EAAE,CAiCjB"}

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

@@ -0,0 +1,59 @@
+import { FilterTree, ViewConfig } from '../../model/index.js';
+import { ViewRuntimeState } from '../../runtime/index.js';
+/**
+ * The one way out of a query that matched nothing, by what was asked.
+ *
+ * - `restore` — a saved view whose conditions were added to: the rows are
+ *   missing because of what the reader added, so the way out is back to
+ *   the conditions the view was saved with, not to none. Clearing them
+ *   would turn 「不可恢复」 into 「全部」 — another view under its name.
+ * - `edit` — a saved view asking exactly what it was saved to ask: the view
+ *   is empty right now, which is an answer. Its conditions are what it is,
+ *   so nothing is taken away; the way on is to ask something else.
+ * - `clear` — a view never saved, under conditions: nothing to go back to,
+ *   so the conditions go and what there is shows.
+ * - `add` — no conditions at all: everything there is was shown, and the
+ *   only thing left is a question.
+ */
+export type EmptyWayOut = 'restore' | 'edit' | 'clear' | 'add';
+export declare function emptyWayOut(
+/** `conditionsDrifted`: `null` for a view never saved. */
+drifted: boolean | null, hasConditions: boolean): EmptyWayOut;
+/** What `wayOutOf` reads and acts on; a record view and an analysis alike. */
+export interface WayOutTarget {
+    /** The open view's state: what is in force, and what it was saved as. */
+    state: Pick<ViewRuntimeState<ViewConfig>, 'applied' | 'saved'> | null;
+    /** Whether conditions of the view's own are in force on the rows. */
+    hasConditions: boolean;
+    /** Takes every condition out of the draft; `submit` then asks again. */
+    filter: {
+        clear(): void;
+        submit(): void;
+    };
+    /** The open view, to put the saved conditions back in force. */
+    runtime: {
+        edit(patch: {
+            filter: FilterTree;
+        }): void;
+        apply(): void;
+    } | null;
+    /** Opens the editor the question is changed in. */
+    openEditor(): void;
+}
+/**
+ * The way out of an empty result, and the press that takes it.
+ *
+ * The two data views share the rule and the press: the record view's empty
+ * result and the analysis's say different sentences over them, and nothing
+ * else. Clearing asks again — `clear` alone would leave the rows on screen
+ * fetched under the conditions the button just took away; going back puts
+ * the saved conditions in force and nothing else of the draft (`restore` is
+ * only ever chosen when the saved config is of the open view's kind,
+ * `conditionsDrifted`); and asking something else opens the editor, because
+ * the question to change is behind a fold that may not even be on screen.
+ */
+export declare function wayOutOf({ state, hasConditions, filter, runtime, openEditor, }: WayOutTarget): {
+    wayOut: EmptyWayOut;
+    take(): void;
+};
+//# sourceMappingURL=emptyWayOut.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emptyWayOut.d.ts","sourceRoot":"","sources":["../../../src/ui/record/emptyWayOut.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE/D,wBAAgB,WAAW;AACzB,0DAA0D;AAC1D,OAAO,EAAE,OAAO,GAAG,IAAI,EACvB,aAAa,EAAE,OAAO,GACrB,WAAW,CAIb;AAED,8EAA8E;AAC9E,MAAM,WAAW,YAAY;IAC3B,yEAAyE;IACzE,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC;IACtE,qEAAqE;IACrE,aAAa,EAAE,OAAO,CAAC;IACvB,wEAAwE;IACxE,MAAM,EAAE;QAAE,KAAK,IAAI,IAAI,CAAC;QAAC,MAAM,IAAI,IAAI,CAAA;KAAE,CAAC;IAC1C,gEAAgE;IAChE,OAAO,EAAE;QAAE,IAAI,CAAC,KAAK,EAAE;YAAE,MAAM,EAAE,UAAU,CAAA;SAAE,GAAG,IAAI,CAAC;QAAC,KAAK,IAAI,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;IAC7E,mDAAmD;IACnD,UAAU,IAAI,IAAI,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,EACvB,KAAK,EACL,aAAa,EACb,MAAM,EACN,OAAO,EACP,UAAU,GACX,EAAE,YAAY,GAAG;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,IAAI,IAAI,IAAI,CAAA;CAAE,CAyBtD"}

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

@@ -0,0 +1,47 @@
+import { RuntimeLimits } from '../../model/index.js';
+import { RecordViewRuntime } from '../../runtime/index.js';
+import { FilterEditorController, RecordExportScope, RecordTableController } from '../../react/index.js';
+import { ExportWindowProps } from '../kit/ExportDialog.js';
+/** The media type every export is handed over as: a UTF-8 CSV. */
+export declare const CSV_TYPE = "text/csv;charset=utf-8";
+/**
+ * Whether the host's limits leave an export's formulas neutralized
+ * (`RuntimeLimits.exportNeutralizeFormulas`): only an explicit `false` turns
+ * it off, so limits a host spelled out by hand without the member still
+ * write a safe file.
+ */
+export declare function neutralizesFormulas(limits: Pick<RuntimeLimits, 'exportNeutralizeFormulas'>): boolean;
+/** One file an export produced, as it was handed over. */
+export interface ExportedFile {
+    name: string;
+    text: string;
+    scope: RecordExportScope;
+    rows: number;
+}
+/**
+ * What the export window is handed (`ExportWindowProps`) for one open record view
+ * — the workbench's toolbar and an embed's head alike (D14, D22).
+ *
+ * The rows go out as a CSV of the columns the table is drawing, in its
+ * order, each value through the same reading the cell above it uses: an
+ * export that said `1789723315014` where the screen said a date would be a
+ * second, quieter view of the data. The host's scope narrows the export
+ * exactly as it narrows the rows, so the window names both kinds of
+ * condition.
+ *
+ * Everything else it reads for itself: the wording and the language and zone
+ * a value reads in from the surface it is drawn on, the clock from the
+ * runtime, and the columns and the ceiling (`exportPlan`) off the table and
+ * the runtime — so a caller hands over the view and nothing it could get
+ * wrong. It is therefore called **inside** the surface (`ViewSurface`), where
+ * the window it feeds is drawn.
+ */
+export declare function useExportOffer({ runtime, table, filter, title, onExported, }: {
+    runtime: RecordViewRuntime;
+    table: RecordTableController;
+    filter: FilterEditorController;
+    /** The view's title, which names the file. */
+    title: string;
+    onExported?(file: ExportedFile): void;
+}): ExportWindowProps;
+//# sourceMappingURL=exportOffer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exportOffer.d.ts","sourceRoot":"","sources":["../../../src/ui/record/exportOffer.ts"],"names":[],"mappings":"AAcA,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAC;AAI9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAOhE,kEAAkE;AAClE,eAAO,MAAM,QAAQ,2BAA2B,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,0BAA0B,CAAC,GACtD,OAAO,CAET;AAsCD,0DAA0D;AAC1D,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,iBAAiB,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,KAAK,EACL,MAAM,EACN,KAAK,EACL,UAAU,GACX,EAAE;IACD,OAAO,EAAE,iBAAiB,CAAC;IAC3B,KAAK,EAAE,qBAAqB,CAAC;IAC7B,MAAM,EAAE,sBAAsB,CAAC;IAC/B,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;CACvC,GAAG,iBAAiB,CAiDpB"}