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

package/dist/react-router/index.d.ts

@@ -0,0 +1,12 @@
+import { ViewRouter } from '../runtime/routes.js';
+/**
+ * React Router as `ViewHost`'s `router`, inside its `RouterProvider` (or
+ * any router component): where it is, and a way to go — paths relative to
+ * its `basename`, as its own links are.
+ *
+ * ```tsx
+ * <ViewHost engine={engine} router={useReactRouter()} bindings={bindings}>
+ * ```
+ */
+export declare function useReactRouter(): ViewRouter;
+//# sourceMappingURL=index.d.ts.map

package/dist/react-router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react-router/index.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,IAAI,UAAU,CAe3C"}

package/dist/react-router.js

@@ -0,0 +1,27 @@
+import { c as e } from "react/compiler-runtime";
+import { useLocation as t, useNavigate as n } from "react-router";
+//#region src/react-router/index.ts
+function r() {
+	let r = e(9), { pathname: i, search: a, state: o } = t(), s = n(), c;
+	r[0] !== i || r[1] !== a || r[2] !== o ? (c = {
+		pathname: i,
+		search: a,
+		state: o
+	}, r[0] = i, r[1] = a, r[2] = o, r[3] = c) : c = r[3];
+	let l;
+	r[4] === s ? l = r[5] : (l = (e, t) => {
+		s(e, {
+			state: t?.state,
+			replace: t?.replace
+		});
+	}, r[4] = s, r[5] = l);
+	let u;
+	return r[6] !== c || r[7] !== l ? (u = {
+		location: c,
+		go: l
+	}, r[6] = c, r[7] = l, r[8] = u) : u = r[8], u;
+}
+//#endregion
+export { r as useReactRouter };
+
+//# sourceMappingURL=react-router.js.map

package/dist/react-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-router.js","names":["useMemo","useLocation","useNavigate","ViewRouter","useReactRouter","$","_c","pathname","search","state","navigate","t0","t1","path","options","replace","t2","location","go","_c","useReactRouter","$","c","useLocation","navigate","useNavigate","t0","pathname","search","state","t1","path","options","t2"],"sources":["../src/react-router/index.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * `@ahoo-wang/wow-view-engine/react-router`: the router port's adapter for\n * React Router (host-integration.md 4.2), the one the package ships —\n * React Router is an optional peer only this entry loads. A host on\n * another router writes the port's two members itself (`ViewRouter`).\n */\n\nimport { useMemo } from 'react';\nimport { useLocation, useNavigate } from 'react-router';\nimport type { ViewRouter } from '../runtime/routes.js';\n\n/**\n * React Router as `ViewHost`'s `router`, inside its `RouterProvider` (or\n * any router component): where it is, and a way to go — paths relative to\n * its `basename`, as its own links are.\n *\n * ```tsx\n * <ViewHost engine={engine} router={useReactRouter()} bindings={bindings}>\n * ```\n */\nexport function useReactRouter(): ViewRouter {\n  const { pathname, search, state } = useLocation();\n  const navigate = useNavigate();\n  return useMemo(\n    () => ({\n      location: { pathname, search, state },\n      go: (path, options) => {\n        void navigate(path, {\n          state: options?.state,\n          replace: options?.replace,\n        });\n      },\n    }),\n    [pathname, search, state, navigate],\n  );\n}\n"],"mappings":";;;AAiCA,SAAOI,IAAA;CAAA,IAAAC,IAAAC,EAAA,CAAA,GACL,EAAAC,aAAAC,WAAAC,aAAoCR,EAAY,GAChDS,IAAiBR,EAAY,GAAES;CAAA,AAAAN,EAAA,OAAAE,KAAAF,EAAA,OAAAG,KAAAH,EAAA,OAAAI,KAGjBE,IAAA;EAAAJ;EAAAC;EAAAC;CAA0B,GAACJ,EAAA,KAAAE,GAAAF,EAAA,KAAAG,GAAAH,EAAA,KAAAI,GAAAJ,EAAA,KAAAM,KAAAA,IAAAN,EAAA;CAAA,IAAAO;CAAA,AAAAP,EAAA,OAAAK,IAMpCE,IAAAP,EAAA,MALGO,KAAAC,GAAAC,MAAA;EACGJ,EAASG,GAAM;GAAAJ,OACXK,GAAOL;GAAOM,SACZD,GAAOC;EAClB,CAAC;CAAC,GACHV,EAAA,KAAAK,GAAAL,EAAA,KAAAO;CAAA,IAAAI;CACF,OADEX,EAAA,OAAAM,KAAAN,EAAA,OAAAO,KAPII,IAAA;EAAAC,UACKN;EAA2BO,IACjCN;CAMN,GAACP,EAAA,KAAAM,GAAAN,EAAA,KAAAO,GAAAP,EAAA,KAAAW,KAAAA,IAAAX,EAAA,IARMW;AAQN"}

