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

package/dist/ui/DataWorkbench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataWorkbench.d.ts","sourceRoot":"","sources":["../../src/ui/DataWorkbench.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,kBAAkB,EAClB,WAAW,EACX,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,UAAU,EACV,YAAY,EACZ,cAAc,EACf,MAAM,qBAAqB,CAAC;AAY7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAc,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAExE,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE/E,yFAAyF;AACzF,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEjD,MAAM,WAAW,kBAAkB;IACjC,kDAAkD;IAClD,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACpC;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;;;OAKG;IACH,gBAAgB,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IAC3C;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAC/B;;;;;OAKG;IACH,UAAU,CAAC,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC;;;;;;OAMG;IACH,SAAS,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,gBAAgB,CAAC;QAAC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;KAAE,CAAC;IACzE,2EAA2E;IAC3E,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,qEAAqE;IACrE,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB;;;OAGG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IACpC,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,GAAG,SAAS,CAAC;IACvD;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,6EAA6E;IAC7E,mBAAmB,CAAC,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1C;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B;;;;OAIG;IACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;IACvC;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B;AA2BD;;;;;;;;;;;GAWG;AACH;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,+BAMtD"}

package/dist/ui/EmbeddedDashboard.d.ts

@@ -0,0 +1,103 @@
+import { ReactNode } from 'react';
+import { DashboardFilters } from '../model/index.js';
+import { DashboardFilterMode } from './dashboard/filterModes.js';
+import { EmbedBaseProps, EmbedInteraction } from './embed/options.js';
+export type { BoardFilterModes, DashboardFilterMode, } from './dashboard/filterModes.js';
+export interface EmbeddedDashboardProps extends EmbedBaseProps {
+    /**
+     * How far the reader may go (`EmbedInteraction`): `static` by default —
+     * the board as its author laid it out, its filters read as what they
+     * hold, nothing on it answering a press; `interactive` lets the reader
+     * change the filters and adds the follow-up menu, cross-filtering and
+     * 在工作台中打开, for this viewing only. Neither builds nor saves the board
+     * (D36): a page whose readers build boards embeds `DashboardWorkbench`.
+     */
+    interaction?: EmbedInteraction;
+    /** Whether the panels' titles are drawn (on by default). */
+    withPanelTitles?: boolean;
+    /**
+     * 「导出数据…」 in a panel's 「⋯」 — the export window over its rows (D14),
+     * as `EmbeddedView`'s `withExport` is for one view (off by default). The
+     * tier is the ceiling and the switch opts in within it (D36, amending D24
+     * Q24): it has no effect in the static tier.
+     */
+    withExport?: boolean;
+    /**
+     * How each of the board's filters is offered, by name
+     * (`DashboardFilterMode`): `adjustable` — on the bar, the reader's — unless
+     * named here; `locked` — on the bar as what it holds, fixed; `hidden` —
+     * not on the bar, still narrowing what it is wired to. A locked or hidden
+     * filter holds what `pageValues` gives it, or its default, whatever the
+     * reader does. In the static tier the reader changes none of them: an
+     * adjustable one reads as what it holds, as a locked one does. Not a
+     * security boundary: see the README's embedding section.
+     */
+    filterModes?: Readonly<Record<string, DashboardFilterMode>>;
+    /** The time grouping's mode, likewise; `adjustable` when left out. */
+    groupingMode?: DashboardFilterMode;
+    /**
+     * What the page holds (D22): the value of each locked or hidden filter —
+     * its default where this names none — and, with `groupingMode` locked or
+     * hidden, the time grouping's unit. In force from the first query, and
+     * followed as it changes: a customer page moving to the next customer. It
+     * is the page's own, never the address's — a reader can edit an address.
+     * An entry for an adjustable filter is ignored. What the board refuses of
+     * it is said above the board, as a refused narrowing is.
+     */
+    pageValues?: DashboardFilters | null;
+    /**
+     * What the reader's filters open at, as the host's address has them (D22
+     * F), read as the board opens — as `DashboardWorkbench` reads it: when it
+     * names any of them it is the whole of what they hold; when it names none
+     * they start at their defaults. An entry for a locked or hidden filter is
+     * ignored: `pageValues` holds those.
+     */
+    initialFilters?: DashboardFilters | null;
+    /**
+     * Told what the reader's filters hold whenever that changes — the board
+     * opening included — so a host can write them into its address. Only the
+     * adjustable filters, and the time grouping unless the page holds it: a
+     * locked or hidden value is the page's, and written into an address it
+     * would come back as the reader's. The package never touches the address.
+     */
+    onFiltersChange?(filters: DashboardFilters): void;
+    /** The tab the board opens on, as the host's route has it (D22 E). */
+    initialTab?: string | null;
+    /** Told which tab is on screen whenever that changes, opening included. */
+    onTabChange?(tabId: string | null): void;
+    /**
+     * 「更新于 10:32」 in the first row — when the panels on screen were read,
+     * the earliest of them — and, in the interactive tier, the refresh button
+     * beside it (off by default: a row of chrome nobody asked for is what an
+     * embed exists not to add, D10). The button runs the board's refresh, as
+     * the workbench's does, and writes nothing (D36); it offers no interval,
+     * which stays the author's and `autoRefresh`'s. The static tier has no
+     * controls, so it draws the time alone.
+     */
+    withRefresh?: boolean;
+    /**
+     * What the board's numbers are read as, in the host's words — 「指标卡读
+     * 9 月 21 日（昨日），较前一日」 — drawn under the title while the board
+     * fills the screen, and never otherwise (D70): on the page the host draws
+     * it itself, beside its own title, and the expanded board covers both.
+     * Written from what the host is told (`onFiltersChange`), it follows the
+     * reader's filters into the expansion. The host's own actions stay on its
+     * page: filling the screen keeps what reading the board needs.
+     */
+    caption?: ReactNode;
+}
+/**
+ * One saved dashboard inside a business page (D22): the board, its filter
+ * bar with each filter in the mode the page gives it, and what the host
+ * switched on — a tier (`interaction`), the title, the panel titles, a
+ * panel's export, auto-refresh, filling the screen, 在工作台中打开. Split
+ * from `EmbeddedView` by resource, as the workbenches are: a host that
+ * embeds a board says so, and a record view named here is refused as one
+ * this entry cannot show.
+ *
+ * It reads the board and never writes (D36): no 「编辑」, no save, no
+ * 另存为, no preference — what the reader changes lives in this viewing
+ * alone. Building a board is `DashboardWorkbench`'s.
+ */
+export declare function EmbeddedDashboard(given: EmbeddedDashboardProps): import('react').JSX.Element;
+//# sourceMappingURL=EmbeddedDashboard.d.ts.map

