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

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

@@ -0,0 +1 @@
+{"version":3,"file":"anchor.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/anchor.ts"],"names":[],"mappings":"AAaA;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG;IAAE,qBAAqB,IAAI,OAAO,CAAA;CAAE,CAAC;AAExE,gFAAgF;AAChF,wBAAgB,WAAW,CAAC,KAAK,EAAE;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,UAAU,CAMb"}

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

@@ -0,0 +1,34 @@
+import { FieldOption, FieldTone } from '../../model/index.js';
+import { DisplayField } from './display.js';
+/** One badge: the value the record holds, the label and tone it wears. */
+export interface BadgeEntry {
+    value: unknown;
+    label: string;
+    /** The matching option's tone; absent when no option names this value. */
+    tone?: FieldTone;
+}
+/**
+ * The badges a cell wears, or `undefined` when it wears none.
+ *
+ * Three readings land here and they differ in what they require, not in what
+ * they produce. `enum` is inferred: the renderer is the kind's own, so a
+ * badge is only justified when the definition declares the choices *and*
+ * names at least one of the values — a pill around a code nobody named only
+ * makes the code look deliberate. `status` and `tags` were asked for by name,
+ * so the definition has already answered that question and a value no option
+ * names still wears its pill, showing the code it came as.
+ *
+ * An array gets one badge per entry whichever reading it is: joined into a
+ * single pill they would read as one status with a comma in its name.
+ *
+ * Each entry carries the raw value beside its label, because labels are not
+ * identities: `FieldOption.label` is free text a definition may repeat, and a
+ * list of values may repeat too, so the caller needs something better than
+ * the label to tell two badges apart. The tone rides along from the matching
+ * option, since the caller holding a label no longer has the option it came
+ * from.
+ */
+export declare function badgeEntries(value: unknown, field: DisplayField, say?: (value: string) => string): BadgeEntry[] | undefined;
+/** The label of each value an enum holds; `undefined` when none is known. */
+export declare function optionLabel(value: unknown, options: readonly FieldOption[], say?: (value: string) => string): string | undefined;
+//# sourceMappingURL=badges.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"badges.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/badges.ts"],"names":[],"mappings":"AAaA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,0EAA0E;AAC1E,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,YAAY,EACnB,GAAG,GAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAa,GACpC,UAAU,EAAE,GAAG,SAAS,CAmB1B;AAkBD,6EAA6E;AAC7E,wBAAgB,WAAW,CACzB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,SAAS,WAAW,EAAE,EAC/B,GAAG,GAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAa,GACpC,MAAM,GAAG,SAAS,CAEpB"}

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

