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

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

@@ -0,0 +1,34 @@
+import { ReactElement } from 'react';
+import { FieldDefinition } from '../../model/index.js';
+import { RecordTableController } from '../../react/index.js';
+import { DetachedPopover } from '../kit/toolbar.js';
+export interface CardSettingsProps {
+    table: RecordTableController;
+    /** The fields the definition offers, in its order. */
+    fields: readonly FieldDefinition[];
+    /**
+     * The control that opens it, where the toolbar's is not on screen: the
+     * error strip's worded button for a config that will not run (as
+     * `ColumnSettings`' `trigger`). Left out, the toolbar's own button.
+     */
+    trigger?: ReactElement<Record<string, unknown>>;
+    /** One half of it, as `ColumnSettings`' `detached`. */
+    detached?: DetachedPopover;
+}
+/**
+ * What a card shows: the field that names it, the fields in its body, the
+ * field its picture comes from, and how many stand in a row.
+ *
+ * It is the column settings' button under the card layout (D18 VI): the
+ * same place in the toolbar, the same popover, and the question the column
+ * settings answer for a row asked for a card. Before this the button did
+ * nothing at all under cards, and `config.card` had no editor anywhere.
+ *
+ * The body keeps the order the config holds: a field switched on joins at
+ * the end, one switched off leaves, and what a saved view already lists
+ * stays where it was. Nothing here is dragged — a card's body is read top
+ * to bottom, and the definition's order is the order most hosts want; a
+ * reorder is the one thing left to the phase after this.
+ */
+export declare function CardSettings({ table, fields, trigger, detached, }: CardSettingsProps): import('react').JSX.Element;
+//# sourceMappingURL=CardSettings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CardSettings.d.ts","sourceRoot":"","sources":["../../../src/ui/record/CardSettings.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAEjD,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAiClE,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEtE,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,qBAAqB,CAAC;IAC7B,sDAAsD;IACtD,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IACnC;;;;OAIG;IACH,OAAO,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAChD,uDAAuD;IACvD,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,MAAM,EACN,OAAO,EACP,QAAQ,GACT,EAAE,iBAAiB,+BAiNnB"}

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

@@ -0,0 +1,15 @@
+import { SummaryRow } from '../../record/index.js';
+/**
+ * The summary rows under the cards (D18 V).
+ *
+ * A card has no column to stand a number under, so the two scopes are two
+ * lines instead of two rows: the scope's word, then each summary as the
+ * function's word and the value — the same `SummaryValue` the table's
+ * footer draws, so a number reads the same whichever layout it is under.
+ * Switching to cards used to drop the summaries without a word, which
+ * turned "This page / All records" into something the table alone had.
+ */
+export declare function CardSummaries({ rows }: {
+    rows: readonly SummaryRow[];
+}): import('react').JSX.Element | null;
+//# sourceMappingURL=CardSummaries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CardSummaries.d.ts","sourceRoot":"","sources":["../../../src/ui/record/CardSummaries.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAKxD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,SAAS,UAAU,EAAE,CAAA;CAAE,sCA8CtE"}

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