package/dist/ui/EmbeddedDashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddedDashboard.d.ts","sourceRoot":"","sources":["../../src/ui/EmbeddedDashboard.tsx"],"names":[],"mappings":"AAcA,OAAO,EAA2C,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAChF,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,mBAAmB,CAAC;AA4B3E,OAAO,EAOL,KAAK,mBAAmB,EACzB,MAAM,4BAA4B,CAAC;AAOpC,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAW3E,YAAY,EACV,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,sBAAuB,SAAQ,cAAc;IAC5D;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,4DAA4D;IAC5D,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAC5D,sEAAsE;IACtE,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACrC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACzC;;;;;;OAMG;IACH,eAAe,CAAC,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAClD,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,2EAA2E;IAC3E,WAAW,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IACzC;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,SAAS,CAAC;CACrB;AAWD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,+BAiD9D"}

package/dist/ui/EmbeddedView.d.ts

@@ -0,0 +1,76 @@
+import { ReactNode } from 'react';
+import { FilterTree } from '../model/index.js';
+import { RecordRow } from '../record/index.js';
+import { EmbedBaseProps, EmbedInteraction } from './embed/options.js';
+import { RecordDetailOptions } from './workbench/RecordParts.js';
+export type { EmbedBaseProps, EmbedInteraction, EmbedSize, } from './embed/options.js';
+export interface EmbeddedViewProps extends EmbedBaseProps {
+    /**
+     * An outer condition ANDed onto the view's own, in the view's field names:
+     * the page's narrowing, locked — the reader sees it in the applied band
+     * and cannot take it off. It is admitted like a user's own filter, so a
+     * host cannot widen a view past what its definition allows, and it never
+     * reaches the saved config. It is not a security boundary: see the
+     * README's embedding section.
+     */
+    scopeFilter?: FilterTree | null;
+    /** How far the reader may go (`EmbedInteraction`); `static` by default. */
+    interaction?: EmbedInteraction;
+    /**
+     * The view's search box, at the end of the applied band, where its
+     * definition declares a search field (off by default). Record views only,
+     * and the interactive tier only: the tier is the ceiling and the switch
+     * opts in within it (D36).
+     */
+    withSearch?: boolean;
+    /**
+     * The export button and window (D14), in the embed's first row (off by
+     * default). Record views only, and the interactive tier only (D36,
+     * amending D24 Q24): with it, rows can be picked, since the window offers
+     * to take the picked ones.
+     */
+    withExport?: boolean;
+    /**
+     * What the host offers on one row of a record view. The slot takes the row
+     * alone, because there is no view to command here.
+     */
+    rowActions?(row: RecordRow): ReactNode;
+    /**
+     * A record's detail, opened from its row (off by default; G20): every
+     * field under its group, read whole — the event a row stands for, its
+     * payload — in a sheet beside the page, or over the drawer the embed sits
+     * in. Record views only, and the interactive tier only (D36: the tier is
+     * the ceiling). Read-only: the row's commands (`rowActions`) are not in
+     * its header, and nothing it does is written.
+     *
+     * `true` is the detail as the host reads the definition's records
+     * (`bind`'s `reading`: its `render`, `title` and `sections`), or as it
+     * comes where it bound none — its open record this embed's own, never the
+     * binding's `open`/`onOpenChange`, so two embeds of one definition on a
+     * page each open their own and write nothing to the host's address;
+     * `RecordDetailOptions` — what `DataWorkbench` takes as `record.detail` —
+     * lets the host hold which record is open (`open`/`onOpenChange`) and add
+     * its own sections.
+     */
+    detail?: boolean | RecordDetailOptions;
+}
+/**
+ * One saved record or analysis view inside a business page: the result, and
+ * what the host switched on around it (D22).
+ *
+ * The workbench exists to let a user *change* how they observe; this exists
+ * to let a page *show* what someone already decided. So there is no view
+ * list, no condition editor and no save — nothing it does is written
+ * anywhere (D36) — an order page embedding "recent shipments for this
+ * customer" wants the rows, not a second application. How far a reader may
+ * go is one explicit tier (`interaction`); the rest are switches: the
+ * title, the search, the export, auto-refresh, filling the screen, 在工作台
+ * 中打开. A dashboard is `EmbeddedDashboard`, split by resource as the
+ * workbenches are; this one names it as a view it cannot show.
+ *
+ * Everything it drops is chrome. Admission, paging, auto-refresh and the
+ * request budget are the runtime's, identical to the workbench's, because
+ * both are compositions over the same controllers.
+ */
+export declare function EmbeddedView(given: EmbeddedViewProps): import('react').JSX.Element;
+//# sourceMappingURL=EmbeddedView.d.ts.map

