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

package/dist/ui/kit/dragPlugins.d.ts

@@ -0,0 +1,35 @@
+import { ComponentProps } from 'react';
+import { DragDropProvider } from '@dnd-kit/react';
+import { dragAccessibility } from './dragAnnounce.js';
+type ProviderProps = ComponentProps<typeof DragDropProvider>;
+/** The library's own defaults, as a provider's customising callback gets them. */
+type Defaults<K extends 'plugins' | 'sensors'> = Parameters<Extract<NonNullable<ProviderProps[K]>, (defaults: never) => unknown>>[0];
+/**
+ * What every sortable list's `DragDropProvider` runs (Q-11), spread onto it
+ * whole so no list sets one half and forgets the other:
+ *
+ * - `plugins` — the library's defaults, its `Accessibility` plugin worded
+ *   by the list (`dragAccessibility`, through each list's own
+ *   `…DragAccessibility`) rather than in the library's English built from
+ *   ids;
+ * - `sensors` — the library's defaults, the pointer's waiting for a drag to
+ *   be one ({@link PRESS_OR_DRAG}) so the handle can still be clicked;
+ * - under a strict CSP, the page's nonce ({@link cspNonce}) on the `<style>`
+ *   the library adds to `<head>` while a drag is on (the grabbing cursor, no
+ *   text selection), which `style-src 'self'` would otherwise block
+ *   (R3-P1-3).
+ */
+export declare function sortableList(accessibility: ReturnType<typeof dragAccessibility>): {
+    plugins(defaults: Defaults<'plugins'>): Defaults<'plugins'>;
+    sensors(defaults: Defaults<'sensors'>): Defaults<'sensors'>;
+};
+/**
+ * The plugins one sortable row runs: the library's defaults less the
+ * optimistic sorting. That plugin reorders the DOM while the pointer moves,
+ * which makes the indexes a row is rendered from stale exactly when the drop
+ * is read; without it the library still draws the drag preview, and every
+ * list here computes the committed order from what the drop reports.
+ */
+export declare function withoutOptimisticSorting<P>(defaults: P[]): P[];
+export {};
+//# sourceMappingURL=dragPlugins.d.ts.map

package/dist/ui/kit/dragPlugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dragPlugins.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/dragPlugins.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAQ5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,KAAK,aAAa,GAAG,cAAc,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE7D,kFAAkF;AAClF,KAAK,QAAQ,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI,UAAU,CACzD,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,EAAE,KAAK,KAAK,OAAO,CAAC,CACrE,CAAC,CAAC,CAAC,CAAC;AAkBL;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAC1B,aAAa,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,GAClD;IACD,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC5D,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;CAC7D,CAgBA;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAE9D"}

package/dist/ui/kit/dragWording.d.ts

@@ -0,0 +1,15 @@
+import { MessageFormatters } from './MessagesProvider.js';
+import { DragWording } from './dragAnnounce.js';
+import { MessageKey } from './messages.js';
+/** Where one list's drag sentences live in the catalogue. */
+export interface DragWordingKeys {
+    /** The row was picked up. */
+    picked: MessageKey;
+    /** The move was given up and the row stayed where it was. */
+    cancelled: MessageKey;
+    /** The placeholder `picked` and `cancelled` name the carried row by. */
+    placeholder: string;
+}
+/** One list's drag sentences, in the wording in force. */
+export declare function dragWording(messages: MessageFormatters, keys: DragWordingKeys): DragWording;
+//# sourceMappingURL=dragWording.d.ts.map

package/dist/ui/kit/dragWording.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dragWording.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/dragWording.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,6DAA6D;AAC7D,MAAM,WAAW,eAAe;IAC9B,6BAA6B;IAC7B,MAAM,EAAE,UAAU,CAAC;IACnB,6DAA6D;IAC7D,SAAS,EAAE,UAAU,CAAC;IACtB,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,0DAA0D;AAC1D,wBAAgB,WAAW,CACzB,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,eAAe,GACpB,WAAW,CAOb"}

package/dist/ui/kit/failureSink.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { RuntimeEnvironment, ViewErrorEvent, ViewRuntime } from '../../runtime/index.js';
+type Sink = (event: ViewErrorEvent) => void;
+/**
+ * Where the render boundaries below tell the host what they caught (D40):
+ * the engine's `onError`, through the environment the view runs on, with the
+ * open view named. The two workbenches and the embeds set it, because they
+ * are the ones handed the engine; a boundary with none above it tells only
+ * its own `onFailure`.
+ */
+export declare function FailureSink({ environment, runtime, children, }: {
+    environment: RuntimeEnvironment;
+    runtime: ViewRuntime | null | undefined;
+    children: ReactNode;
+}): import('react').JSX.Element;
+/** The nearest surface's way to the host's `onError`, if there is one. */
+export declare function useFailureSink(): Sink | undefined;
+export {};
+//# sourceMappingURL=failureSink.d.ts.map