@@ -0,0 +1,49 @@
+import { NumberFormat } from '../../model/index.js';
+import { DisplayContext } from './display.js';
+import { MessageFormatters } from './MessagesProvider.js';
+/**
+ * A number histogram's bucket key as the band it starts: 「¥0～500」 in
+ * Chinese, `¥0–500` in English — or `undefined` when the column is not such a
+ * group, or the key is not a number (a bucket with no key reads as it always
+ * did).
+ *
+ * A key alone is the band's lower bound, and a column of 「¥0.00」「¥500.00」
+ * does not say which band a row is, or how wide. The upper bound is the key
+ * plus the group's `interval`, and the two are joined in the catalogue's
+ * words (`label.analysis.band`): the dash is the language's, not Intl's —
+ * ICU writes a Chinese range with a hyphen.
+ *
+ * The bounds are written short, the way an axis writes a number
+ * (`compactFormat`: 万 and 亿, K and M), because a band is a name and
+ * 「¥10,000.00～¥20,000.00」 buries it; but only when short is exact. A
+ * band of 1,250 wide would read `1.3–2.5K` in the compact notation, a band
+ * nobody asked for, so when either bound would be rounded both are written
+ * in full with the decimals the band needs. A field whose numbers are names
+ * (`useGrouping: false`, a year) is never compacted: 2K is not a year.
+ *
+ * What both bounds say alike is said once, as Intl's own ranges do: the
+ * currency in front stays on the lower bound and a unit, a percent sign or
+ * a compact suffix behind stays on the upper — 「¥1～2万」, `10–20%`.
+ */
+export declare function bandText(value: unknown, column: {
+    interval?: number;
+    numberFormat?: NumberFormat;
+}, messages: MessageFormatters, context: DisplayContext): string | undefined;
+/**
+ * The segment `[from, to)` of a number field, written as a band is: what a
+ * condition pair `GTE`＋`LT` reads as on the applied bar, so the bar, the
+ * follow-up menu over the band pressed and the name of the view opened from
+ * it say one sentence. The bounds are what the conditions store, and an
+ * upper bound computed as a key plus an interval can carry binary noise —
+ * 0.2 + 0.1 — so each is read back at fifteen significant digits, which is
+ * all a double holds anyway.
+ */
+export declare function segmentText(from: number, to: number, format: NumberFormat | undefined, messages: MessageFormatters, context: DisplayContext): string;
+/**
+ * Whether a number reads back as itself in a format: what is printed, times
+ * a power of ten (the compact notation's 万 or K, a percentage's hundred),
+ * is the number. A rounded figure — 1,250 as 「1.3K」 — is not; nor is
+ * anything written in digits this cannot read, which then prints in full.
+ */
+export declare function writesExactly(value: number, format: NumberFormat, locale: string | undefined): boolean;
+//# sourceMappingURL=band.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"band.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/band.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,OAAO,EACd,MAAM,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,YAAY,CAAA;CAAE,EAC1D,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,cAAc,GACtB,MAAM,GAAG,SAAS,CAUpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,cAAc,GACtB,MAAM,CAQR;AAiFD;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,OAAO,CAgBT"}

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

@@ -0,0 +1,19 @@
+/** Where a chart failed: its library never arrived, or it threw drawing. */
+export type ChartStage = 'load' | 'draw';
+/**
+ * A chart that could not be drawn, carrying what the library threw.
+ *
+ * It is thrown in render, so the render boundary around the chart stands in
+ * for it and offers to draw it again, as for any other part; the boundary
+ * tells it apart by this class and hands the host a `chart` failure rather
+ * than a `render` one (D40), with the library's own error. Its message is
+ * that error's, so the fallback says what it always said.
+ */
+export declare class ChartFailure extends Error {
+    readonly stage: ChartStage;
+    /** What the library, or its loader, threw. */
+    readonly cause: unknown;
+    constructor(stage: ChartStage, cause: unknown);
+}
+export declare function isChartFailure(error: unknown): error is ChartFailure;
+//# sourceMappingURL=chartFailure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chartFailure.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/chartFailure.ts"],"names":[],"mappings":"AAaA,4EAA4E;AAC5E,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;AAEzC;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;gBAEZ,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO;CAY9C;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE"}

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

@@ -0,0 +1,13 @@
+/**
+ * Puts `value` on the clipboard, and says whether it got there.
+ *
+ * The Clipboard API first. It is secure-context only, so an application
+ * served over plain HTTP — an operations console on an internal address,
+ * the compensation console's own deployment — has no `navigator.clipboard`
+ * at all, and a permission the reader refused rejects the write. Either way
+ * the copy falls back to the document's `copy` command over a selection of
+ * the value, which every browser still carries for exactly this; only when
+ * that fails too is the answer no.
+ */
+export declare function copyText(value: string): Promise<boolean>;
+//# sourceMappingURL=copyText.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"copyText.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/copyText.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;GAUG;AACH,wBAAsB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAU9D"}

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