@@ -0,0 +1,67 @@
+import { RecordColumnView } from '../../record/index.js';
+import type * as React from 'react';
+/**
+ * The narrowest a column may be dragged.
+ *
+ * A column has to stay grabbable: its own edge is the only way back, and an
+ * edge dragged onto the one before it is a column nobody can find again. It
+ * is a rule about a handle rather than about a config, so it lives here and
+ * not in `validateRecord` — a width written by hand may be anything positive.
+ */
+export declare const MIN_COLUMN_WIDTH = 48;
+/**
+ * The widest a column's width box sets it: a number typed there is a width
+ * a reader meant, and a digit held down is not — a column wider than any
+ * screen is one whose neighbours are gone.
+ */
+export declare const MAX_COLUMN_WIDTH = 2000;
+export interface ColumnResizerProps {
+    column: RecordColumnView;
+    /** Commits a width in pixels, or `null` to let the column size itself. */
+    onResize(field: string, width: number | null): void;
+}
+/**
+ * The right edge of a column header, as something to take hold of.
+ *
+ * **The drag writes the DOM, not state.** A column's width is a layout the
+ * browser already knows and React does not, and a `setState` per
+ * `pointermove` would re-render the whole result — every row, every cell —
+ * between one frame and the next. So the gesture writes the width straight
+ * onto the cells of its own column, the same reasoning `usePinnedOffsets`
+ * measures by, and only the *release* goes through the controller. The pins
+ * follow along on their own: the offsets are published from a
+ * `ResizeObserver` on the header cells, and the cell this drag is resizing is
+ * one of them.
+ *
+ * **The cells are found through the table, not through React.** The handle
+ * knows its own `<th>`, the `<th>` knows its `cellIndex`, and the table knows
+ * its rows — so one column is every row's cell at that index, header, body
+ * and summaries alike. A width put on the header alone is a suggestion an
+ * auto-laid-out table is free to ignore, and it is ignored exactly when it
+ * matters: dragging a column narrower than the text in it.
+ *
+ * **What it commits is a width, and what it un-commits is the key.** A
+ * double-click, or Enter, writes `null`, and the controller then drops the
+ * member rather than setting it to `undefined` — a config is JSON, and a
+ * column back at its automatic width has no `width` in it.
+ */
+export declare function ColumnResizer({ column, onResize }: ColumnResizerProps): React.JSX.Element;
+/**
+ * The handle's keyboard contract, as a function over the handle itself.
+ *
+ * One column's width has two ways in — the handle, which a pointer and a
+ * reader's own cursor find, and the column header, which is where the
+ * roving order stops (`useRovingHeader`). Both must move the same column by
+ * the same amount, so the arithmetic and the DOM writing live here once and
+ * the header reaches them through its own handle rather than repeating them.
+ * The field comes off the handle because the handle already carries it: a
+ * second parameter saying which column this is could disagree with it.
+ *
+ * Returns whether the key was one of the three it answers, so a caller knows
+ * whether to stand the default action down.
+ */
+export declare function resizeByKey(handle: HTMLElement, event: {
+    key: string;
+    shiftKey: boolean;
+}, onResize: (field: string, width: number | null) => void): boolean;
+//# sourceMappingURL=ColumnResizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ColumnResizer.d.ts","sourceRoot":"","sources":["../../../src/ui/record/ColumnResizer.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAG9D;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAMrC,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,gBAAgB,CAAC;IACzB,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;CACrD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,kBAAkB,qBAwIrE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,EACzC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,GACtD,OAAO,CAkBT"}

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

@@ -0,0 +1,51 @@
+import { DisplayContext, DisplayField } from '../kit/display.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+import type * as React from 'react';
+/** One value read the way the detail reads a declared field. */
+export type ReadField = (value: unknown, field: DisplayField) => React.ReactNode;
+/** A value the detail lays out as a structure rather than as one reading. */
+export declare function isStructure(value: unknown): value is object;
+/**
+ * A structured value in a record's detail, read whole — which is what the
+ * detail is for.
+ *
+ * A cell reads an array of objects by its elements' titles and an object by
+ * how many fields it holds, because a row is one line (`heldReading`). The
+ * detail has the room, and what a reader opened it for is often exactly
+ * what those readings leave out: the event a failure recorded, its payload,
+ * the stack trace inside it. So an array of objects is laid out element by
+ * element — the element's title, then each field the definition declares
+ * for an element in that field's own reading, then whatever the element
+ * holds that nothing declares — and an object with no declared elements is
+ * laid out key by key. What nothing declares has no label to show, so its
+ * keys are shown as they are written, in the monospace a key is.
+ */
+export declare function DetailStructure({ value, field, read, messages, display, }: {
+    value: object;
+    field: DisplayField;
+    read: ReadField;
+    messages: MessageFormatters;
+    display: DisplayContext;
+}): React.JSX.Element;
+/**
+ * Where a value sits against its name: beside it, or — for a structure or
+ * text longer than a line — under it, across the whole width. Beside its
+ * name, each level of a document would give up the name column's width
+ * again, and a stack trace three levels down was a column a few characters
+ * wide. Under it, a level costs one rule's indent; a long text is its own
+ * block already and takes no rule.
+ *
+ * `undefined` is beside; otherwise the classes the value's `<dd>` takes,
+ * and its `<dt>` then takes `col-span-2`.
+ */
+export declare function blockOf(value: unknown): string | undefined;
+/**
+ * A long value read whole: kept as written, in a block of its own that
+ * scrolls, with the means to take it away — an error message, a stack
+ * trace.
+ */
+export declare function LongValue({ value }: {
+    value: string;
+}): React.JSX.Element;
+export declare function isLong(value: string): boolean;
+//# sourceMappingURL=DetailStructure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DetailStructure.d.ts","sourceRoot":"","sources":["../../../src/ui/record/DetailStructure.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAKpC,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAGpE,gEAAgE;AAChE,MAAM,MAAM,SAAS,GAAG,CACtB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,YAAY,KAChB,KAAK,CAAC,SAAS,CAAC;AASrB,6EAA6E;AAC7E,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAG3D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,OAAO,GACR,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,OAAO,EAAE,cAAc,CAAC;CACzB,qBAuCA;AAsKD;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAM1D;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EAAE,KAAK,EAAE,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,qBAarD;AAKD,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE7C"}

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