package/dist/react.js

@@ -0,0 +1,3 @@
+import { u as e } from "./viewRuntimeTypes-yK2rlUjK.js";
+import { A as t, C as n, D as r, E as i, F as a, L as o, M as s, N as c, O as l, P as u, R as d, S as f, T as p, _ as m, a as h, b as g, c as _, d as v, f as y, h as b, i as x, j as S, k as C, n as w, o as T, p as E, r as D, s as O, t as k, u as A, v as j, w as M, x as N, z as P } from "./react-DzstAsWB.js";
+export { v as VALUE_CANDIDATE_DEBOUNCE_MS, d as browserRuntimeEnvironment, P as documentVisibility, r as failureReasons, o as kindMismatch, N as ownedNavigation, s as retryableOpen, e as toIssue, S as useAnalysisEditor, t as useAnalysisResult, l as useAutoRefresh, n as useDashboard, g as useFilterEditor, w as useHandOver, D as useHandedConditions, x as useHandedRemoval, O as useInstanceSync, T as useLeaveGuard, c as useOpenView, f as usePanelFollowUps, i as useRecordActions, j as useRecordDetail, m as useRecordExport, b as useRecordTable, C as useRefreshCountdown, h as useReleaseDeleted, E as useSaveCommands, p as useSearchBox, M as useUnavailable, y as useValueCandidates, u as useViewEngine, A as useViewList, _ as useViewManager, a as useViewRuntime, k as useWorkbench };

package/dist/record/compile.d.ts

@@ -0,0 +1,56 @@
+import { AggregationQuery, CursorQuery, FilterPagedQuery, Projection } from '@ahoo-wang/wow-client';
+import { DataViewDefinition, RecordPageTarget, RecordViewConfig, SummaryFunction } from '../model/index.js';
+import { FieldKindRegistry, FilterCompileContext } from '../filter/index.js';
+/** The first page of either paging mode; Wow numbers pages from 1. */
+export declare const FIRST_PAGE: Readonly<Record<'paged' | 'cursor', RecordPageTarget>>;
+/**
+ * The fields a page of this view asks its source for: what the view shows,
+ * and what reads a row besides.
+ *
+ * A Wow snapshot is the whole document, and a document can carry far more
+ * than anyone looks at — a failed execution holds its stack trace, several
+ * KB of it, on every row. Against the compensation service a page of 100
+ * failed executions measured 808 KB and 2.9 s asked for whole, and 46 KB and
+ * 1.6 s asked for what its view shows. So a page names its fields:
+ *
+ * - the row key, which is what a row *is* — selection, the row's React key
+ *   and every action read it;
+ * - the table's visible columns, and the card's title, image and body when
+ *   the definition offers cards. Both layouts, whichever is current: table
+ *   or cards is a presentation member (`RECORD_PRESENTATION_MEMBERS`), so
+ *   switching draws the same rows from the same query at once, and a card
+ *   switched to must not come up blank waiting for a second one;
+ * - the sort, so a source that works the next cursor out of the last row
+ *   finds its values there — Wow's own backend adds them itself, but
+ *   `ViewSource` is a port anyone implements;
+ * - every summary but `COUNT`: the page scope is the rows on screen added
+ *   up (`pageSummaries`), and it is also what the row falls back to when
+ *   the totals' own aggregation fails. `COUNT` counts rows and reads none;
+ * - `RecordCapability.rowFields`: what the host's own code reads off a row
+ *   — a row or bulk action, a custom cell — that the view need not show.
+ *
+ * A hidden column is not drawn and not exported, so it is not fetched
+ * either: switching it back on edits the config and applies it, and the
+ * query that brings the column also brings its values.
+ *
+ * Only paths the definition declares are asked for — the config comes from
+ * a store — and a field-less kind's name is a handle, not a path, so it is
+ * left out; the row key is always a path. A path under another one asked
+ * for is dropped: the ancestor brings it, and MongoDB refuses the two
+ * together as a path collision.
+ */
+export declare function recordProjection(definition: DataViewDefinition, config: RecordViewConfig): Projection;
+/**
+ * Compiles the applied config into the query its source understands. Which of
+ * the two it is comes from the definition, not from the config: paging is a
+ * property of the backing query API.
+ */
+export declare function compileRecord(definition: DataViewDefinition, config: RecordViewConfig, kinds: FieldKindRegistry, context: FilterCompileContext, page: RecordPageTarget): FilterPagedQuery | CursorQuery;
+/** Alias of one summary cell; the projection reads the result back by it. */
+export declare function summaryAlias(field: string, fn: SummaryFunction): string;
+/**
+ * Totals over the whole filtered range, as one ungrouped aggregation. Page
+ * totals need no query: they are computed from the rows already on screen.
+ */
+export declare function compileSummaries(definition: DataViewDefinition, config: RecordViewConfig, kinds: FieldKindRegistry, context: FilterCompileContext): AggregationQuery | null;
+//# sourceMappingURL=compile.d.ts.map