@@ -0,0 +1,19 @@
+/**
+ * The page's CSP nonce, as Vite and most servers publish it:
+ * `<meta property="csp-nonce" nonce="…">` (the `nonce` attribute, which a
+ * browser hides from `getAttribute` once the policy applies but keeps in the
+ * `nonce` property), or the `content` of the same tag. `undefined` on a page
+ * without one — and under no policy, nothing needs one.
+ */
+export declare function cspNonce(root?: Document | undefined): string | undefined;
+/**
+ * The grid's drag library adds its `<style>` without a nonce: the grid
+ * passes none on, and its only other source is a bundler global. So the
+ * engine adds that style itself, under the page's nonce and with the
+ * library's own rules, before the first drag — the library finds it by its
+ * id and adds nothing. Its rules match only while the library has marked
+ * `<body>` for a drag, so it is inert until then. Nothing is added on a page
+ * that publishes no nonce, where nothing needs one.
+ */
+export declare function draggableStyle(root?: Document | undefined): void;
+//# sourceMappingURL=cspNonce.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cspNonce.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/cspNonce.ts"],"names":[],"mappings":"AAwBA;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,IAAI,GAAE,QAAQ,GAAG,SAA+B,GAC/C,MAAM,GAAG,SAAS,CAMpB;AAUD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,IAAI,GAAE,QAAQ,GAAG,SAA+B,GAC/C,IAAI,CAUN"}

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

@@ -0,0 +1,26 @@
+import { CurrencyReading, FieldNumeric, NumberFormat, RecordData } from '../../model/index.js';
+import { DisplayField } from './display.js';
+import { MessageFormatters } from './MessagesProvider.js';
+/**
+ * A field as it reads on this row: money whose currency each record holds
+ * (`currencyPath`) written in the currency the row holds, where it holds
+ * one the engine can write — else as the field reads, in its digits and no
+ * currency, which is never a currency it guessed.
+ */
+export declare function inRowCurrency<F extends DisplayField>(field: F, row: RecordData | undefined): F;
+/**
+ * An aggregate of money as its currency lets it read: in the one currency
+ * its records are in, or — records in several — 「多种货币」, since a sum of
+ * yuan and yen is no amount (the kernel has already taken the number
+ * away). `undefined` where nothing is known, and the caller reads the
+ * value as it would.
+ */
+export declare function currencyText(value: unknown, reading: CurrencyReading | undefined, format: NumberFormat | undefined, messages: MessageFormatters, locale: string | undefined): string | undefined;
+/**
+ * The currency column a file writes beside money (`csvCellText`): the
+ * field's fixed currency, or the one this row's `reading` says — the
+ * record's own, or an aggregate's, which reads 「多种货币」 where its
+ * records are in several. Empty where none is known.
+ */
+export declare function currencyCsvText(numeric: FieldNumeric | undefined, reading: CurrencyReading | undefined, messages: MessageFormatters): string;
+//# sourceMappingURL=currency.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"currency.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/currency.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,UAAU,EACX,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,YAAY,EAClD,KAAK,EAAE,CAAC,EACR,GAAG,EAAE,UAAU,GAAG,SAAS,GAC1B,CAAC,CAMH;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,eAAe,GAAG,SAAS,EACpC,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,GAAG,SAAS,CAQpB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,YAAY,GAAG,SAAS,EACjC,OAAO,EAAE,eAAe,GAAG,SAAS,EACpC,QAAQ,EAAE,iBAAiB,GAC1B,MAAM,CAMR"}

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

@@ -0,0 +1,11 @@
+import { AnalysisDatePart } from '../../model/index.js';
+/**
+ * A calendar part's key as the part is called in the reader's language:
+ * the ISO weekday 1 as 「周一」 / "Mon", the hour 20 as 「20时」 / "20:00", the
+ * month 9 as 「9月」 / "Sep", the day 3 as 「3日」 / "3". Each is formatted
+ * off a fixed day of a known weekday in UTC, so no zone moves it: the key
+ * was read in its zone by the source already. A key outside the part's
+ * domain is not one of its values and is shown as it came.
+ */
+export declare function datePartValue(value: unknown, part: AnalysisDatePart, locale: string | undefined): string | undefined;
+//# sourceMappingURL=datePart.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"datePart.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/datePart.ts"],"names":[],"mappings":"AAaA,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEhF;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,GAAG,SAAS,CAkCpB"}

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