@@ -0,0 +1,41 @@
+import { MessageKey } from '../kit/messages.js';
+import { FilterEditorController } from '../../react/index.js';
+import { EmptyWayOut } from './emptyWayOut.js';
+export interface EmptyResultProps {
+    /** Overrides the catalogue's own wording. */
+    title?: string;
+    description?: string;
+    /** Which way out the query that matched nothing has (`emptyWayOut`). */
+    wayOut: EmptyWayOut;
+    /** The one way out; without it the state is a sentence and nothing more. */
+    onAction?(): void;
+}
+/**
+ * A query that ran and matched nothing, with one way out of it.
+ *
+ * The four other "nothing here" screens are said above the table — the query
+ * failed, the config needs fixing — and this is the one the table owns,
+ * because nothing above it says it. What it adds to that sentence is a
+ * *next step*: a screen that reports a dead end and offers no way off it
+ * leaves the reader to find the control that caused it, which on a folded
+ * editor is not even on screen.
+ *
+ * Which step it is follows from what was asked (`emptyWayOut`): back to a
+ * saved view's own conditions when the reader added to them, on to another
+ * question when the saved view itself is empty right now, clear when a view
+ * never saved is under conditions, add one when there are none. The
+ * sentence says which of those it is — 「这个视图现在没有记录」 is not
+ * 「没有记录符合当前条件」. One action, never two: a way out that has to be
+ * chosen between is not a way out.
+ */
+export declare function EmptyResult({ title, description, wayOut, onAction, }: EmptyResultProps): import('react').JSX.Element;
+/**
+ * What an empty result says where it has no way out to offer — a board's
+ * record panel, an embedded view: the conditions are someone else's to
+ * change. Under any condition in force, the view's own or the scope a board
+ * or a page put on it, the rows are missing because of what was asked
+ * (「没有记录符合当前条件。」), as the workbench says it; with none, there are
+ * no records at all.
+ */
+export declare function emptyHintOf(filter: Pick<FilterEditorController, 'applied' | 'scoped'>): MessageKey;
+//# sourceMappingURL=EmptyResult.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EmptyResult.d.ts","sourceRoot":"","sources":["../../../src/ui/record/EmptyResult.tsx"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,WAAW,gBAAgB;IAC/B,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,MAAM,EAAE,WAAW,CAAC;IACpB,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,WAAW,EACX,MAAM,EACN,QAAQ,GACT,EAAE,gBAAgB,+BAsBlB;AAgBD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,IAAI,CAAC,sBAAsB,EAAE,SAAS,GAAG,QAAQ,CAAC,GACzD,UAAU,CAIZ"}

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