package/dist/ui/kit/failureSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failureSink.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/failureSink.tsx"],"names":[],"mappings":"AAaA,OAAO,EAA0C,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAC/E,OAAO,KAAK,EACV,kBAAkB,EAClB,cAAc,EACd,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAGhC,KAAK,IAAI,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;AAI5C;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,EAC1B,WAAW,EACX,OAAO,EACP,QAAQ,GACT,EAAE;IACD,WAAW,EAAE,kBAAkB,CAAC;IAChC,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC;IACxC,QAAQ,EAAE,SAAS,CAAC;CACrB,+BAiBA;AAED,0EAA0E;AAC1E,wBAAgB,cAAc,IAAI,IAAI,GAAG,SAAS,CAEjD"}

package/dist/ui/kit/features.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Which of the workbench's own controls a host wants on screen (D18 XI).
+ *
+ * All on by default. A feature turned off is **absent**, never disabled
+ * (D4): a sensitive view that must not be exported has no export button,
+ * rather than a grey one that teaches the user what they may not do. These
+ * are the host's presentation choices; whether a *user* may do something is
+ * the store's `ViewPermissions`, which stays a separate question.
+ */
+export interface WorkbenchFeatures {
+    /** The export button and window (D14), over records or groups (D25 Q28). */
+    export?: boolean;
+    /** The table/cards switch. Record views only. */
+    layouts?: boolean;
+    /** The column settings, or the card settings under the card layout. */
+    columns?: boolean;
+    /** The sort settings. Record views only. */
+    sort?: boolean;
+    /**
+     * The visualization panel and the 「可视化」 button that opens it (D20 屏
+     * I／J). Analysis views only: off, the result is read as the saved layout
+     * says — a table, or the chart already in the config — and there is no way
+     * into the panel, because a panel nobody can reach is a panel that does
+     * not exist.
+     */
+    visualization?: boolean;
+    /** The view manager — its gear in the sidebar and its item in the switcher. */
+    manage?: boolean;
+    /**
+     * The search box at the end of the applied band (`SearchBox`). It is there
+     * only where the definition declares a search field; off, the search is
+     * still a condition the editor can add, just not one kept on hand.
+     */
+    search?: boolean;
+}
+/** The host's answer over the default, with no member left undefined. */
+export declare function featuresOf(given: WorkbenchFeatures | undefined): Required<WorkbenchFeatures>;
+//# sourceMappingURL=features.d.ts.map

package/dist/ui/kit/features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/features.ts"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IAChC,4EAA4E;IAC5E,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,iDAAiD;IACjD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,uEAAuE;IACvE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,4CAA4C;IAC5C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,+EAA+E;IAC/E,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAaD,yEAAyE;AACzE,wBAAgB,UAAU,CACxB,KAAK,EAAE,iBAAiB,GAAG,SAAS,GACnC,QAAQ,CAAC,iBAAiB,CAAC,CAE7B"}

package/dist/ui/kit/focus.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Where the keyboard goes when a press takes away what it pressed — the
+ * one set of rules the analysis cards (`useListFocus`), the board's filter
+ * bar (`dashboard/landing.ts`), the filter band's actions and the
+ * workbench's bands share. It lived twice, in `analysis/listFocus.ts` and
+ * `dashboard/landing.ts`, and the filter band reached into both (2026-09-27
+ * quality review: a helper in a feature folder is a cycle waiting).
+ */
+/** Anything the Tab key would stop on, before `disabled` is read. */
+export declare const FOCUSABLE = "button, [href], input, select, textarea, [tabindex]:not([tabindex=\"-1\"])";
+/** Where the keyboard should go, looked up once the press has been drawn. */
+export type Landing = () => Element | null | undefined;
+/**
+ * Where a dialog the board opened hands the keyboard back as it closes. A
+ * dialog opened from a menu item would return it to that item, which went
+ * with the menu; so the board names the control that asked instead — the
+ * edit bar's 「＋ 添加」, or the panel's own 「⋯」 — asked at closing, since
+ * the board has changed under the dialog by then.
+ */
+export type FinalFocus = () => HTMLElement | boolean;
+/** Whether the control is one focus would slide off again. */
+export declare function isBarred(element: HTMLElement): boolean;
+/** The element itself when it takes the keyboard, else the first inside it that does. */
+export declare function focusableIn(element: Element | null | undefined): HTMLElement | null;
+/**
+ * Marks a control a landing passes over though Tab stops on it: an ⓘ
+ * beside a term (`TermTip`), which says what the term means on focus. A
+ * press that opens the analysis tray landed on the first one and opened
+ * its tooltip over the row, answering a question nobody had asked.
+ */
+export declare const PASSED_OVER = "data-landing-skip";
+/**
+ * Focuses the first control of `item` — the item as a keyboard sees it —
+ * and says whether there was one.
+ */
+export declare function focusIn(item: Element | null | undefined): boolean;
+/**
+ * Where the keyboard goes after a press takes away what it pressed (U-02):
+ * a filter's ✕ goes with the value it cleared, 「清空」 is disabled by its
+ * own press, 「完成接线」 goes with the wiring bar. A focus with nothing under
+ * it falls to `<body>`, and the next Tab starts the page again.
+ *
+ * The press says where the keyboard should land, as a lookup; the effect
+ * after the render that took the control away runs it — the control is
+ * still on the page while the press is being handled. Only a keyboard that
+ * really fell is moved: one that something else took meanwhile (a menu, a
+ * popover, a dialog) stays where it is.
+ *
+ * The component holding this must render after the press.
+ */
+export declare function useLanding(): (where: Landing) => void;
+/** Whether the keyboard is nowhere: on the body, or on a control gone dead. */
+export declare function keyboardFell(): boolean;
+//# sourceMappingURL=focus.d.ts.map