package/dist/ui/EmbeddedView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddedView.d.ts","sourceRoot":"","sources":["../../src/ui/EmbeddedView.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACjD,OAAO,KAAK,EAAkB,UAAU,EAAY,MAAM,mBAAmB,CAAC;AAC9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAmBpD,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAStE,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,SAAS,GACV,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,2EAA2E;IAC3E,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,UAAU,CAAC,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,CAAC;IACvC;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,mBAAmB,CAAC;CACxC;AAqBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,+BAsBpD"}

package/dist/ui/ViewHost.d.ts

@@ -0,0 +1,94 @@
+import { ReactNode } from 'react';
+import { ViewEngine } from '../runtime/index.js';
+import { ViewDestination, ViewRouter } from '../runtime/routes.js';
+import { ViewBinding } from './workbench/bindings.js';
+import { HostColorMode } from './colorMode.js';
+import { ViewMessages } from './kit/messages.js';
+import { ViewPreset } from './kit/presets.js';
+export interface ViewHostProps {
+    /**
+     * The application's engine, built once (host-integration.md 4) — the
+     * data port: its `resources` and its `store`. An inner host without one
+     * uses the outer one's. The definitions are said where they are shown, in
+     * the words in force there; the words of the outermost host naming the
+     * engine are the ones checked for keys they lack (`ViewEngine.setText`).
+     */
+    engine?: ViewEngine;
+    /**
+     * The language port: the language values show in, the outer host's when
+     * left out. A change of it redraws what is open and rebuilds nothing.
+     */
+    locale?: string;
+    /**
+     * The language port's words, merged over those in force — the engine's
+     * own and the definitions' keys (`text(key)`) alike — so switching them
+     * redraws every open view in them without reopening, re-querying or
+     * dirtying anything (3.1).
+     */
+    messages?: ViewMessages;
+    /**
+     * The router port (4.2): the host's router — `useReactRouter()` from
+     * `/react-router`, or two members over another. With it the engine keeps
+     * the address: every way off a board or a view goes through the route of
+     * the resource it leads to; a workbench opens the address's `?view=` and
+     * writes it back; a bound resource's record detail follows `?id=`; a view
+     * handed over, and a board's filters and tab, travel as the history
+     * entry's state; another site opens apart. A surface's own props still
+     * win. The outer host's when left out.
+     */
+    router?: ViewRouter;
+    /**
+     * Every way off a board or a view, in the host's own hands instead of the
+     * router's: handed resolved through the route of the resource it leads
+     * to (`ViewRoute`); a URL, and a resource with no route, as it came.
+     */
+    navigate?(to: ViewDestination): void;
+    /**
+     * Each resource's behaviour in this host (`bind`) — its route, its
+     * reading and the commands on its records; an inner host's wins by id.
+     */
+    bindings?: readonly ViewBinding[];
+    /**
+     * The theme port, the first of two paths (4.1): `host` — the engine
+     * follows the host's shadcn theme (Tailwind v4), through
+     * `shadcn-bridge.css`, which the host imports; no preset is named. The
+     * other path is `preset`.
+     */
+    theme?: 'host';
+    /**
+     * The other path: the host follows the engine — a preset (its stylesheet
+     * imported: `themes/<name>.css` or `themes.css`), named on `<html>`, and
+     * worn by the host's own chrome through `fve-tokens`.
+     */
+    preset?: ViewPreset;
+    /** The host's brand colour over the preset (`--fve-brand`, on `<html>`). */
+    brand?: string;
+    /**
+     * Light or dark (4.1): `system` by default — the engine paints `<html>`'s
+     * `.dark` and `color-scheme` and follows the system live — or `light` /
+     * `dark` to start pinned; `host` where the host paints its own mode (as
+     * next-themes does), and the engine only follows `.dark`. The reader
+     * picks another through `useColorMode`. Only the outermost host paints.
+     */
+    colorMode?: HostColorMode;
+    /**
+     * Where the reader's pick of a mode is kept on this machine (a
+     * `localStorage` key); not kept when left out.
+     */
+    rememberColorMode?: string;
+    children: ReactNode;
+}
+/**
+ * The host's one entry (host-integration.md 4.2): a few ports the host
+ * fills — data (`engine`), router, theme, language, commands (`bindings`)
+ * — around every surface under it, each taking only what differs where it
+ * stands: `<DataWorkbench definitionId={ORDERS} />`. The router, the i18n
+ * and the theme stay the host's; the ports are bridges to them.
+ *
+ * Hosts nest, the inner one over the outer one — a page's own bindings, a
+ * second engine — and a surface's own `engine`, `messages`, `locale`,
+ * `onNavigate` or `record` still wins. Only the outermost host paints
+ * `<html>`: the mode, the preset, the brand.
+ */
+export declare function ViewHost({ engine, locale, messages, router: own, navigate, bindings, theme, preset, brand, colorMode, rememberColorMode, children, }: ViewHostProps): import('react').JSX.Element;
+//# sourceMappingURL=ViewHost.d.ts.map