@@ -0,0 +1,47 @@
+/**
+ * How the cell that takes the leftover width is found. It lives here rather
+ * than in `columns.ts` so the cap can skip it without the two files having
+ * to import each other.
+ */
+export declare const FILLER_COLUMN = "filler";
+/**
+ * The last cell of every row, which is not a column.
+ *
+ * The registry's table is `w-full` and an auto layout hands the surplus to
+ * the columns in proportion to what they already ask for, so on a wide
+ * screen one of them becomes a cell with nothing in it: the four-column
+ * fixture in a 1300px result area drew `金额` **446px** around
+ * `¥2,450.00`, and the eye had to cross most of the screen to get from an
+ * order to its amount. A trailing cell asking for `width: 100%` takes that
+ * surplus instead, and every real column comes out at the width its own
+ * content asks for — nothing wraps, nothing is cut, nothing is stretched.
+ *
+ * **And the row still runs to the frame.** Capping the table at
+ * `max-content` was tried first and left a 371px table inside a 692px
+ * result area: the hairlines, the hover band and both summary rows stopped
+ * mid-frame with 320px of bare frame beside them, while the toolbar above
+ * and the pagination below ran to its edge — a table floating in a box, and
+ * against `ui/record.md`'s own rule that the table runs to that edge. The
+ * filler keeps the row as wide as the port, so what the pointer highlights
+ * and what a picked row tints is a whole row again.
+ *
+ * **It is drawn, not announced.** `aria-hidden` keeps it out of the table's
+ * accessible grid, so nobody is told about a column with no name and no
+ * values — which is what the first-load header means when it refuses to
+ * draw an empty `<th>` over rows that do not exist. Here there *are* rows;
+ * what is refused is only the pretence that this is one more column of them.
+ * It is in no `table.columns`, carries no width in any config, is never
+ * pinned, and the cap's header scan steps over it.
+ *
+ * It sits after everything, the host's action column included, so the last
+ * *data* column keeps D13's edge exactly where it was: the rule and the
+ * shadow say "this column is held", and past them there is nothing rather
+ * than more table. Being last is also why `ColumnResizer`'s `cellIndex`
+ * walk and the summary rows' own cells never had to learn about it. On a
+ * table wider than its port there is no surplus at all, so it collapses to
+ * nothing and every number the cap reads is the one it read before.
+ */
+export declare function FillerHead(): import('react').JSX.Element;
+/** The same cell in a body, summary or skeleton row. */
+export declare function FillerCell(): import('react').JSX.Element;
+//# sourceMappingURL=Filler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Filler.d.ts","sourceRoot":"","sources":["../../../src/ui/record/Filler.tsx"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,eAAO,MAAM,aAAa,WAAW,CAAC;AAWtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,UAAU,gCAQzB;AAED,wDAAwD;AACxD,wBAAgB,UAAU,gCAQzB"}

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

@@ -0,0 +1,46 @@
+import { SummaryRow } from '../../record/index.js';
+import { HintCaption, OffscreenHint } from './offscreenSummaries.js';
+export interface OffscreenSummaryProps {
+    hint: OffscreenHint;
+    scope: SummaryRow['scope'];
+    /**
+     * The hint shares its cell with the scope label and so says the scope
+     * itself: 「全部 · 实付 总和 ¥1,401.49 →」.
+     */
+    withScope: boolean;
+    /**
+     * Whether this row words whose number it is, or shares that line with the
+     * row beside it that names the same column's same function
+     * (`hintCaptions`, R2-79). Its own by default.
+     */
+    caption?: HintCaption;
+    onReveal: () => void;
+}
+/**
+ * The summary row naming what it holds out of view (D51): the first such
+ * column's summary, 「等 N 项」 when there are more, and an arrow the way
+ * they lie. A button, because what it offers is to go there.
+ *
+ * It never widens its cell (`contain: inline-size`): the cell is a column
+ * the rows share, the row key at its usual widest, and a hint that appears
+ * and disappears as the table scrolls must not move the columns under it.
+ *
+ * **Two lines, the number on its own** (second review, R1-P1-2 / R3-P1-2).
+ * On one line the sentence did not fit the frozen cell it is given — 142px
+ * of button in a workbench, less in a narrow key column — and what was cut
+ * was its end, the number: 「实付 总和 ¥3,875,…」, 「Retrie… →」. The number
+ * is the one thing the hint exists to say, so it gets a line of its own
+ * with the arrow beside it, and the line above says whose it is (the
+ * scope, the column and the function), wrapping to a second line in a
+ * narrow cell before it is cut. 「等 N 项」 follows the number and gives
+ * way before it; whatever is cut, the whole sentence is still the button's
+ * name and its tooltip. A number is short and is cut last. The cell stays as wide as
+ * before; the row is one line taller while the hint shows, which is the
+ * room the reading needs and costs no column its place.
+ *
+ * Two rows naming the same number say whose it is once (`caption`,
+ * R2-79): over the page's number, and the total's row keeps to the one
+ * line its scope and number take.
+ */
+export declare function OffscreenSummary({ hint, scope, withScope, caption, onReveal, }: OffscreenSummaryProps): import('react').JSX.Element;
+//# sourceMappingURL=OffscreenSummary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OffscreenSummary.d.ts","sourceRoot":"","sources":["../../../src/ui/record/OffscreenSummary.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAOxD,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAG1E,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IAC3B;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,KAAK,EACL,SAAS,EACT,OAAe,EACf,QAAQ,GACT,EAAE,qBAAqB,+BAqIvB"}

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