package/dist/ui/kit/focus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/focus.ts"],"names":[],"mappings":"AAeA;;;;;;;GAOG;AAEH,qEAAqE;AACrE,eAAO,MAAM,SAAS,+EACsD,CAAC;AAE7E,6EAA6E;AAC7E,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,WAAW,GAAG,OAAO,CAAC;AAErD,8DAA8D;AAC9D,wBAAgB,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAMtD;AAED,yFAAyF;AACzF,wBAAgB,WAAW,CACzB,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAClC,WAAW,GAAG,IAAI,CAQpB;AAED;;;;;GAKG;AACH,eAAO,MAAM,WAAW,sBAAsB,CAAC;AAE/C;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAKjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,IAAI,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAcrD;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,IAAI,OAAO,CAQtC"}

package/dist/ui/kit/kinds.d.ts

@@ -0,0 +1,54 @@
+import { InboxIcon, UserIcon } from 'lucide-react';
+import { Issue, ViewAudience, ViewKind } from '../../model/index.js';
+import { MessageKey } from './messages.js';
+/**
+ * The face each kind and each audience wears.
+ *
+ * The sidebar, the title bar and the manager all draw the same view, so the
+ * mapping lives once: a kind that looked like an inbox in the list and like
+ * something else in the header would read as two different things.
+ */
+export declare const KIND_ICON: Record<ViewKind, typeof InboxIcon>;
+/**
+ * Who a view is for: one person or several. A system view is a shared view —
+ * `audienceOf` says so — and where it came from is `SYSTEM_ICON`'s to say.
+ *
+ * Not a lock for "personal": a lock is what a system view wears, because the
+ * one thing a reader has to know about it is that it cannot be renamed or
+ * deleted, and one glyph meaning "only mine" in the title bar and "cannot be
+ * changed" in the list is a picture with two readings.
+ */
+export declare const AUDIENCE_ICON: Record<ViewAudience, typeof UserIcon>;
+/**
+ * A view that came with the definition: it travels with the code, so it is
+ * never renamed or deleted here, and a lock is that fact as a picture.
+ */
+export declare const SYSTEM_ICON: import('lucide-react').LucideIcon;
+/**
+ * The one kind of view a surface has open, where it has one: a dashboard
+ * workbench or an embedded board says `dashboard`, a workbench of several
+ * kinds says nothing. It is what the chrome around the view calls the thing
+ * it makes, saves and deletes (`useKindWord`).
+ */
+export declare const SurfaceKind: import('react').Context<"record" | "dashboard" | "analysis" | undefined>;
+/** The key a kind says `key` with: its own where it has one. */
+export declare function kindWord(key: MessageKey, kind: ViewKind | undefined): MessageKey;
+/** `kindWord` for the kind the surface has open (`SurfaceKind`). */
+export declare function useKindWord(): (key: MessageKey) => MessageKey;
+/**
+ * An issue about the thing open, said as its kind says it: 「仪表盘保存失败」
+ * on a board where a view says 「视图保存失败」.
+ *
+ * The engine raises the same code for every kind — the write, the list and
+ * the opening are one protocol — so the choice is the surface's, as it is
+ * for a label (`kindWord`). A code reads the entry it falls back to
+ * (`formatMessage`: the code itself, else its longest prefix the catalogue
+ * ships), so `view.save.failed.unavailable` reads as `view.save.failed`
+ * does, and that entry's own word stands in. Only the chrome that reports
+ * on the thing open asks: a panel's view, the picker's list and a board's
+ * analysis promoted to a view are views, and are said so.
+ */
+export declare function kindIssue(found: Issue, kind: ViewKind | undefined): Issue;
+/** `kindIssue` for the kind the surface has open (`SurfaceKind`). */
+export declare function useKindIssue(): (found: Issue) => Issue;
+//# sourceMappingURL=kinds.d.ts.map