package/dist/ui/ViewHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ViewHost.d.ts","sourceRoot":"","sources":["../../src/ui/ViewHost.tsx"],"names":[],"mappings":"AAaA,OAAO,EAA4B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAMxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMnD,MAAM,WAAW,aAAa;IAC5B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,CAAC;IACrC;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAClC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,EACvB,MAAM,EACN,MAAM,EACN,QAAQ,EACR,MAAM,EAAE,GAAG,EACX,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,MAAM,EACN,KAAK,EACL,SAAS,EACT,iBAAiB,EACjB,QAAQ,GACT,EAAE,aAAa,+BAkCf"}

package/dist/ui/actions/ActionButtons.d.ts

@@ -0,0 +1,49 @@
+import { RecordRow } from '../../record/index.js';
+import { ActionInput, RecordAction } from '../../runtime/actions.js';
+import { BulkActionView, RowActionView } from '../../react/index.js';
+/**
+ * Presses an action, where a choice's option is the input, and names the
+ * control the keyboard goes back to when a question it opens closes — the
+ * button pressed, or the menu's button for an item, which goes with the
+ * menu.
+ */
+type Start = (action: RecordAction, input?: ActionInput, from?: HTMLElement | null) => void;
+export interface RowActionButtonsProps {
+    row: RecordRow;
+    views: readonly RowActionView[];
+    place: 'row' | 'detail';
+    /** A command is running on the surface: nothing else starts. */
+    busy: boolean;
+    onStart: Start;
+}
+/**
+ * A record's declared actions, in its row, on its card or in its detail:
+ * the primary ones as buttons, the rest behind 「⋯」, named after the
+ * record. An action the record does not take now is held off, and why is
+ * said on the button — its tooltip, which focus opens too, and its
+ * accessible description — and atop the menu; each reason once. A button
+ * held off stays where Tab finds it, and the 「⋯」 stays pressable while a
+ * command runs, its items held off instead, so the keyboard is never handed
+ * to the page by the press it just made.
+ */
+export declare function RowActionButtons({ row, views, place, busy, onStart, }: RowActionButtonsProps): import('react').JSX.Element;
+export interface BulkActionButtonsProps {
+    views: readonly BulkActionView[];
+    busy: boolean;
+    onStart: Start;
+}
+/**
+ * The declared actions over the selection, in the selection's bar: the
+ * primary one counting what it is for (「准备 20 条」), and how many of
+ * those take it where not all do (「催发货 2/4 条」), the others by name, a
+ * choice as a menu of its options; one none of the selection takes is held
+ * off with the reason. Every one asks first — how many, and which of them
+ * will not take it (`ActionDialog`).
+ *
+ * Each is an item of the toolbar the bar stands in, so the bar stays one
+ * Tab stop with the arrows inside it (A11Y-11); a host's own bulk slot
+ * beside them is the host's markup, and keeps the stops it has.
+ */
+export declare function BulkActionButtons({ views, busy, onStart, }: BulkActionButtonsProps): import('react').JSX.Element;
+export {};
+//# sourceMappingURL=ActionButtons.d.ts.map