@@ -0,0 +1,53 @@
+import { RecordTableController } from '../../react/index.js';
+import { RecordRow } from '../../record/index.js';
+import { EmptyWayOut } from './emptyWayOut.js';
+import { RecordCell } from './RecordTable.js';
+import type * as React from 'react';
+export interface RecordCardsProps {
+    table: RecordTableController;
+    /**
+     * Renders one value of a card; the default reads it as the field says.
+     * The same contract as the table's, handed the same `column` for the same
+     * field: a card is a row folded out, and one renderer serves both.
+     */
+    renderCell?(cell: RecordCell): React.ReactNode;
+    /**
+     * Whether cards can be picked. Same contract as the table's, and the same
+     * default: a card is a row folded out, so a surface that offers nothing to
+     * do with a selection must not grow one back by switching layout.
+     */
+    selectable?: boolean;
+    /**
+     * What a host offers on one card, in a footer under its body. Same
+     * contract as the table's: the row alone, because the caller holding the
+     * runtime is the one that binds the action context.
+     */
+    rowActions?(row: RecordRow): React.ReactNode;
+    /**
+     * Opens a card's detail: a press on the card, or Enter/Space on the card
+     * the keyboard is on (`record/openRows.ts`).
+     */
+    onOpen?(row: RecordRow): void;
+    /** The empty result's wording, when the host has its own. */
+    emptyTitle?: string;
+    emptyDescription?: string;
+    /** Which way out an empty result offers; see `RecordTable`. */
+    emptyWayOut?: EmptyWayOut;
+    /** The one way out of an empty result; see `EmptyResult`. */
+    onEmptyAction?(): void;
+}
+/**
+ * The same result as cards, drawn from the card half of the saved config.
+ *
+ * Which layout is showing is part of that config and both halves are stored,
+ * so switching back and forth loses nothing — and a card is not the table
+ * narrowed: its title, its body fields and its image are its own.
+ *
+ * What it says when there is nothing to draw is the table's answer too
+ * (D18 V): nothing at all before a first result, skeleton cards while the
+ * first one is on its way, the empty result with its one way out when the
+ * query matched nothing, and the summary lines under the cards whenever
+ * the table would have drawn its footer.
+ */
+export declare function RecordCards({ table, renderCell, selectable, rowActions, onOpen, emptyTitle, emptyDescription, emptyWayOut, onEmptyAction, }: RecordCardsProps): React.JSX.Element | null;
+//# sourceMappingURL=RecordCards.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RecordCards.d.ts","sourceRoot":"","sources":["../../../src/ui/record/RecordCards.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAmB,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAsBxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAWnD,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,qBAAqB,CAAC;IAC7B;;;;OAIG;IACH,UAAU,CAAC,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC,SAAS,CAAC;IAC/C;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,UAAU,CAAC,CAAC,GAAG,EAAE,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;IAC7C;;;OAGG;IACH,MAAM,CAAC,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IAC9B,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,+DAA+D;IAC/D,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,6DAA6D;IAC7D,aAAa,CAAC,IAAI,IAAI,CAAC;CACxB;AAcD;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,UAAU,EACV,UAAiB,EACjB,UAAU,EACV,MAAM,EACN,UAAU,EACV,gBAAgB,EAChB,WAAmB,EACnB,aAAa,GACd,EAAE,gBAAgB,4BAuKlB"}

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