package/dist/ui/kit/kinds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kinds.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/kinds.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,SAAS,EAIT,QAAQ,EAET,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAC1E,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAEjE;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE,OAAO,SAAS,CAIxD,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,YAAY,EAAE,OAAO,QAAQ,CAG/D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,mCAAW,CAAC;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,WAAW,0EAAiD,CAAC;AA2G1E,gEAAgE;AAChE,wBAAgB,QAAQ,CACtB,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,QAAQ,GAAG,SAAS,GACzB,UAAU,CAEZ;AAED,oEAAoE;AACpE,wBAAgB,WAAW,IAAI,CAAC,GAAG,EAAE,UAAU,KAAK,UAAU,CAG7D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,KAAK,CAKzE;AAED,qEAAqE;AACrE,wBAAgB,YAAY,IAAI,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,CAGtD"}

package/dist/ui/kit/layout.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The one size under the body text: 13px, from `--_fve-text-ui` in `styles.css`.
+ *
+ * There used to be two of them within 0.8px of each other — `text-xs` (12)
+ * on the group labels, column headers, badges, pagination and the toolbar's
+ * hint, and the registry's `sm` control size (`text-[0.8rem]`, 12.8) on the
+ * sidebar's view items and every small button. Two sizes that close are not
+ * a rank, they are one size drawn twice; and 12.8px lands off the pixel
+ * grid, which is why 中文 at that size looked blurry. Both became this, so
+ * the surface has three rungs — 13 / 14 (`text-sm`) / 16 — and the step
+ * between two of them is visible.
+ *
+ * The line height comes with it: the class replaced (`text-xs`) carried one,
+ * and a font size on its own would have left each label with whatever its
+ * parent happened to say.
+ *
+ * `text-xs` stays where the text is genuinely a rank below this one — the
+ * labels drawn *inside* a chart, where density is the point, and the
+ * `AND`/`OR` code a menu item wears in front of the sentence it stands for.
+ */
+export declare const TEXT_UI = "fve:text-[length:var(--_fve-text-ui)] fve:leading-[1.125rem]";
+/**
+ * A heading the keyboard is *sent* to when a panel changes level
+ * (`tabIndex={-1}`), and never tabbed to: it is where the reader lands, not a
+ * control. It wears no focus ring — the browser drew one round the panel's
+ * title each time the panel changed, a box around words that cannot be
+ * pressed (2026-09-23 audit). The next Tab goes to the first control after
+ * it, which rings as every control does; a screen reader reads the heading
+ * it landed on either way.
+ */
+export declare const LANDING_HEADING = "fve:text-base fve:font-semibold fve:outline-none";
+/**
+ * The four distances this package puts between things, and the one surface
+ * it draws them on.
+ *
+ * Everything used to be `gap-2` or `gap-3`, which is why a workbench read as
+ * one flat stack of rows: if the space between two blocks is the space
+ * between two buttons, nothing is grouped and the eye has nothing to hold
+ * on to. The scale is what makes grouping visible, so it is written down
+ * once and read from here rather than typed at each call site.
+ *
+ * | Step      | Between                                    |
+ * | --------- | ------------------------------------------ |
+ * | `BLOCKS`  | the three blocks of the main column (16px)  |
+ * | `ROWS`    | rows inside one block (12px)                |
+ * | `GROUPS`  | control groups inside one row (8px)         |
+ * | `WITHIN`  | controls inside one group (4px)             |
+ */
+export declare const SPACE: {
+    readonly BLOCKS: "fve:gap-4";
+    readonly ROWS: "fve:gap-3";
+    readonly GROUPS: "fve:gap-2";
+    readonly WITHIN: "fve:gap-1";
+};
+/**
+ * The width a fixed-width dashboard is held to, centred (D31): 1200px.
+ *
+ * Chosen from the grid rather than the screen. The board is 24 columns with
+ * a 10px gap, so at 1200px one column is about 40px and the sizes a panel
+ * starts at (`defaultPanelSize`) come out at widths each reads well at: a
+ * metric card, six columns, about 290px — its number and its trend line
+ * with room, not a quarter of a wall screen; a chart, twelve, about 585px —
+ * a month of daily bars, labelled; a note, twelve, a line of text short
+ * enough to read across. It is wider than `md` (768px), so a fixed board
+ * never falls into the one-column reading any earlier than a full one; and
+ * it is about what a workbench's main column is on a laptop, so the two
+ * widths differ only where a full board would stretch — a wide monitor, a
+ * wall screen — which is where a fixed one is asked for.
+ */
+export declare const FIXED_BOARD_WIDTH = 1200;
+/**
+ * The filter tray (decisions.md D12): a wash of the muted colour and no
+ * border. The conditions inside it are the bordered things; a border around
+ * a row of bordered pills was the box-in-box the layout was rebuilt to lose.
+ */
+export declare const TRAY = "fve:rounded-lg fve:bg-muted/40 fve:p-3";
+//# sourceMappingURL=layout.d.ts.map