package/dist/ui/actions/ActionButtons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionButtons.d.ts","sourceRoot":"","sources":["../../../src/ui/actions/ActionButtons.tsx"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EACV,WAAW,EAEX,YAAY,EACb,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAoB1E;;;;;GAKG;AACH,KAAK,KAAK,GAAG,CACX,MAAM,EAAE,YAAY,EACpB,KAAK,CAAC,EAAE,WAAW,EACnB,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,KACtB,IAAI,CAAC;AAqIV,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,SAAS,CAAC;IACf,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IAChC,KAAK,EAAE,KAAK,GAAG,QAAQ,CAAC;IACxB,gEAAgE;IAChE,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,KAAK,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,GAAG,EACH,KAAK,EACL,KAAK,EACL,IAAI,EACJ,OAAO,GACR,EAAE,qBAAqB,+BA4GvB;AAiBD,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IACjC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,KAAK,CAAC;CAChB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,IAAI,EACJ,OAAO,GACR,EAAE,sBAAsB,+BAiExB"}

package/dist/ui/actions/ActionDialog.d.ts

@@ -0,0 +1,35 @@
+import { PendingAction } from '../../react/index.js';
+import { FinalFocus } from '../kit/focus.js';
+export interface ActionDialogProps {
+    /** What is waiting on the reader; nothing is open while `null`. */
+    pending: PendingAction | null;
+    onInput(name: string, value: unknown): void;
+    onOnlyAble(): void;
+    onConfirm(): void;
+    onCancel(): void;
+    /** Where the keyboard goes as it closes: the control that asked. */
+    finalFocus?: FinalFocus;
+}
+/**
+ * The question an action asks before it is sent, and its form.
+ *
+ * How many records it is for — or, for one, which: the reader confirms the
+ * record they meant — and what it does beyond the obvious, in the host's
+ * words (`confirm`) or, where the host said none, the engine's; the fields
+ * the command needs, drawn by the condition editor's own value controls;
+ * and over a selection, the records the engine already knows will not take
+ * it, by reason with their keys — 「5 条里 3 条能重试」 — with one press to
+ * pick only the ones that can, and the answer counting what will be sent
+ * (「催发货 3 条」). Sent anyway, the refused are reported as not run and
+ * left selected; nothing is lost.
+ *
+ * A modal that an outside press does not dismiss, the keyboard inside
+ * until an answer. Only a dangerous question with nothing to fill is an
+ * `alertdialog` — read out as urgent, which a loss is; a form, or a routine
+ * question, is a `dialog`. The answer stays pressable while a required
+ * field is blank: pressing it marks what is missing and takes the keyboard
+ * there, rather than a grey button that says nothing of why. The words stay
+ * while it animates closed, rather than blanking.
+ */
+export declare function ActionDialog({ pending, onInput, onOnlyAble, onConfirm, onCancel, finalFocus, }: ActionDialogProps): import('react').JSX.Element | null;
+//# sourceMappingURL=ActionDialog.d.ts.map

package/dist/ui/actions/ActionDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionDialog.d.ts","sourceRoot":"","sources":["../../../src/ui/actions/ActionDialog.tsx"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAuB1D,OAAO,EAAW,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI3D,MAAM,WAAW,iBAAiB;IAChC,mEAAmE;IACnE,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;IAC9B,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5C,UAAU,IAAI,IAAI,CAAC;IACnB,SAAS,IAAI,IAAI,CAAC;IAClB,QAAQ,IAAI,IAAI,CAAC;IACjB,oEAAoE;IACpE,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAKD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,EAC3B,OAAO,EACP,OAAO,EACP,UAAU,EACV,SAAS,EACT,QAAQ,EACR,UAAU,GACX,EAAE,iBAAiB,sCAoKnB"}

package/dist/ui/actions/ActionSurface.d.ts