package/dist/record/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/record/compile.ts"],"names":[],"mappings":"AAaA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAEhB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAChB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAKL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAE5B,sEAAsE;AACtE,eAAO,MAAM,UAAU,EAAE,QAAQ,CAC/B,MAAM,CAAC,OAAO,GAAG,QAAQ,EAAE,gBAAgB,CAAC,CAI5C,CAAC;AA6BH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,gBAAgB,GACvB,UAAU,CAoEZ;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,iBAAiB,EACxB,OAAO,EAAE,oBAAoB,EAC7B,IAAI,EAAE,gBAAgB,GACrB,gBAAgB,GAAG,WAAW,CA0ChC;AAYD,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,eAAe,GAAG,MAAM,CAGvE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,iBAAiB,EACxB,OAAO,EAAE,oBAAoB,GAC5B,gBAAgB,GAAG,IAAI,CA4BzB"}

package/dist/record/defaults.d.ts

@@ -0,0 +1,9 @@
+import { DataViewDefinition, RecordCapability, RecordViewConfig, RuntimeLimits, ViewDefinition } from '../model/index.js';
+export declare function recordCapabilityOf(definition: ViewDefinition): RecordCapability | undefined;
+/**
+ * A complete starting config, because `create` takes a config rather than
+ * inventing one: a definition that `validateDefinition` accepted always has a
+ * layout and a row key to build from.
+ */
+export declare function defaultRecordConfig(definition: DataViewDefinition, limits?: RuntimeLimits): RecordViewConfig;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/record/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/record/defaults.ts"],"names":[],"mappings":"AAaA,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,cAAc,EAEpB,MAAM,mBAAmB,CAAC;AAG3B,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,cAAc,GACzB,gBAAgB,GAAG,SAAS,CAE9B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,kBAAkB,EAC9B,MAAM,GAAE,aAAsC,GAC7C,gBAAgB,CA8ClB"}

package/dist/record/detail.d.ts

@@ -0,0 +1,27 @@
+import { DataViewDefinition } from '../model/index.js';
+import { RecordCardField } from './project.js';
+/** One titled part of a record's detail: the fields a group gathers. */
+export interface DetailSection {
+    /** The field group's id, or `null` for the fields no group gathers. */
+    id: string | null;
+    /** The group's label; `null` where the fields gathered no group. */
+    label: string | null;
+    /**
+     * Its fields, resolved the way a card's are — a detail is a card that
+     * holds every field — so a value reads there as it does on the card.
+     */
+    fields: RecordCardField[];
+}
+/**
+ * How a record's detail is laid out: every field the definition declares,
+ * under the groups it declares, in their order — the order the field
+ * pickers list them in, so the detail reads like the author arranged the
+ * record — and the fields no group gathers after them, in declaration
+ * order. A field is listed once, under the first group that names it.
+ *
+ * Only fields that are a **value on the record** are listed: a fieldless
+ * kind — full-text search, the deletion switch, the metadata handles — is a
+ * way to filter, and has no value to show.
+ */
+export declare function detailSections(definition: Pick<DataViewDefinition, 'fields' | 'fieldGroups'>): DetailSection[];
+//# sourceMappingURL=detail.d.ts.map