@@ -0,0 +1,45 @@
+import { ReactNode } from 'react';
+import { RecordRow } from '../../record/index.js';
+import { RecordDetailController, RecordDetailSection } from '../../react/index.js';
+import { RenderFailureHandler } from '../kit/RenderBoundary.js';
+export interface RecordDetailProps {
+    detail: RecordDetailController;
+    /** The row's own commands, as the list offers them, in the panel's header. */
+    actions?(row: RecordRow): ReactNode;
+    /**
+     * The host's own sections for the record open (`RecordDetailSection`),
+     * placed among the engine's field groups. Asked only while a record is in
+     * hand, and each drawn inside a boundary of its own.
+     */
+    sections?(row: RecordRow): readonly RecordDetailSection[];
+    /**
+     * The record read the host's way, in place of the field groups and the
+     * host's sections (`RecordDetailOptions.render`): drawn inside one
+     * boundary, as a section is, while a record is in hand.
+     */
+    render?(row: RecordRow): ReactNode;
+    /** The record's name in the header, in place of its key. */
+    title?(row: RecordRow): string | undefined;
+    /** Told of a host section that threw, as the workbench's other parts are. */
+    onRenderFailure?: RenderFailureHandler;
+}
+/**
+ * One record read whole, beside the list it was opened from (production
+ * review A2).
+ *
+ * It opens at once with what the list had, and fills in as the whole record
+ * comes; every field the definition declares is listed under its group, in
+ * the reading a column would give it — and a long value (an error message, a
+ * stack trace) whole, kept as written, scrollable and copyable. The row's
+ * commands sit in the header, so acting on what was just read does not mean
+ * closing it to find the row again; the panel follows the record after a
+ * command, because the controller reads it again when the view's result
+ * lands.
+ *
+ * Opened by its key alone (a link to a record the page does not hold, G2),
+ * it says that it is reading, then shows the record — or says that the
+ * record is not there, that the reader may not see it, or that it could not
+ * be read, with a way to try again.
+ */
+export declare function RecordDetail({ detail, actions, sections: hostSections, render, title: titleOf, onRenderFailure, }: RecordDetailProps): import('react').JSX.Element;
+//# sourceMappingURL=RecordDetail.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RecordDetail.d.ts","sourceRoot":"","sources":["../../../src/ui/record/RecordDetail.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAKvC,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EACV,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAc9B,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,0BAA0B,CAAC;AASlC,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,8EAA8E;IAC9E,OAAO,CAAC,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,mBAAmB,EAAE,CAAC;IAC1D;;;;OAIG;IACH,MAAM,CAAC,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,CAAC;IACnC,4DAA4D;IAC5D,KAAK,CAAC,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;IAC3C,6EAA6E;IAC7E,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAgBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,EAC3B,MAAM,EACN,OAAO,EACP,QAAQ,EAAE,YAAY,EACtB,MAAM,EACN,KAAK,EAAE,OAAO,EACd,eAAe,GAChB,EAAE,iBAAiB,+BAmLnB"}

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