@@ -0,0 +1,60 @@
+import { ReactNode } from 'react';
+import { RecordRow } from '../../record/index.js';
+import { RecordViewRuntime } from '../../runtime/index.js';
+import { RecordActions } from '../../runtime/actions.js';
+import { RecordActionSlots, RecordActionTable, RecordActionsController } from '../../react/index.js';
+import { SelectionContext } from '../record/SelectionBar.js';
+import { ViewMessages } from '../kit/messages.js';
+export interface ActionSurfaceOptions {
+    /** The host's declared actions on this surface's records. */
+    actions?: RecordActions;
+    /** The host's own markup, drawn after the declared actions. */
+    slots?: RecordActionSlots;
+    table: RecordActionTable;
+    runtime: RecordViewRuntime | null;
+    /** What reading the view again means here; the table's own by default. */
+    refresh?(): void;
+    /** The record the detail holds, when the page does not. */
+    also?: readonly RecordRow[];
+    /** The surface's voice, which says a command's start and its outcome. */
+    say(message: string): void;
+    /**
+     * Says a command's outcome instead of `say`, where the surface reads its
+     * query back too: the refresh after a command would otherwise say its
+     * count over the outcome before a reader heard it
+     * (`useQueryAnnouncement`'s `lead`).
+     */
+    sayOutcome?(message: string): void;
+    /**
+     * The host's wording and language, where the surface's provider is below
+     * this hook — the record view's parts are above the surface they draw —
+     * so what is said aloud is said in the words drawn on the line.
+     */
+    messages?: ViewMessages;
+    locale?: string;
+    /** Whether the selection may be acted on: a read-only board's panel may not. */
+    bulk?: boolean;
+}
+/** What a record surface draws of its actions, each where it goes. */
+export interface ActionSurface {
+    controller: RecordActionsController;
+    /** A record's actions, in its row or card; `undefined` when it has none. */
+    row?(row: RecordRow): ReactNode;
+    /** A record's actions in its detail; `undefined` when it has none. */
+    detail?(row: RecordRow): ReactNode;
+    /** The selection's actions; `undefined` when nothing acts on a selection. */
+    bulk?(context: SelectionContext): ReactNode;
+    /** The command's line: how far it has come, what it came to. */
+    status: ReactNode;
+    /** The question and the form, while one is waiting. */
+    dialog: ReactNode;
+}
+/**
+ * A record surface's actions (host-integration.md 5): the host's declared
+ * ones placed by the engine — a record's in its row, card and detail, the
+ * selection's in its bar — then the host's slots, the escape hatch; one
+ * runner for every command on the surface, its line above the rows and its
+ * start and outcome said aloud; the question and the form in one dialog.
+ */
+export declare function useActionSurface({ actions, slots, table, runtime, refresh, also, say, sayOutcome, messages: wording, locale, bulk: selectable, }: ActionSurfaceOptions): ActionSurface;
+//# sourceMappingURL=ActionSurface.d.ts.map

package/dist/ui/actions/ActionSurface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionSurface.d.ts","sourceRoot":"","sources":["../../../src/ui/actions/ActionSurface.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAkC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAMvD,MAAM,WAAW,oBAAoB;IACnC,6DAA6D;IAC7D,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,KAAK,EAAE,iBAAiB,CAAC;IACzB,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAClC,0EAA0E;IAC1E,OAAO,CAAC,IAAI,IAAI,CAAC;IACjB,2DAA2D;IAC3D,IAAI,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IAC5B,yEAAyE;IACzE,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;;;OAKG;IACH,UAAU,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,uBAAuB,CAAC;IACpC,4EAA4E;IAC5E,GAAG,CAAC,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,CAAC;IAChC,sEAAsE;IACtE,MAAM,CAAC,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,CAAC;IACnC,6EAA6E;IAC7E,IAAI,CAAC,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC5C,gEAAgE;IAChE,MAAM,EAAE,SAAS,CAAC;IAClB,uDAAuD;IACvD,MAAM,EAAE,SAAS,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,IAAI,EACJ,GAAG,EACH,UAAgB,EAChB,QAAQ,EAAE,OAAO,EACjB,MAAM,EACN,IAAI,EAAE,UAAiB,GACxB,EAAE,oBAAoB,GAAG,aAAa,CAsKtC"}

package/dist/ui/actions/BulkStatus.d.ts