@@ -0,0 +1,293 @@
+import { AnalysisDatePart, AnalysisDateUnit, FieldNumeric, FieldOption, NumberFormat, SummaryFunction, EpochTimeUnit } from '../../model/index.js';
+import { MetricCondition, MetricFunction } from '../../analysis/index.js';
+import { MessageKey } from './messages.js';
+import { MessageFormatters } from './MessagesProvider.js';
+import { BadgeEntry } from './badges.js';
+/** Where a value is shown: the language, and the zone its times read in. */
+export interface DisplayContext {
+    /** A BCP 47 tag; the runtime's own when left out. */
+    locale?: string;
+    /** An IANA zone; the runtime's own when left out. */
+    timeZone?: string;
+    /**
+     * How a definition's words are shown here (`useSay`): an option's label
+     * is said in them. Left out, a label reads as it is written — a keyed
+     * definition's (`text(key)`) as its key, marker and all — so a host that
+     * calls `cellText` or `displayValue` itself for such a definition passes
+     * `useSay()` here (a surface's own context, `useSurfaceDisplay`, carries
+     * it already).
+     */
+    say?: (value: string) => string;
+    /**
+     * The clock "now" is read from: a table cell leaves out the year of a
+     * time in the current one (`tableTime`). A workbench and an embed pass
+     * their engine's `environment`, so a page whose clock is pinned reads
+     * the same every day; the runtime's own when left out.
+     */
+    clock?: {
+        now(): Date;
+    };
+}
+/** What a column knows about the field behind it. */
+export interface DisplayField {
+    kind?: string;
+    /** Renderer key; the kind's when the field names none. */
+    cell?: string;
+    options?: readonly FieldOption[];
+    /** How a number of this field is written, when the field says. */
+    numberFormat?: NumberFormat;
+    /**
+     * For money whose currency each record holds: where the row holds it
+     * (`currencyPathOf`). A reader holding the row writes the value in that
+     * currency (`inRowCurrency`).
+     */
+    currencyPath?: string;
+    /**
+     * What the number is by the source's semantics, where that decides how
+     * it reads (`RecordColumnView.numeric`): a file holds it raw.
+     */
+    numeric?: FieldNumeric;
+    /** For a date histogram group: its keys are the starts of these buckets. */
+    dateUnit?: AnalysisDateUnit;
+    /** The zone those buckets were cut in, when the group named one. */
+    timeZone?: string;
+    /** For a calendar part group: its keys are this part's integers. */
+    datePart?: AnalysisDatePart;
+    /**
+     * For an array of objects, the element field each element is read by and
+     * its name within the element (`FieldDefinition.elementTitle`).
+     */
+    elementTitle?: ElementTitleField;
+    /**
+     * For an array of objects that declares its elements, each element field
+     * by its name within an element — what the record detail lays one
+     * element out by (`RecordCardField.elements`).
+     */
+    elements?: readonly ElementField[];
+    /** A time field kept in epoch seconds (`epochUnitOf`); milliseconds when unsaid. */
+    timeUnit?: EpochTimeUnit;
+    /**
+     * How finely a time of day is read where the reading is short.
+     *
+     * A filter's times are set to the minute (用户 2026-09-25), so a condition
+     * says 「09:05」, not 「09:05:00」 — `'minute'`, used by the date control's
+     * trigger and the condition's summary (`displayValue`). A time that does
+     * carry seconds still says them, so no bound is ever shown other than it
+     * runs.
+     *
+     * A table cell is short by default (`tableTime`): to the minute, unless
+     * the column says `'second'` (`RecordColumnView.timePrecision`). Every
+     * other reading of a record's value keeps the seconds.
+     */
+    timePrecision?: 'minute' | 'second';
+}
+/** One field of an element, by its name within the element. */
+export interface ElementField extends DisplayField {
+    field: string;
+    label: string;
+}
+/** The element field an array of objects is read by, one element each. */
+export interface ElementTitleField extends DisplayField {
+    /** Its name within one element. */
+    name: string;
+}
+/**
+ * A value as its field shows it, or `undefined` when the field's kind has
+ * nothing to add and the caller's own rendering stands: a number keeps its
+ * format, a boolean its wording.
+ *
+ * Wow keeps a time as epoch milliseconds, so a raw table is a column of
+ * thirteen-digit numbers; and an enum is a code the definition has already
+ * named. Times read in the context's zone, which is the engine's: the one a
+ * relative filter such as "today" is evaluated in, so what a row is filtered
+ * by and what it shows agree.
+ */
+export declare function displayValue(value: unknown, field: DisplayField, context: DisplayContext): string | undefined;
+/**
+ * A time as a table cell writes it: short, and numeric where the language
+ * writes it so — `09-17 21:19` in Chinese, `Sep 17, 9:19 PM` in English —
+ * with the year only when it is not the current one (`2025-09-17 21:19`,
+ * `Sep 17, 2025, 9:19 PM`), and the seconds only when the column asks for
+ * them (`timePrecision: 'second'`). `undefined` for anything that is not a
+ * moment read as a `datetime`, or a day that names no time of day, which
+ * reads as `displayValue` says.
+ *
+ * The whole time, seconds and year included, is what `displayValue` says,
+ * and the cell carries it as its title (second review R2-23: two columns of
+ * 「2026年9月17日 21:19:08」 were 360px of a 1440px table).
+ */
+export declare function tableTime(value: unknown, field: DisplayField, context: DisplayContext): string | undefined;
+/**
+ * What a summary function is called under a column of these values.
+ *
+ * `MIN` of a number is its smallest and `MIN` of a moment is its earliest —
+ * one word each, in the vocabulary of what is being summarised, rather than
+ * one word stretched over both. The reading decides, because the reading is
+ * what the column shows; every other function keeps its one name. A record
+ * column's summary and an analysis metric are named by this one rule, so the
+ * latest of a datetime is 「最晚」 under a record column, in an analysis
+ * header and in the tray's summary select alike.
+ */
+export declare function summaryFunctionKey(fn: SummaryFunction | Exclude<MetricFunction, 'DERIVED'>, cell?: string): MessageKey;
+/**
+ * What an analysis column is called on screen.
+ *
+ * A group is its field — and a time group says what one of its rows spans,
+ * 「创建时间（按日）」, because a bucket key reads as a moment and a column of
+ * 「9月1日」 does not say whether each row is that day or that month. A metric
+ * is two words the kernel hands over separately — the field and the summary
+ * — because only a catalogue knows their order: 「金额的平均」 and "Average
+ * of Amount" are the same header. Composing it
+ * here is what makes two summaries of one field two different headers, where
+ * the alias (`amount_1`) named the machine and the label named them both the
+ * same. A count is neither: it counts records rather than summarising a
+ * field, so it says so in one word.
+ *
+ * A metric the source estimates wears 「≈」 in front of it (D20 口径): the
+ * types in `estimated`, which the projection reads off what the source says
+ * it estimates (`AnalysisProjection.approximate`, from
+ * `AnalysisCapability.approximate` — a descriptor's `analysis.approximate`,
+ * percentiles when nothing says otherwise). A p95
+ * that prints to two decimals beside an exact sum reads as exact — the sign
+ * is one character and travels everywhere the header does, the chart's axis
+ * and legend included. The word behind the sign is
+ * `label.analysis.approximate`, which the table header's tooltip and
+ * description carry (`SortableHeader`'s `note`).
+ *
+ * A metric with a condition of its own says it after a 「·」 (D20 显示名):
+ * 「金额的总和 · 已发运」 when the condition keeps one value of one field,
+ * 「金额的总和 · 有条件」 otherwise (`metricCondition`). Without it a sum over
+ * the shipped orders wore the header of a sum over all of them, and a
+ * region with none shipped read as a region with no sales.
+ */
+export declare function columnTitle(column: {
+    label: string;
+    fn?: MetricFunction;
+    /**
+     * Whether the source estimates it (`AnalysisColumnView.approximate`);
+     * left out, read off `estimated`.
+     */
+    approximate?: boolean;
+    named?: true;
+    /** The reading of the values under it: a date's `MIN` is its earliest. */
+    cell?: string;
+    /** A time group's granularity: what one of its rows spans. */
+    dateUnit?: AnalysisDateUnit;
+    /** A calendar part group's part: what its rows fold together. */
+    datePart?: AnalysisDatePart;
+    /** A metric's own condition: the one value it keeps, when it is one. */
+    condition?: Pick<MetricCondition, 'value'>;
+}, messages: MessageFormatters, 
+/**
+ * The metric types the source estimates (`AnalysisProjection.approximate`);
+ * percentiles where the caller holds no view.
+ */
+estimated?: readonly string[]): string;
+/**
+ * One day as `2026-09-20`, on the surface's clock.
+ *
+ * `en-CA` is what writes a date in that order whatever the host's language,
+ * and the calendar is pinned to the Gregorian one: a file named for a Hijri
+ * day would sort beside nothing and name a day the data is not filed under.
+ * It is the zone the surface shows times in, so the day in the file's name is
+ * the day its rows read as.
+ */
+export declare function isoDay(date: Date, context: DisplayContext): string;
+/**
+ * When something was read, as a reader glances at it (「更新于 10:32」): the
+ * time of day on the surface's clock, in its language, and the date before
+ * it once that was not today — a board left open overnight must not pass
+ * yesterday's numbers off as this morning's.
+ */
+export declare function readingTime(at: Date, now: Date, context: DisplayContext): string;
+/**
+ * The bucket of records with no value, in the surface's words — 「（空）」 —
+ * when `value` is the engine's sentinel key for a group that keeps one
+ * (`AnalysisColumnView.missingKey`); `undefined` for any other value.
+ *
+ * The sentinel is a stored key, one string in every language, because it
+ * travels to Wow and back as the bucket's own key; what a reader sees is the
+ * interface's to say. A key the analyst wrote themselves — 「未上报城市」 —
+ * is their name for the bucket and reads as written, and a value that only
+ * spells the sentinel on a group without one is some record's own value.
+ */
+export declare function missingText(value: unknown, column: {
+    missingKey?: string;
+    role?: 'group' | 'metric';
+}, messages: MessageFormatters): string | undefined;
+/**
+ * A value an analysis shows when its field's kind has nothing to add: a number
+ * as `formatNumber` prints it; a boolean in the catalogue's words; anything
+ * else as text. A table cell, a chart axis and a tooltip read the same, so a
+ * currency metric is not a bare number on the axis.
+ */
+export declare function valueText(value: unknown, messages: MessageFormatters, format?: NumberFormat, locale?: string): string;
+/**
+ * One cell as text, for somewhere a React node cannot go — a CSV file, a
+ * copied selection, a title attribute.
+ *
+ * It is the same reading `cellValue` draws and deliberately the same code
+ * path: the badges come from `badgeEntries`, the times and enums from
+ * `displayValue`, the numbers and booleans from the rules under them. What it
+ * drops is only what a node carries and a line of text cannot — a badge is
+ * its label, a link is its URL, a clamped paragraph is the whole paragraph.
+ * Several badges, several elements or several plain values read as one list
+ * joined by the catalogue's separator, the way the cell reads out loud; an
+ * array of objects or an object reads as `heldReading` says.
+ *
+ * An option's label is said through `context.say`: give it (`useSay()`)
+ * for a definition written in keys, or the text carries the keys (D2).
+ */
+export declare function cellText(value: unknown, field: DisplayField, messages: MessageFormatters, context: DisplayContext): string;
+/**
+ * Several readings as one line, joined by the catalogue's list separator —
+ * 「、」 in Chinese, ", " in English — the one every read-out list in this
+ * package is joined by.
+ */
+export declare function labelsOf(entries: readonly BadgeEntry[], messages: MessageFormatters): string;
+/**
+ * What a value holding structure reads as: an array of objects, or an
+ * object. `undefined` for anything else — a scalar, or a list of scalars —
+ * which the readings after it answer.
+ *
+ * **Never as JSON.** On the Wow event stream the events of one stream sit in
+ * an array `body` of objects, each carrying its payload; written out, one
+ * cell held a stack trace and pushed the table far off the screen, while
+ * saying nothing an operator asked — which step was this? So:
+ *
+ * - with an element title declared, the array reads as **its elements**,
+ *   each by that field and the way that field reads (`elements`): an enum
+ *   element field wears its option's label and tone, a string its text. One
+ *   entry per element, as a list of tags is one badge per tag: joined into
+ *   one they would read as one name with a comma in it. An element whose
+ *   title is empty is still an element, and reads as untitled rather than
+ *   dropping out of the count;
+ * - without one, it reads as **how many** it holds — 「3 项」 — which is true,
+ *   short, and all that can be said without knowing what an element is;
+ * - an object that is not an array reads as how many fields it holds, for
+ *   the same reason, unless the field names a title, when it is the one
+ *   element it is.
+ *
+ * An empty array or object holds nothing and reads as nothing, as an empty
+ * list of tags draws no badge.
+ */
+export declare function heldReading(value: unknown, field: DisplayField, messages: MessageFormatters, context: DisplayContext): {
+    elements: BadgeEntry[];
+} | {
+    text: string;
+} | undefined;
+/**
+ * One cell as a CSV file holds it: the screen's reading (`cellText`), except
+ * a number no format was declared for, which is written as the number it is.
+ *
+ * On screen such a number is grouped for the reader — 534,897 — but a CSV is
+ * read by a spreadsheet, and `534,897` in a CSV is a string no column sums.
+ * A number whose field *declares* a format (a currency, a percentage) keeps
+ * it: the author said how it reads, and the file says the same. One whose
+ * reading comes from the source's semantics instead (`numeric`: a decimal,
+ * money) is written as the number it is, and money's currency goes in a
+ * column of its own beside it (`currencyCsvText`) — a column of `¥1,204.50`
+ * and `JP¥1,205` is text no spreadsheet adds up, nor tells apart.
+ */
+export declare function csvCellText(value: unknown, field: DisplayField, messages: MessageFormatters, context: DisplayContext): string;
+//# sourceMappingURL=display.d.ts.map

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

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

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