package/dist/ui/kit/layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/layout.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,OAAO,iEAC4C,CAAC;AAEjE;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,qDACwB,CAAC;AAErD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,KAAK;;;;;CAKR,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,IAAI,2CAA2C,CAAC"}

package/dist/ui/kit/messages.d.ts

@@ -0,0 +1,56 @@
+import { Issue } from '../../model/index.js';
+import { en } from '../messages/en.js';
+/**
+ * Wording, by key.
+ *
+ * The model carries `code` and `params` and no copy at all, which is what
+ * lets an application translate or reword any of it. This is the other half
+ * of that decision: without a catalogue the codes reach the screen, and
+ * `record.summary.unsupported` is not a sentence anybody should read.
+ *
+ * Two namespaces share one flat map: an issue's `code`, and a `label.*` key
+ * for the text a component writes itself. A missing key falls back to the key,
+ * so a gap shows up as the code it always used to show rather than as nothing.
+ *
+ * A host's overrides stay a plain string map: it may key wording of its own
+ * off the same catalogue, and nothing here ever reads a key it did not ship.
+ */
+export type ViewMessages = Readonly<Record<string, string>>;
+/**
+ * Every key this package ships, as a union.
+ *
+ * It is what a component may ask for by name, so a key deleted from the
+ * catalogue — or misspelt in JSX — is a compile error rather than a code on
+ * screen. It does not constrain what a host adds: `ViewMessages` stays open.
+ */
+export type MessageKey = keyof typeof en;
+/**
+ * A host's rewording of the engine's own keys, checked against them: write
+ * an override as `{ … } satisfies MessageOverrides`, and a key the engine
+ * renames or drops is a compile error rather than wording that silently
+ * falls back to the engine's sentence. Keys of the host's own (a
+ * definition's `text(key)`) go beside it in a `ViewMessages`, which stays
+ * open. The keys are public surface, listed in `test/surface/messages.txt`.
+ */
+export type MessageOverrides = Partial<Record<MessageKey, string>>;
+/**
+ * One entry with its params filled in.
+ *
+ * A param that is a number is a quantity — a count, a total, a page, a
+ * limit — and it is printed the way every other number on the surface is
+ * (`formatNumber`, in `locale`): 「共 624,082 条记录」 beside a summary that
+ * reads 「534,897」, not 「共 624082 条记录」. A caller whose number is a name
+ * rather than an amount — an id, a year, a row key — hands it over as a
+ * string, and a string is left exactly as it came.
+ */
+export declare function formatMessage(messages: ViewMessages, key: string, params?: Issue['params'], locale?: string): string;
+/** One issue as a sentence. */
+export declare function formatIssue(messages: ViewMessages, issue: Issue, locale?: string): string;
+/** Several issues, in order, joined for one alert. */
+export declare function formatIssues(messages: ViewMessages, issues: readonly Issue[], locale?: string): string;
+/**
+ * The English catalogue, which is what every component reads until a host
+ * says otherwise. The keys live in `messages/`, one file per prefix family.
+ */
+export declare const defaultMessages: ViewMessages;
+//# sourceMappingURL=messages.d.ts.map

package/dist/ui/kit/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/messages.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAGlD,OAAO,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAEvC;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,EAAE,CAAC;AAEzC;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;AAKnE;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,EACxB,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CAkBR;AAgGD,+BAA+B;AAC/B,wBAAgB,WAAW,CACzB,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,KAAK,EACZ,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CAER;AAED,sDAAsD;AACtD,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CAER;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,YAAgC,CAAC"}

package/dist/ui/kit/numbers.d.ts