package/dist/record/detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detail.d.ts","sourceRoot":"","sources":["../../src/record/detail.ts"],"names":[],"mappings":"AAaA,OAAO,EAAmB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAa,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/D,wEAAwE;AACxE,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,oEAAoE;IACpE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB;;;OAGG;IACH,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,IAAI,CAAC,kBAAkB,EAAE,QAAQ,GAAG,aAAa,CAAC,GAC7D,aAAa,EAAE,CAqBjB"}

package/dist/record/export.d.ts

@@ -0,0 +1,78 @@
+import { RecordData } from '../model/index.js';
+/** The least an export needs of a column: where to read it, what to call it. */
+export interface ExportColumn {
+    /** A Wow query path, read the way a cell reads it. */
+    field: string;
+    /** What the header row calls this column. */
+    label: string;
+}
+/**
+ * How one value is written.
+ *
+ * It is injected rather than decided here, because how a value *reads* is the
+ * UI's answer — an enum by its label, a time in the surface's zone, a number
+ * in its field's format — and this layer has no catalogue, no locale and no
+ * renderers. The column rides along with the value, so one formatter serves
+ * every column of the table.
+ */
+export type ExportFormat<C extends ExportColumn = ExportColumn> = (value: unknown, column: C) => string;
+/**
+ * The byte order mark Excel needs to read a UTF-8 CSV as UTF-8.
+ *
+ * Without it Excel on Windows reads the file in the machine's ANSI code page
+ * and every Chinese name in it arrives as mojibake — which is most of what
+ * these exports carry.
+ */
+export declare const CSV_BOM = "\uFEFF";
+/** How a CSV is written. */
+export interface CsvOptions {
+    /**
+     * Whether a cell a spreadsheet could evaluate is written with an
+     * apostrophe in front, so it opens as the text it is. On unless set to
+     * `false`.
+     *
+     * A file leaves the page: it is opened in Excel, often by someone other
+     * than whoever exported it, and a value somebody typed into a text field
+     * — `=HYPERLINK(…)`, `=cmd|' /C calc'!A0` — would run there as a formula
+     * (OWASP, CSV Injection). So every cell whose text starts with `=`, `+`,
+     * `-`, `@`, a tab or a carriage return gets a leading `'`, the header's
+     * labels included, since a definition names them.
+     *
+     * Two kinds of cell are left alone, because a spreadsheet reads them as a
+     * number and never as a formula: one whose value was a number (a negative
+     * amount, however its field formats it — `-1,204.50`, `-$12.00`), and one
+     * whose text is a plain number (`-12.5` held by a text field). Prefixing
+     * either would only make the file differ from the screen.
+     *
+     * Turn it off only where the file never reaches a spreadsheet — a
+     * pipeline that reads the CSV back as data and wants the text as stored.
+     */
+    neutralizeFormulas?: boolean;
+}
+/** One cell of a file: the value it was read from, and the text it reads as. */
+export interface CsvCell {
+    /** What the row held; only its type is looked at: a number is never a formula. */
+    value: unknown;
+    /** The text written, before any escaping. */
+    text: string;
+}
+/**
+ * The rows as a CSV, RFC 4180 with a BOM in front.
+ *
+ * The header is the labels of the columns handed over, in the order they are
+ * handed over — which is the projected order of the visible columns, so the
+ * file carries the table's columns rather than the definition's fields.
+ *
+ * Nothing here looks at what a value *means*: `format` has already decided
+ * that, and what is left is writing it (`writeCsv`) — the escaping, and the
+ * formulas neutralized unless `options` says otherwise (`CsvOptions`).
+ */
+export declare function serializeCsv<C extends ExportColumn>(rows: readonly RecordData[], columns: readonly C[], format: ExportFormat<C>, options?: CsvOptions): string;
+/**
+ * Cells already read, as a CSV: the one writer every export goes through —
+ * a record view's rows (`serializeCsv`) and an analysis's groups alike — so
+ * the escaping and the formula rule (`CsvOptions.neutralizeFormulas`) are
+ * one rule rather than one per export.
+ */
+export declare function writeCsv(header: readonly string[], rows: readonly (readonly CsvCell[])[], options?: CsvOptions): string;
+//# sourceMappingURL=export.d.ts.map