@@ -0,0 +1,29 @@
+/** A file the user is being handed, before the browser is asked to take it. */
+export interface DownloadedFile {
+    name: string;
+    /** What the file holds: text — a CSV, an SVG — or bytes, a PNG. */
+    content: string | Blob;
+    /** The media type the blob is made with; the browser names the file by it. */
+    type: string;
+}
+/**
+ * Hands a file to the browser.
+ *
+ * The whole of the DOM this feature needs, in one function and in `/ui`: a
+ * blob, an object URL and an anchor that clicks itself. Revoking the URL in a
+ * `finally` rather than on a timer is safe because the click is synchronous —
+ * the browser has taken the blob by the time this returns — and it is a
+ * `finally` so that a click the browser refuses frees the blob all the same,
+ * rather than holding the whole file in memory for the rest of the session.
+ */
+export declare function downloadFile(file: DownloadedFile): void;
+/**
+ * A file name from a view's title and a day: `订单待办-2026-09-20.csv`.
+ *
+ * The title is the user's own words, so it is kept as it is but for what a
+ * file system will not take and for its length; a title that is blank or all
+ * punctuation leaves the day to name the file by itself rather than a file
+ * called `-.csv`.
+ */
+export declare function fileName(title: string, day: string, extension: string): string;
+//# sourceMappingURL=download.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"download.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/download.ts"],"names":[],"mappings":"AAaA,+EAA+E;AAC/E,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAgBvD;AAwBD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,GAChB,MAAM,CAaR"}

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