@@ -0,0 +1,53 @@
+import { NumberFormat } from '../../model/index.js';
+/**
+ * A number as this surface prints it: in the format its field declared, and
+ * grouped in the surface's language when it declared none.
+ *
+ * It is the one fallback for every number the UI writes — a record cell, a
+ * summary, an analysis cell, a chart's axis, a count inside a sentence — so a
+ * total reads 「534,897」 in the record view and in the analysis view alike,
+ * where the record side used to print 「534897」. A field whose numbers are
+ * names rather than quantities (a year, an employee number) says so with
+ * `numberFormat: { useGrouping: false }`. A format Intl refuses to build gives
+ * way to the same plain grouping.
+ *
+ * `locale` is the surface's language, and it is not optional in spirit: a
+ * number left to `toLocaleString()` is grouped for whatever machine the page
+ * happens to run on, which is the one language nobody chose. It stays optional
+ * in the signature because a format may pin its own.
+ */
+export declare function formatNumber(value: number | bigint, format?: NumberFormat, locale?: string): string;
+/**
+ * A difference of two percentages as the points between them, signed —
+ * -0.144 is 「-14.4」 — to the decimals the percentage is written with, and
+ * at least one; one too small for them 「<+0.1」, as a percentage is.
+ */
+export declare function formatPoints(delta: number, format: NumberFormat | undefined, locale: string | undefined): string;
+/**
+ * A number format written short: the same style, currency or unit, in the
+ * language's own compact notation — 万 and 亿 in Chinese, K, M and B in
+ * English, which is what Intl's `compact` already knows — to three
+ * significant digits, as Metabase writes it: 10,230 reads 「1.02万」 and
+ * `10.2K`, and 49,818 beside 50,000 reads 「4.98万」 beside 「5万」 — one
+ * decimal made them 「1万」 and 「5万」, and a week of 4.9万s hid its ups
+ * and downs (audit P1-4). No zero is added to reach three (「5万」, not
+ * 「5.00万」), and none is invented either: a whole part longer than three
+ * digits is written whole (`morePrecision`), so 4,885 reads 「4,885」 and
+ * 12,345,678 「1,235万」 rather than 「4,890」 and 「1,230万」. The whole
+ * part is grouped as every other number on the page is — Chinese has no
+ * short word below 万, and 4,880 was the one 「4880」 beside the table's
+ * 「4,880」 (audit P2-3) — unless the format says its numbers are names
+ * that take no grouping. What the format said about decimals is dropped,
+ * since it was said about the whole number: two fraction digits on a
+ * compact figure would ask for 「1110.00万」.
+ */
+export declare function compactFormat(format: NumberFormat | undefined): NumberFormat;
+/**
+ * The formatter a field's `numberFormat` asks for, built once, or `null` when
+ * Intl will not build it. The type admits what Intl refuses — a locale such
+ * as `zh_CN`, a currency style with no currency — and the throw used to take
+ * the whole table down mid-render. The language gives way first, as a date's
+ * does; a format that still fails is dropped, and the number shows unformatted.
+ */
+export declare function numberFormatter(format: NumberFormat, surfaceLocale?: string): Intl.NumberFormat | null;
+//# sourceMappingURL=numbers.d.ts.map

package/dist/ui/kit/numbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/numbers.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,MAAM,CAAC,EAAE,YAAY,EACrB,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CASR;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,CAeR;AA6CD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,GAAG,YAAY,CAyB5E;AAID;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,YAAY,EACpB,aAAa,CAAC,EAAE,MAAM,GACrB,IAAI,CAAC,YAAY,GAAG,IAAI,CAgB1B"}

package/dist/ui/kit/popups.d.ts