package/dist/record/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../src/record/export.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,gFAAgF;AAChF,MAAM,WAAW,YAAY;IAC3B,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,IAAI,CAChE,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,CAAC,KACN,MAAM,CAAC;AAEZ;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,WAAM,CAAC;AAuB3B,4BAA4B;AAC5B,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,gFAAgF;AAChF,MAAM,WAAW,OAAO;IACtB,kFAAkF;IAClF,KAAK,EAAE,OAAO,CAAC;IACf,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,YAAY,EACjD,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,OAAO,GAAE,UAAe,GACvB,MAAM,CAWR;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,IAAI,EAAE,SAAS,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,EACrC,OAAO,GAAE,UAAe,GACvB,MAAM,CAMR"}

package/dist/record/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The record kernel: a definition and a config in, a Wow query or a rendered
+ * view out. Pure functions with no React, DOM, network or clock of their own.
+ */
+export * from './compile.js';
+export * from './defaults.js';
+export * from './detail.js';
+export { CSV_BOM, serializeCsv, type CsvOptions, type ExportColumn, type ExportFormat, } from './export.js';
+export * from './paging.js';
+export * from './project.js';
+export * from './validate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/record/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/record/index.ts"],"names":[],"mappings":"AAaA;;;GAGG;AACH,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,OAAO,EACL,OAAO,EACP,YAAY,EACZ,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,aAAa,CAAC;AACrB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC"}

package/dist/record/paging.d.ts

@@ -0,0 +1,89 @@
+import { RecordCapability, RuntimeLimits } from '../model/index.js';
+/**
+ * Where a paged result stands, as the pager reads it: every number the bar
+ * shows and every step it offers, worked out once from what **ran**.
+ *
+ * The size is the executed config's and never the draft's. While a new page
+ * size is still on its way the rows on screen, their page number and the
+ * total all belong to the old one, and a page count divided by the new one
+ * describes a result nobody has seen.
+ */
+export interface PagedPaging {
+    mode: 'paged';
+    /** The page the rows came from, counted from 1. */
+    index: number;
+    /** The page size the rows were fetched at. */
+    size: number;
+    /** Every row the conditions match, when the source says. */
+    total?: number;
+    /**
+     * The pages the pager can reach: all of them, or only those inside the
+     * source's window (`pageWindow`). Absent when the source
+     * reported no total, since then there is nothing to count them from.
+     */
+    pages?: number;
+    /** Whether a page after this one can be asked for at all. */
+    hasNext: boolean;
+    /**
+     * The rows the reachable pages hold — present only when that is fewer than
+     * the total, because the source's window stops the pager short of it.
+     */
+    reachable?: number;
+}
+/** A cursor result: the one way on, when there is one. */
+export interface CursorPaging {
+    mode: 'cursor';
+    nextCursor: string | null;
+    hasNext: boolean;
+}
+export type RecordPaging = PagedPaging | CursorPaging;
+/**
+ * The window a paged source serves: the definition's own `maxWindow` where
+ * it declares one below the runtime's `maxPageWindow`, which is what a Wow
+ * server's HTTP guard admits at its defaults (D42). `undefined` for a cursor
+ * source, which has a position rather than a window, and when neither
+ * bounds it — a host that lifted the runtime's to infinity.
+ */
+export declare function pageWindow(capability: Partial<Pick<RecordCapability, 'maxWindow' | 'paging'>> | undefined, limits: Partial<Pick<RuntimeLimits, 'maxPageWindow'>>): number | undefined;
+/**
+ * The last page a source with this window serves at this size: the page `p`
+ * with `p × size` still inside it. Never below 1 — the first page is asked
+ * for whatever the window says, and a source that refuses it says so as a
+ * failed query rather than as a pager with no pages.
+ *
+ * `undefined` when there is no window, or no size to divide it by.
+ */
+export declare function lastPageInWindow(size: number, maxWindow?: number): number | undefined;
+/**
+ * The paging facts of one paged result.
+ *
+ * A page is reachable when `index × size` stays inside the window, which is
+ * why the count is `⌊window / size⌋` rather than `⌈window / size⌉`: at 30 a
+ * page, a 10 000-row window serves 333 full pages, and page 334 would reach
+ * row 10 020. So a total the window does cover can still lose its last page
+ * to it, and `reachable` says so whenever the pages stop short of the total,
+ * not only when the total is larger than the window.
+ */
+export declare function pagedPaging(facts: {
+    index: number;
+    size: number;
+    total?: number;
+    maxWindow?: number;
+}): PagedPaging;
+/** The cursor result's facts: there is a next page when there is a cursor. */
+export declare function cursorPaging(nextCursor: string | null): CursorPaging;
+/**
+ * A page the pager may ask for: at least 1, and no later than the last it
+ * can reach — past the end, the reader wants the end. Where the pages are
+ * not counted there is no end to hold it to.
+ */
+export declare function clampPage(paging: PagedPaging, index: number): number;
+/**
+ * Where a page that came back empty belongs instead: the last page there
+ * now is, when the rows it counted left the result under it — a refresh
+ * after a command took rows out, on the last page of a shrinking result.
+ * `null` when the page is where the reader belongs: it holds rows, it is
+ * the first, or the pages are not counted.
+ */
+export declare function pageAfterShrink(paging: RecordPaging, index: number, rows: number): number | null;
+//# sourceMappingURL=paging.d.ts.map