@@ -0,0 +1,51 @@
+/**
+ * As much of a drag event as an announcement reads.
+ *
+ * The plugin's own option bag is untyped at the call site, so the callbacks
+ * say what they need rather than inheriting `any` and losing every check
+ * inside them.
+ */
+export interface DragAnnouncement {
+    operation: {
+        source?: {
+            id: string | number;
+        } | null;
+    };
+    canceled?: boolean;
+}
+/**
+ * What a drag says for itself: the instructions on the handle, and the two
+ * sentences with the thing it carries named. `dragWording.ts` reads them
+ * out of the catalogue.
+ */
+export interface DragWording {
+    instructions: string;
+    picked(name: string): string;
+    cancelled(name: string): string;
+}
+/**
+ * What a screen reader hears while something is being dragged — the column
+ * settings, the sort editor, the view manager and the panel's series list
+ * are the lists that are, and they share this because the sentences differ
+ * only in the words.
+ *
+ * The library ships English sentences built from the ids it is carrying,
+ * which here are field names and instance ids: "Picked up draggable item
+ * createdAt". Wording and language belong to the catalogue like every other
+ * word on screen, and the ids are turned back into the labels the user is
+ * reading.
+ *
+ * A completed drop says nothing on purpose. Where the row landed is announced
+ * once by the list itself, for a drop and for an arrow key alike, so the same
+ * move is never read out twice.
+ */
+export declare function dragAccessibility(say: DragWording, nameOf: (id: string) => string): {
+    screenReaderInstructions: {
+        draggable: string;
+    };
+    announcements: {
+        dragstart: (event: DragAnnouncement) => string | undefined;
+        dragend: (event: DragAnnouncement) => string | undefined;
+    };
+};
+//# sourceMappingURL=dragAnnounce.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dragAnnounce.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/dragAnnounce.ts"],"names":[],"mappings":"AAaA;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE;QAAE,MAAM,CAAC,EAAE;YAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,GAAG,IAAI,CAAA;KAAE,CAAC;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM;;;;;2BAQP,gBAAgB;yBAIlB,gBAAgB;;EAMtC"}

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