@@ -0,0 +1,41 @@
+import { ActionRunner, BulkOutcome, BulkRunning } from '../../react/index.js';
+import { MessageFormatters, SayWith } from '../kit/MessagesProvider.js';
+import type * as React from 'react';
+export interface BulkStatusProps {
+    /** The surface's runner; nothing is drawn while it is idle. */
+    command: Pick<ActionRunner, 'running' | 'outcome' | 'stop' | 'dismiss'>;
+    /** The line, for the surface to land the keyboard on its button. */
+    ref?: React.Ref<HTMLDivElement>;
+}
+/**
+ * A surface's command, as one line: how far it has come while it runs,
+ * with the way to stop it; what it came to once it has settled, with the
+ * way to put the line away.
+ *
+ * It is the write outcome's recipe (`OutcomeActions`) applied to a host's
+ * command: the same `LineAlert`, the same tones, the same single way out.
+ * The record surface draws it under its rows, held to the bottom of the
+ * view while they scroll, because the outcome outlives the selection it
+ * acted on and the selection's bar goes when the selection does — and a
+ * line that appeared above the rows pushed every row down under the
+ * pointer that pressed it.
+ *
+ * Three tones for three readings, taken from the callout recipe: everything
+ * done is a note (`info` — the expected ending should not shout), some of
+ * it done is a `warning`, nothing done and something failed is an `error`;
+ * a command in flight is a note. The reasons are the source's own words,
+ * the commonest first, a couple of them with how many records gave each —
+ * records refuse for different reasons, and one reason said for all of
+ * them was a guess. What failed or was not sent stays selected
+ * (`useActionRunner`), and the line says so; what has an unknown outcome
+ * is let go, and the line says to check it.
+ *
+ * Stop starts nothing more and stays a button: pressed again it stops
+ * waiting, so a command that never answers cannot hold the line.
+ */
+export declare function BulkStatus({ command, ref }: BulkStatusProps): React.JSX.Element | null;
+/** The line while a command runs: its name and how far it has come. */
+export declare function runningSentence(running: BulkRunning, messages: MessageFormatters, sayWith: SayWith): string;
+/** The line once a command has settled: what it came to, and why not. */
+export declare function outcomeSentence(outcome: BulkOutcome, messages: MessageFormatters, sayWith: SayWith): string;
+//# sourceMappingURL=BulkStatus.d.ts.map

package/dist/ui/actions/BulkStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BulkStatus.d.ts","sourceRoot":"","sources":["../../../src/ui/actions/BulkStatus.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AACpC,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,OAAO,EAGb,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,eAAe;IAC9B,+DAA+D;IAC/D,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC;IACxE,oEAAoE;IACpE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;CACjC;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,UAAU,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,eAAe,4BA0C3D;AAED,uEAAuE;AACvE,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,OAAO,GACf,MAAM,CAWR;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,OAAO,GACf,MAAM,CAIR"}

package/dist/ui/analysis/AnalysisChart.d.ts

@@ -0,0 +1,71 @@
+import { AnalysisColumnView, ChartData } from '../../analysis/index.js';
+import { ChartSpec, RecordData } from '../../model/index.js';
+import { ChartImageSlot } from '../charts/image.js';
+import { OnPick } from '../charts/family.js';
+export interface AnalysisChartProps {
+    data: ChartData;
+    /** The saved spec; only `combo` and a few axis options still need it. */
+    spec?: ChartSpec;
+    className?: string;
+    /**
+     * The result's columns, so a category shows as its field's values do: an
+     * enum by its label, a date bucket as its day or its month.
+     */
+    columns?: readonly AnalysisColumnView[];
+    /**
+     * Makes the marks pressable: a bar, a slice, a cell or a point opens the
+     * follow-up menu on the group it stands for. The reading table beside the
+     * chart is not: the keyboard's path to the same menu is the table layout,
+     * where a row is a row (F10).
+     */
+    onPick?: OnPick;
+    /**
+     * The rows are the first groups of more — the result says so beside the
+     * chart; a pie also says its shares are of the groups shown.
+     */
+    cutShort?: boolean;
+    /**
+     * The group a dashboard panel's press set the board's filter to (D22 I):
+     * a bar, a line's point or a slice stands out, the rest drawn faint.
+     */
+    highlight?: (row: RecordData) => boolean;
+    /**
+     * The follow-up menu is open over the chart (`DrillMenu`): the drawing's
+     * tooltip is put away and stays away until it closes (`ChartMenuOpen`).
+     */
+    menuOpen?: boolean;
+    /**
+     * Whether a press on a group opens the follow-up menu here, so the
+     * tooltip says so (`ChartPressHint`): a workbench, an embed that follows
+     * up. A board's press filters, and its badge says that.
+     */
+    pressHint?: boolean;
+    /**
+     * Whether a long time axis also zooms by pinch and Ctrl + wheel, not only
+     * by its slider — a workbench, where the chart is the page's subject; a
+     * dashboard panel or a read-only embedding leaves the wheel to the page
+     * (docs/design/analysis-echarts.md 2.2).
+     */
+    zoomGestures?: boolean;
+    /**
+     * Where the drawing hands itself over to be taken away as a picture
+     * (`useChartImage`, D33 Q58). A metric card is words, not a drawing, and
+     * hands nothing over.
+     */
+    image?: ChartImageSlot;
+}
+/**
+ * Draws what the kernel already shaped.
+ *
+ * Every pivot, merge, cumulation and conversion happened in `shapeChart`, so
+ * `charts/` only picks marks and colours; a different chart library would
+ * replace those files without touching a rule. This one dispatches by family
+ * and hands each the same props, the category labeller included.
+ *
+ * It also reads the same projection twice: once as marks, and once as a
+ * table nobody looks at. A drawing is one image with a name, so the numbers
+ * have to be said somewhere, and saying them off `ChartData` — not off the
+ * row projection beside it — is what keeps the two from disagreeing.
+ */
+export declare function AnalysisChart({ data: given, spec: specified, className, columns, onPick, cutShort, highlight, menuOpen, pressHint, zoomGestures, image, }: AnalysisChartProps): import('react').JSX.Element;
+//# sourceMappingURL=AnalysisChart.d.ts.map