@@ -0,0 +1,83 @@
+import { Dialog as DialogPrimitive } from '@base-ui/react/dialog';
+import { Menu as MenuPrimitive } from '@base-ui/react/menu';
+import { AlertDialogContent as VendoredAlertDialogContent } from '../components/alert-dialog.js';
+import { ComboboxContent as VendoredComboboxContent } from '../components/combobox.js';
+import { DialogContent as VendoredDialogContent } from '../components/dialog.js';
+import { DropdownMenuContent as VendoredDropdownMenuContent } from '../components/dropdown-menu.js';
+import { PopoverContent as VendoredPopoverContent } from '../components/popover.js';
+import { SelectContent as VendoredSelectContent } from '../components/select.js';
+import { TooltipContent as VendoredTooltipContent } from '../components/tooltip.js';
+import type * as React from 'react';
+/**
+ * The destructive dialog's two portalled elements, themed like the plain one.
+ *
+ * Same shape as `DialogContent` below and for the same reason — backdrop and
+ * popup are siblings inside the portal, so both carry the root class, the
+ * surface's mode and the popup layer. What it deliberately does not carry is
+ * a close button: an alert dialog asks a question with a cost, and the answer
+ * is one of the two in the footer rather than a corner that dismisses it.
+ *
+ * Three things here are not the registry's as it ships, and all three are
+ * about the same fact: two of the questions this draws open on **top of
+ * another dialog** — a delete and its second confirmation are raised from a
+ * row of the view manager, which is itself a `Dialog` over a dimmed page.
+ *
+ * The backdrop is `forceRender`, because Base UI does not render a nested
+ * backdrop unless asked; without it the confirmation opened with no dimming
+ * of its own and the list behind it never moved. It dims at
+ * `ALERT_DIALOG_BACKDROP_DIM` rather than the registry's 10%, because 10%
+ * over a page that is already dimmed 10% is 19% — the confirmation read as a
+ * second white card dropped into the list rather than as the one thing being
+ * asked. And the card itself carries `ALERT_DIALOG_RAISED`, which is what
+ * separates the two layers where a scrim cannot.
+ */
+export declare function AlertDialogContent({ className, size, style, finalFocus, ...props }: React.ComponentProps<typeof VendoredAlertDialogContent>): React.JSX.Element;
+export declare function ComboboxContent({ className, side, sideOffset, align, alignOffset, anchor, style, ...props }: React.ComponentProps<typeof VendoredComboboxContent>): React.JSX.Element;
+/**
+ * The one popup with no positioner, and with two portalled elements.
+ *
+ * A dialog's backdrop is the popup's *sibling* inside the portal, so putting
+ * `fve-root` on the popup alone would leave the backdrop outside every root.
+ * The build scopes the whole stylesheet to `:where(.fve-root, .fve-root *)`,
+ * so an unrooted backdrop loses every one of its utilities and paints
+ * nothing: a dialog with no dimming behind it. Both elements carry the root
+ * class and the surface's mode here, and both take the popup layer, so the
+ * host variable moves a dialog with the rest.
+ */
+export declare function DialogContent({ className, children, style, showCloseButton, finalFocus, ...props }: React.ComponentProps<typeof VendoredDialogContent>): React.JSX.Element;
+/**
+ * A side panel over the workbench — a record's detail, the visualization
+ * panel on a phone — themed like a dialog: it is one (Base UI's `Dialog`,
+ * which the registry's `Sheet` is), with the same two portalled elements, so
+ * both carry the root class, the surface's mode and the popup layer, and the
+ * close button's name comes from the catalogue.
+ *
+ * From the right edge (`side="right"`, the default) it takes the full
+ * height; on a narrow screen the width, on a wide one a reading column. From
+ * the bottom (`side="bottom"`, the registry's drawer position) it takes the
+ * width and at most four fifths of the height, scrolling inside itself, so
+ * the top of the page stays in view above it.
+ */
+export declare function SheetContent({ className, children, style, side, showCloseButton, overlayClassName, finalFocus, ...props }: DialogPrimitive.Popup.Props & {
+    side?: 'right' | 'bottom';
+    /** The registry's close button; left out where the content has its own. */
+    showCloseButton?: boolean;
+    /** Classes for the backdrop, beside the root class it always wears. */
+    overlayClassName?: string;
+}): React.JSX.Element;
+export declare function DropdownMenuContent({ align, alignOffset, side, sideOffset, anchor, className, style, finalFocus, ...props }: React.ComponentProps<typeof VendoredDropdownMenuContent> & {
+    /**
+     * What the menu is placed against when it has no trigger of its own: a
+     * chart mark or a table row that was pressed, as an element or a point.
+     */
+    anchor?: MenuPrimitive.Positioner.Props['anchor'];
+}): React.JSX.Element;
+/**
+ * A submenu's popup: the same portal, layer and theme as the menu it opens
+ * from, positioned beside its trigger as the registry's copy positions it.
+ */
+export declare function DropdownMenuSubContent({ align, alignOffset, side, sideOffset, className, ...props }: React.ComponentProps<typeof DropdownMenuContent>): React.JSX.Element;
+export declare function PopoverContent({ className, align, alignOffset, side, sideOffset, style, finalFocus, ...props }: React.ComponentProps<typeof VendoredPopoverContent>): React.JSX.Element;
+export declare function SelectContent({ className, children, side, sideOffset, align, alignOffset, alignItemWithTrigger, style, ...props }: React.ComponentProps<typeof VendoredSelectContent>): React.JSX.Element;
+export declare function TooltipContent({ className, side, sideOffset, align, alignOffset, children, style, ...props }: React.ComponentProps<typeof VendoredTooltipContent>): React.JSX.Element;
+//# sourceMappingURL=popups.d.ts.map

package/dist/ui/kit/popups.d.ts.map

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