@@ -0,0 +1,32 @@
+import { RecordTableController } from '../../react/index.js';
+export interface RecordPaginationProps {
+    table: RecordTableController;
+    /**
+     * What the bar offers besides the count (D39): `all`, the default, the
+     * page size and the pages; `pages`, the pages alone — a dashboard's
+     * record panel, whose page size is its view's; `none`, the count alone —
+     * a board read with no controls (a static embed, D36).
+     */
+    controls?: 'all' | 'pages' | 'none';
+    /**
+     * The bar's name as a landmark; 「分页」 by default. A board names each
+     * record panel's after the panel (D39), so the landmarks on one page tell
+     * apart.
+     */
+    label?: string;
+}
+/**
+ * How many rows there are and how to reach the next of them.
+ *
+ * It sits under the result rather than in the toolbar because it is about
+ * the rows, not about the view: paging leaves no trace in a saved config,
+ * and the page a user was on is not part of how they look at records.
+ *
+ * One row, read left to right: how many records there are in all, then — at
+ * the far end, where the hand already is — the page size, which page this is,
+ * and the two steps out of it. The count leads because it is the answer to
+ * the question the conditions above were asked; the controls follow it
+ * because they are only how to see the rest of it.
+ */
+export declare function RecordPagination({ table, controls, label, }: RecordPaginationProps): import('react').JSX.Element | null;
+//# sourceMappingURL=RecordPagination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RecordPagination.d.ts","sourceRoot":"","sources":["../../../src/ui/record/RecordPagination.tsx"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAoBlE,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,qBAAqB,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,CAAC;IACpC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,QAAgB,EAChB,KAAK,GACN,EAAE,qBAAqB,sCAiOvB"}

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