package/dist/ui/analysis/AnalysisChart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnalysisChart.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/AnalysisChart.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAUlE,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAG3E,OAAO,EAQL,KAAK,MAAM,EACZ,MAAM,qBAAqB,CAAC;AAkB7B,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,yEAAyE;IACzE,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACxC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,EAC5B,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,SAAS,EACf,SAAS,EACT,OAAO,EACP,MAAM,EACN,QAAQ,EACR,SAAS,EACT,QAAgB,EAChB,SAAiB,EACjB,YAAoB,EACpB,KAAK,GACN,EAAE,kBAAkB,+BAiEpB"}

package/dist/ui/analysis/AnalysisTable.d.ts

@@ -0,0 +1,54 @@
+import { AnalysisProjection } from '../../analysis/index.js';
+import { RecordData } from '../../model/index.js';
+import { HeaderSorting } from './headerSort.js';
+import { OnPick } from '../charts/family.js';
+export interface AnalysisTableProps {
+    view: AnalysisProjection;
+    /**
+     * Makes the rows pressable: a row opens the follow-up menu on the group
+     * it is. This is the keyboard's path to the menu the chart's marks open
+     * with a pointer (F10): a row takes focus and opens on Enter or Space.
+     */
+    onPick?: OnPick;
+    /**
+     * Makes the headers sort the groups: a press orders them by that column,
+     * ascending, then descending, then back to the view's own order, and the
+     * question runs again (`useHeaderSort`). Left out — a dashboard panel, an
+     * embedded view — the headers name their columns and nothing more.
+     */
+    sorting?: HeaderSorting;
+    /**
+     * Whether a press opens a menu (`aria-haspopup`): the follow-up menu, as
+     * it does unless said otherwise. A dashboard panel whose press sets the
+     * board's filter or goes elsewhere opens none (D22 I).
+     */
+    opensMenu?: boolean;
+    /**
+     * The group a press set the board's filter to, marked rather than
+     * narrowed to (D22 I): its row wears `data-pressed` and `aria-current`.
+     */
+    highlight?: (row: RecordData) => boolean;
+    /**
+     * Whether the table is its own scroll port, as `RecordTable`'s prop of
+     * the same name says (`stickyPort`). On by default: a workbench, an
+     * embed. A dashboard panel, whose body is what scrolls, turns it off, so
+     * the header and the totals hold against the panel rather than against a
+     * box nobody scrolls.
+     */
+    scrolls?: boolean;
+}
+/**
+ * The aggregation as a table: groups first, then metrics, with the totals row
+ * from its own ungrouped query rather than from summing what is on screen.
+ *
+ * It reads as the record table does, from the same recipes: a number on the
+ * right edge in tabular figures, header included (`NUMERIC_CELL`); an id in
+ * the monospace the record view's copyable reading wears (`IDENTIFIER_FACE`);
+ * each header the record table's `SortableHeader`; each column at a width
+ * held on its cells (`columnWidth`), the surplus in the aria-hidden filler
+ * (`record/Filler.tsx`). The widths come from the columns and never from the
+ * rows (`analysis/tableColumns.ts`), so a question asked again with other
+ * answers leaves every column where it was.
+ */
+export declare function AnalysisTable({ view, onPick, sorting, opensMenu, highlight, scrolls, }: AnalysisTableProps): import('react').JSX.Element;
+//# sourceMappingURL=AnalysisTable.d.ts.map

package/dist/ui/analysis/AnalysisTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnalysisTable.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/AnalysisTable.tsx"],"names":[],"mappings":"AAuCA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAGL,KAAK,UAAU,EAEhB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAQrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAUlD,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,kBAAkB,CAAC;IACzB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,CAAC;IACzC;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAOD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,EAC5B,IAAI,EACJ,MAAM,EACN,OAAO,EACP,SAAgB,EAChB,SAAS,EACT,OAAc,GACf,EAAE,kBAAkB,+BA2cpB"}