package/dist/ui/kit/presets.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The presets `@ahoo-wang/wow-view-engine/themes.css` ships, by name, in the
+ * order it lists them (themes.md 4.1, D35) — for a host that builds its own
+ * picker, and for the completion of a `preset` prop. The values are in the
+ * stylesheet, never here: this is a list of names, which
+ * `test/themeFiles.test.ts` holds to the stylesheet's.
+ *
+ * - `neutral` — the stylesheet's own look, and the default.
+ * - `azure` — a Chinese enterprise admin look: a clear blue, 6px corners,
+ *   white cards on a grey page, a type stack with the Chinese faces first.
+ * - `porcelain` — a native desktop look: the system type, larger corners,
+ *   soft shadows, near-neutral greys.
+ * - `contrast` — high contrast: text at 7:1, edges at 4.5:1, chart
+ *   patterns on.
+ *
+ * A brand colour is not a preset: a host gives `--fve-brand` beside any of
+ * them, and each preset holds it to its own lines (theme-architecture.md 2).
+ *
+ * There are no display names: the engine draws no picker, and a host that
+ * does names them in its own words.
+ */
+export declare const BUILT_IN_PRESETS: readonly ["neutral", "azure", "porcelain", "contrast"];
+/** The name of a preset the package ships. */
+export type BuiltInPreset = (typeof BUILT_IN_PRESETS)[number];
+/**
+ * What a `preset` prop takes: a built-in preset, with completion, or the name
+ * of one the host wrote the same way (`:where([data-fve-preset='acme'])`).
+ * `string & {}` keeps the built-in names in completion while any string
+ * still type-checks; a bare `string` would swallow the union.
+ */
+export type ViewPreset = BuiltInPreset | (string & {});
+/**
+ * How dense a surface sits (themes.md 2.4, D35 Q63): the record and
+ * analysis tables' rows and cell padding, the view list's rows and the
+ * dashboard panels' padding — never a control's height, a type size or the
+ * dashboard's row. The host's call, like the preset: `data-fve-density` on
+ * `<html>` for the page, or `density` on one surface. Left out, a surface
+ * sits at the density its preset recommends (`--fve-preset-density`), and
+ * at `default` when it recommends none.
+ */
+export type ViewDensity = 'compact' | 'default' | 'comfortable';
+//# sourceMappingURL=presets.d.ts.map

package/dist/ui/kit/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/presets.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gBAAgB,wDAKnB,CAAC;AAEX,8CAA8C;AAC9C,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAEvD;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAC"}

package/dist/ui/kit/roving.d.ts

@@ -0,0 +1,32 @@
+import { KeyboardEvent } from 'react';
+/** Which way the arrows run through a group. */
+export type RovingAxis = 'row' | 'column';
+/** Moves the stop onto one member, which is what focus means to a group. */
+export declare function takeStop(node: Element | null, group: readonly HTMLElement[]): void;
+/**
+ * Keeps the invariant «exactly one member holds the stop».
+ *
+ * Called from a layout effect with no dependency list, because every render
+ * of the group is a chance for the holder to have left — a column hidden, a
+ * result replaced by a shorter one — and a group with no stop is a group
+ * the Tab key walks straight past.
+ */
+export declare function settleStop(group: readonly HTMLElement[]): void;
+/**
+ * Where an arrow lands, or `null` when the key is not one of the group's.
+ *
+ * The ends do not wrap: past the last column lies the first row, and past
+ * the last row lies whatever follows the table, so a group that sends a
+ * reader back to member one is a group with no way out. `Toolbar` wraps
+ * because a bar is a closed set of controls; these are not.
+ */
+export declare function rovingDestination(key: string, at: number, count: number, axis: RovingAxis): number | null;
+/**
+ * Moves the stop by the key pressed on a member, and says whether it did.
+ *
+ * A modifier is the browser's or the page's, never the group's: Ctrl+Home
+ * is the top of the document. A group laid out as a grid (the record
+ * cards) runs both ways in reading order, so each axis is asked in turn.
+ */
+export declare function moveStop(event: KeyboardEvent<HTMLElement>, group: readonly HTMLElement[], ...axes: readonly RovingAxis[]): boolean;
+//# sourceMappingURL=roving.d.ts.map

package/dist/ui/kit/roving.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roving.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/roving.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE3C,gDAAgD;AAChD,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,QAAQ,CAAC;AAO1C,4EAA4E;AAC5E,wBAAgB,QAAQ,CACtB,IAAI,EAAE,OAAO,GAAG,IAAI,EACpB,KAAK,EAAE,SAAS,WAAW,EAAE,GAC5B,IAAI,CAIN;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,IAAI,CAI9D;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,UAAU,GACf,MAAM,GAAG,IAAI,CAQf;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,EACjC,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,GAAG,IAAI,EAAE,SAAS,UAAU,EAAE,GAC7B,OAAO,CAeT"}