@@ -0,0 +1,118 @@
+import { RecordData, RecordKey } from '../../model/index.js';
+import { RecordColumnView, RecordRow } from '../../record/index.js';
+import { RecordTableController } from '../../react/index.js';
+import { ReleasedPins } from './pinCap.js';
+import { EmptyWayOut } from './emptyWayOut.js';
+import type * as React from 'react';
+export interface RecordTableProps {
+    table: RecordTableController;
+    /**
+     * Renders one cell; the default reads it as the column's `cell` says.
+     * It is handed the raw value and the column as the runtime holds them —
+     * a keyed definition's labels as keys: what it shows, it says (`useSay`,
+     * or `cellValue` given the surface's `useSurfaceDisplay()`, whose `say`
+     * says an option's label).
+     */
+    renderCell?(cell: RecordCell): React.ReactNode;
+    /**
+     * Whether rows can be picked. On by default; a surface that offers nothing
+     * to do with a selection turns it off rather than showing a column of
+     * checkboxes that lead nowhere.
+     */
+    selectable?: boolean;
+    /**
+     * Told whenever the cap (D17-4) lets a pin go or gives it back, so the
+     * column settings can say which pins are not drawn right now: the config
+     * still holds them, and a switch that shows "pinned" over a column with
+     * no edge is a state the screen fails to reflect.
+     */
+    onReleasedPins?(released: ReleasedPins): void;
+    /**
+     * What a host offers on one row, as a pinned last column.
+     *
+     * It takes the row and nothing else: the table knows a result, not a
+     * runtime, and the caller that owns the runtime — a workbench, an embedded
+     * view — is the one that binds it into a `RecordRowActionContext`. Leaving
+     * it out leaves the column out; the output is wrapped in `RowActions`, so
+     * a host hands over buttons rather than a layout.
+     */
+    rowActions?(row: RecordRow): React.ReactNode;
+    /**
+     * Opens a row's detail: a press on the row's own ground, or Enter/Space on
+     * the row the keyboard is on — the rows are one Tab stop with the arrows
+     * inside it (`record/openRows.ts`). Absent, rows are not openable.
+     */
+    onOpen?(row: RecordRow): void;
+    /**
+     * Whether the table is its own scroll area. On by default, which is what a
+     * workbench wants: the rows scroll under a header that stays.
+     *
+     * A surface that scrolls itself — a dashboard panel, a host page that
+     * scrolls as a whole — turns it off and keeps the sticky header, summaries
+     * and pinned columns, which then hold against *its* scrolling. Leaving it
+     * on inside such a surface is what takes the header away: the wrapper
+     * becomes a second scrollport that nothing ever scrolls.
+     */
+    scrolls?: boolean;
+    /**
+     * Whether the table holds its own last column against the right edge
+     * (D13's end). On by default, which is what a workbench wants: the table
+     * is worked, scrolled across, and the end frames the middle passing under
+     * it.
+     *
+     * A surface that is read at rest — a dashboard panel — turns it off. A
+     * column held on the right covers the middle as soon as the table
+     * overflows, before anything has scrolled, and the cap (D17-4) cannot
+     * help: it weighs the held group against half the port, and one column
+     * under half of it is kept however much of its neighbour it covers. On a
+     * workbench that is the frame doing its job; on a panel, read at a glance
+     * and seldom scrolled sideways, it is the neighbour's last characters gone
+     * — 「已重试次数」 read as 「已重试次」 on the home page. The key
+     * and the columns pinned left stay held, since those cover nothing until
+     * the rows are scrolled.
+     */
+    holdEnd?: boolean;
+    /** Overrides the catalogue's own wording for an empty result. */
+    emptyTitle?: string;
+    emptyDescription?: string;
+    /**
+     * Which way out an empty result offers (`emptyWayOut`); `add` when left
+     * out — a table handed rows by hand has no conditions it knows of.
+     */
+    emptyWayOut?: EmptyWayOut;
+    /**
+     * What that way out does. Left out, the empty result offers none — an
+     * embedded view or a dashboard panel has no condition editor of its own to
+     * send anybody to, and a button that leads nowhere is worse than no button.
+     */
+    onEmptyAction?(): void;
+    /**
+     * Whether the headers are only read (off by default): no sort button and
+     * no width handle, each column still a stop for the arrow keys. An
+     * embed's static tier (D22, D36), where the rows are what the page shows
+     * and nothing on it reorders or reshapes them.
+     */
+    readOnly?: boolean;
+    /**
+     * What the table is called, for a reader moving by tables: the view's
+     * title in a workbench or an embed, the panel's on a board, where several
+     * record panels stand side by side and a table named by nothing is one of
+     * several nobody can tell apart. A key is said (`text(key)`).
+     */
+    name?: string;
+}
+export interface RecordCell {
+    column: RecordColumnView;
+    row: RecordData;
+    key: RecordKey;
+    value: unknown;
+}
+/**
+ * The record view as a table.
+ *
+ * Columns and rows come from the last successful result rather than the
+ * draft, because the kernel projected them from the config that ran: what is
+ * on screen always answers a question that was actually asked.
+ */
+export declare function RecordTable({ table, renderCell, selectable, rowActions, onOpen, scrolls, holdEnd, emptyTitle, emptyDescription, emptyWayOut, onEmptyAction, onReleasedPins, readOnly, name, }: RecordTableProps): React.JSX.Element | null;
+//# sourceMappingURL=RecordTable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RecordTable.d.ts","sourceRoot":"","sources":["../../../src/ui/record/RecordTable.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAGpC,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AA6BlE,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAO9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AA0CpD,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,qBAAqB,CAAC;IAC7B;;;;;;OAMG;IACH,UAAU,CAAC,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC,SAAS,CAAC;IAC/C;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,cAAc,CAAC,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9C;;;;;;;;OAQG;IACH,UAAU,CAAC,CAAC,GAAG,EAAE,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;IAC7C;;;;OAIG;IACH,MAAM,CAAC,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IAC9B;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B;;;;OAIG;IACH,aAAa,CAAC,IAAI,IAAI,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,gBAAgB,CAAC;IACzB,GAAG,EAAE,UAAU,CAAC;IAChB,GAAG,EAAE,SAAS,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,UAAU,EACV,UAAiB,EACjB,UAAU,EACV,MAAM,EACN,OAAc,EACd,OAAc,EACd,UAAU,EACV,gBAAgB,EAChB,WAAmB,EACnB,aAAa,EACb,cAAc,EACd,QAAgB,EAChB,IAAI,GACL,EAAE,gBAAgB,4BA6VlB"}

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

@@ -0,0 +1,14 @@
+import type * as React from 'react';
+export interface RowActionsProps {
+    children?: React.ReactNode;
+}
+/**
+ * The wrapper a host's per-row actions land in.
+ *
+ * A table cell and a card footer are very different boxes, and the buttons a
+ * host hands over are its own. This layer is what keeps them looking alike in
+ * both: the same gap, the same edge to align on, and one `data-slot` a test
+ * or a host stylesheet can address.
+ */
+export declare function RowActions({ children }: RowActionsProps): React.JSX.Element;
+//# sourceMappingURL=RowActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RowActions.d.ts","sourceRoot":"","sources":["../../../src/ui/record/RowActions.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,qBASvD"}