@@ -0,0 +1,36 @@
+/**
+ * What every list here makes of a finished drag, before it makes anything of
+ * its own — beside `dragAnnounce.ts`, which is what the same drag says out
+ * loud.
+ */
+/** As much of a finished drag as a drop reads. */
+export interface DropOperation {
+    source?: {
+        id: string | number;
+    } | null;
+    target?: {
+        id: string | number;
+    } | null;
+}
+/** The two items one drop is between, by the ids the library carried. */
+export interface Drop {
+    source: string;
+    target: string;
+}
+/**
+ * The drop this was, or null — the one guard every sortable list here
+ * shares.
+ *
+ * A drag that was given up is not a drop, and neither is one that ended on
+ * the row it started from: both would spend a write — a query, a revision —
+ * to put the list back in the order it is already in. Everything past that
+ * is the list's own business: which entry a position names, whether the two
+ * rows are in the same audience, whether both aliases name a series this
+ * chart draws.
+ *
+ * The ids come back as strings because that is what the lists read them as:
+ * the library types them `string | number`, and a numeric id compared
+ * against a field name would be a comparison that never matched.
+ */
+export declare function dropped(operation: DropOperation, canceled: boolean | undefined): Drop | null;
+//# sourceMappingURL=dragDrop.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dragDrop.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/dragDrop.ts"],"names":[],"mappings":"AAaA;;;;GAIG;AAEH,kDAAkD;AAClD,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACxC,MAAM,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACzC;AAED,yEAAyE;AACzE,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CACrB,SAAS,EAAE,aAAa,EACxB,QAAQ,EAAE,OAAO,GAAG,SAAS,GAC5B,IAAI,GAAG,IAAI,CAIb"}