package/dist/record/paging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paging.d.ts","sourceRoot":"","sources":["../../src/record/paging.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEzE;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,OAAO,CAAC;IACd,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,0DAA0D;AAC1D,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,YAAY,CAAC;AAEtD;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,UAAU,EACR,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,WAAW,GAAG,QAAQ,CAAC,CAAC,GAAG,SAAS,EACrE,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC,GACpD,MAAM,GAAG,SAAS,CAOpB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,GAAG,SAAS,CAGpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,WAAW,CA0Bd;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,YAAY,CAEpE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,IAAI,CAKf"}

package/dist/record/path.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The value at a dot path in a row, or `undefined` where the path leads
+ * nowhere: through `null` or `undefined`, through a primitive, or into an
+ * array by anything but a non-negative integer index.
+ *
+ * `'state.id'` reads `row.state.id`; `'items.0.sku'` reads the first item's
+ * sku. An empty path reads the row itself. It never throws.
+ *
+ * It was `getPropertyValue` of `@ahoo-wang/wow-client`, which kept it only
+ * for this package; a path read belongs with the kernel that reads rows.
+ */
+export declare function readPath(row: unknown, path: string): unknown;
+//# sourceMappingURL=path.d.ts.map

package/dist/record/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/record/path.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAc5D"}

package/dist/record/project.d.ts

@@ -0,0 +1,245 @@
+import { CursorPage, PagedList } from '@ahoo-wang/wow-client';
+import { CurrencyReading, DataViewDefinition, FieldDefinition, FieldNumeric, FieldOption, NumberFormat, RecordData, RecordKey, RecordViewConfig, RuntimeLimits, SummaryFunction, EpochTimeUnit } from '../model/index.js';
+import { RecordPaging } from './paging.js';
+/**
+ * Which edge the table holds a column against.
+ *
+ * It is the layout's answer and never the config's: a user pins a column to
+ * the left or not at all (D19), and the right edge belongs to the table's
+ * own frame — the column drawn last, or the host's action column where
+ * there is one, which the projection cannot see (`ui/record/columns.ts`).
+ */
+export type ColumnEdge = 'left' | 'right';
+/** A column as the table should render it, with its semantics resolved. */
+export interface RecordColumnView {
+    field: string;
+    label: string;
+    kind: string;
+    /** Renderer key; the kind's default when the field names none. */
+    cell: string;
+    width?: number;
+    /**
+     * Which edge holds this column, when one does. `'right'` is the column
+     * the layout holds because it is drawn **last** (D13) and never a pin the
+     * config asked for — a host that puts a row-action column after it takes
+     * that place, and the table lets this one go (`ui/record/columns.ts`).
+     */
+    pinned?: ColumnEdge;
+    /**
+     * True on the definition's row key: the column that says which record a
+     * row is, which is why it leads the left area and is pinned there
+     * whatever the config asks.
+     *
+     * It is on the projected column rather than left to the renderer to work
+     * out, because the renderer holds a result and not a definition. The pin
+     * cap is the one that has to know (D17-4): every other pin can be let go
+     * on a narrow screen, and this one cannot.
+     */
+    primary?: true;
+    sortable: boolean;
+    numberFormat?: NumberFormat;
+    /**
+     * What the number is by the source's semantics (`FieldNumeric`), where
+     * that — and not the author's `numberFormat` — decides how it reads: a
+     * file then holds the number itself, and money its currency beside it.
+     */
+    numeric?: FieldNumeric;
+    /**
+     * For money whose currency each record holds: where the row holds it
+     * (`currencyPathOf`), so the value reads in its own currency.
+     */
+    currencyPath?: string;
+    /** An enum's choices, so a cell can show a value by its label. */
+    options?: readonly FieldOption[];
+    /** For an array of objects, what each element is read by. */
+    elementTitle?: ElementTitleView;
+    /** A time kept in epoch seconds; milliseconds when unsaid. */
+    timeUnit?: EpochTimeUnit;
+    /**
+     * How finely the cell writes a time of day, where the field asks for its
+     * seconds (`FieldDefinition.timePrecision`); to the minute when unsaid.
+     */
+    timePrecision?: 'second';
+}
+/**
+ * The element field an array of objects is read by, one element at a time
+ * (`FieldDefinition.elementTitle`), resolved to what reading it takes: where
+ * it sits within an element, and how it reads.
+ *
+ * It rides on the column rather than being looked up by the renderer because
+ * the renderer holds a result and not a definition — the same reason the
+ * column carries its options.
+ */
+export interface ElementTitleView {
+    /** Its name within one element, e.g. `name` in `body[].name`. */
+    name: string;
+    kind: string;
+    /** Renderer key; the kind's default when the field names none. */
+    cell: string;
+    options?: readonly FieldOption[];
+    numberFormat?: NumberFormat;
+    /**
+     * For money whose currency each record holds: where the row holds it
+     * (`currencyPathOf`), so the value reads in its own currency.
+     */
+    currencyPath?: string;
+}
+export interface RecordRow {
+    /** Value of the definition's row key. */
+    key: RecordKey;
+    data: RecordData;
+}
+/**
+ * One field of a card. It carries what a column carries about how a value
+ * reads — a card is a row folded out, and `RecordCards` hands a host's
+ * `renderCell` the same `column` for a value on a card as the table does
+ * for the same value — with the parts a card never has (pinning, width,
+ * sorting) left out. `kind` and `cell` are optional for a controller built
+ * by hand; the projection always names them.
+ */
+export interface RecordCardField {
+    field: string;
+    label: string;
+    kind?: string;
+    cell?: string;
+    options?: readonly FieldOption[];
+    numberFormat?: NumberFormat;
+    /**
+     * For money whose currency each record holds: where the row holds it
+     * (`currencyPathOf`), so the value reads in its own currency.
+     */
+    currencyPath?: string;
+    /** For an array of objects, what each element is read by. */
+    elementTitle?: ElementTitleView;
+    /** A time kept in epoch seconds; milliseconds when unsaid. */
+    timeUnit?: EpochTimeUnit;
+    /**
+     * For an array of objects that declares its elements: each element field
+     * that holds a value, read the way this one is, `field` being its name
+     * within one element. Only the record detail lays an element out field by
+     * field; a cell and a card read an element by its title.
+     */
+    elements?: RecordCardField[];
+}
+/**
+ * The card layout of the result, resolved against the definition.
+ *
+ * A card is not a narrow table: the saved config says which field titles it,
+ * which fields make up its body and where its image comes from, and none of
+ * that is derivable from the table's columns.
+ */
+export interface RecordCardView {
+    /** Field whose value titles each card; the row key when it holds none. */
+    title: string;
+    /** How the title's values show, when the definition still has the field. */
+    titleField?: RecordCardField;
+    /** Fields of the card body, in order, with their labels resolved. */
+    fields: RecordCardField[];
+    /** Field holding an image URL, when the config asks for one. */
+    image?: string;
+    /** How many cards stand in one row; see `RecordCardSpec.perRow`. */
+    perRow?: 1 | 2 | 3 | 4;
+}
+export interface RecordProjection {
+    columns: RecordColumnView[];
+    /** The same result's card layout; both halves are saved side by side. */
+    card: RecordCardView;
+    rows: RecordRow[];
+    paging: RecordPaging;
+}
+/**
+ * A declared field as a value of it reads outside a table — on a card, and
+ * in the detail of one record (`detailSections`), which is a card holding
+ * every field.
+ */
+export declare function cardField(field: FieldDefinition): RecordCardField;
+/**
+ * The same rows drawn under another config that asks the source the same
+ * question: a column wider, moved or pinned (`restyledOnly` in the runtime
+ * decides that it is only that). The rows and the paging stay the ones that
+ * landed; the columns and the card are projected again, so a presentation
+ * edit is on screen without a round trip to the source.
+ */
+export declare function restyleRecord(definition: DataViewDefinition, config: RecordViewConfig, view: RecordProjection): RecordProjection;
+/**
+ * Turns a page of rows into what a table or a card list renders. Both paging
+ * modes arrive here, and the mode stays visible in the result so the UI knows
+ * whether it has a page number or a cursor to move on with.
+ */
+export declare function projectRecord(definition: DataViewDefinition, config: RecordViewConfig, page: PagedList<RecordData> | CursorPage<RecordData>, pageIndex?: number, limits?: Pick<RuntimeLimits, 'maxPageWindow'>): RecordProjection;
+export interface SummaryCell {
+    field: string;
+    label: string;
+    fn: SummaryFunction;
+    /** `null` when the source returned nothing for this cell. */
+    value: number | string | null;
+    numberFormat?: NumberFormat;
+    /**
+     * For money whose currency each record holds: where a row holds it, so
+     * the page's own total is read off the rows (`pageSummaries`).
+     */
+    currencyPath?: string;
+    /**
+     * For such money, the currency the total is in — or that it is in
+     * several, when the value is no amount and is `null` (`CurrencyReading`).
+     * Absent where it could not be told.
+     */
+    currency?: CurrencyReading;
+    /** The epoch unit of the moment it holds, with `cell`; see `epochUnitOf`. */
+    timeUnit?: EpochTimeUnit;
+    /**
+     * How the value reads, when the column does not read it as a number: the
+     * renderer key of the column it stands under.
+     *
+     * Set on the earliest and the latest of a column of moments, which are two
+     * of that column's own cells rather than numbers about it — so the footer
+     * formats them the way the column formats that cell, in the surface's
+     * language and zone, and a day written `2026-09-18` is not shown as the
+     * 17th somewhere else. `COUNT` over the same column is a number of rows
+     * like any other and names no reading; the maths is refused there by
+     * admission. So a cell that names no reading is a number.
+     */
+    cell?: string;
+}
+export interface SummaryRow {
+    /** `page` is computed from the visible rows; `total` from its own query. */
+    scope: 'page' | 'total';
+    cells: SummaryCell[];
+}
+/** Where the numbers come from; a page total never needs a round trip. */
+export type SummarySource = {
+    scope: 'page';
+    rows: readonly RecordData[];
+} | {
+    scope: 'total';
+    result: readonly RecordData[];
+};
+/**
+ * The value of `field` in a record. A field is a Wow query path, so
+ * `state.status` is a value inside `state` rather than a key named with a dot:
+ * a Wow snapshot keeps everything it materialises under `state`.
+ *
+ * A `null` the record holds comes back as `null`; only a path that is not
+ * there is `undefined`. A cell renderer may tell the two apart, and
+ * `readPath` would turn the first into the second.
+ */
+export declare function recordValue(data: RecordData, field: string): unknown;
+/**
+ * Page summaries are derived from the rows on screen; range summaries are read
+ * back from the aggregation by alias. Mixing the two would misreport AVG, so
+ * the scope stays part of the result.
+ */
+export declare function projectSummaries(definition: DataViewDefinition, config: RecordViewConfig, source: SummarySource): SummaryRow;
+/**
+ * The same cells read over the rows on screen.
+ *
+ * A table shows both scopes at once — this page beside everything the
+ * conditions match — and only the second one costs a query. The first is the
+ * visible rows added up, so it is derived from the cells the executed config
+ * already named rather than from the config itself, which a renderer holding
+ * a result does not have. Reducing the rows a second time is the same
+ * arithmetic `projectSummaries` does for a `page` source, kept here with it
+ * so the two scopes can never drift apart.
+ */
+export declare function pageSummaries(cells: readonly SummaryCell[], rows: readonly RecordRow[]): SummaryRow;
+//# sourceMappingURL=project.d.ts.map

package/dist/record/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/record/project.ts"],"names":[],"mappings":"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"}