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

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

@@ -0,0 +1,45 @@
+import { FieldOption } from '../../model/index.js';
+import { AnalysisEditorController, FilterEditorController } from '../../react/index.js';
+export interface TrayProps {
+    filter: FilterEditorController;
+    analysis: AnalysisEditorController;
+    optionsFor?(remote: string): FieldOption[] | undefined;
+    disabled?: boolean;
+    /** Auto-run: the preference and the way to change it (`WorkbenchController`). */
+    autoRun?: {
+        on: boolean;
+        set(on: boolean): void;
+    };
+}
+/**
+ * The analysis view's editor: the question itself, one row a step, in the
+ * order each step depends on the one before (D71, revising D20) —
+ *
+ * 1. **展开** (only where the capability declares a chain): what one
+ *    counted thing is, which decides the fields every row after it names;
+ * 2. **指标**: the numbers, which a derived metric reads in order;
+ * 3. **维度**: what they are compared by;
+ * 4. **结果** (only with a dimension): which groups are kept, in what
+ *    order, how many — it names the metrics and dimensions above it;
+ * 5. **范围**: the records it runs over, last because it depends on nothing
+ *    above it — it narrows the outermost records whatever is expanded.
+ *
+ * Each row is a named `section` headed by the analyst's term with an ⓘ
+ * that says it in a sentence (`EditorSlot`, `TermTip`).
+ *
+ * One footer runs the whole draft: the range's conditions and the question
+ * are one config, and `runtime.apply` runs it once, so the one primary on
+ * the screen is Apply (D17-3), at the footer's end, resting quiet while
+ * nothing waits for it. How the result is looked at — table or chart, and
+ * which chart — is not in here: it is the result's, on its toolbar and in
+ * the visualization panel (D20).
+ *
+ * The rows scroll and the footer does not. The band the tray folds into is
+ * capped at half the work column (`styles.css`, "The editor takes at most
+ * half"), and what scrolls inside that cap is the question: Apply is how a
+ * draft gets run, and a footer scrolled out of sight under a long range is
+ * a button the analyst has to go looking for. The notice of what an edit
+ * took out stands just above it for the same reason (`DroppedNotice`).
+ */
+export declare function Tray({ filter, analysis, optionsFor, disabled, autoRun, }: TrayProps): import('react').JSX.Element;
+//# sourceMappingURL=Tray.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Tray.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/Tray.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EACV,wBAAwB,EACxB,sBAAsB,EACvB,MAAM,sBAAsB,CAAC;AAiB9B,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,QAAQ,EAAE,wBAAwB,CAAC;IACnC,UAAU,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,GAAG,SAAS,CAAC;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iFAAiF;IACjF,OAAO,CAAC,EAAE;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAA;KAAE,CAAC;CACnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,IAAI,CAAC,EACnB,MAAM,EACN,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,OAAO,GACR,EAAE,SAAS,+BAmKX"}

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

@@ -0,0 +1,68 @@
+import { ReactElement, RefObject } from 'react';
+import { ChartSpec } from '../../model/index.js';
+import { AnalysisResultController } from '../../react/index.js';
+/** The visualization panel's two levels: the chart types, then the options. */
+export type VisualizationLevel = 'picker' | 'options';
+/** Where the keyboard is put as the panel's level moves. */
+export interface VisualizationFocus {
+    /** The heading of the level on screen. */
+    heading: RefObject<HTMLHeadingElement | null>;
+    /**
+     * The chosen tile's options icon (D72): where the options page is left
+     * back to.
+     */
+    optionsButton: RefObject<HTMLButtonElement | null>;
+    /** The control that opened the panel: where closing it hands back to. */
+    visualizeRef: RefObject<HTMLButtonElement | null>;
+}
+/**
+ * The keyboard follows the level (A1).
+ *
+ * The panel replaces its own contents as the level changes, so every one of
+ * those changes would leave the focus on an element that is no longer on the
+ * page — the press that opened it, the options icon, the way back — and a
+ * focus with nothing under it falls to `<body>`. Each level therefore takes
+ * the keyboard to its own heading, except coming back from the options,
+ * which lands on the chosen tile's options icon the user left by (D72);
+ * closing the panel (`null`, where a host can close it) hands it back to
+ * the button that opened it. Both are where the user was.
+ *
+ * It is an effect keyed on the level rather than anything done inside the
+ * press: the heading does not exist until React has drawn the level, and a
+ * timer waiting for that would be a guess.
+ */
+export declare function useVisualizationFocus(level: VisualizationLevel | null): VisualizationFocus;
+export interface VisualizationPanelProps {
+    /** The level on screen; nothing is drawn for `null`. */
+    level: VisualizationLevel | null;
+    focus: VisualizationFocus;
+    result: Pick<AnalysisResultController, 'fits' | 'picked' | 'choose' | 'chart' | 'columns' | 'view' | 'question' | 'chartData'>;
+    /** Whether the totals row is on, and the way it is switched. */
+    totals: boolean;
+    onTotals(on: boolean): void;
+    /** A chart the options page wrote. */
+    onChange(chart: ChartSpec): void;
+    /** A move between the two levels. */
+    onLevel(level: VisualizationLevel): void;
+    /** The picker's way back, where the host can close the panel. */
+    onBack?(): void;
+    /** What that way back is called (`ChartPickerProps.backLabel`). */
+    backLabel?: string;
+}
+/**
+ * The visualization panel (D20 屏 I／J) as the workbench and a dashboard
+ * panel's own look both draw it: the chart types, then the chosen type's
+ * options, both fitting the question's shape. The options stand over the
+ * question, so they work before the first answer and after it failed: the
+ * slots name its columns, and what reads rows — a funnel's stages in the
+ * order they came — has none yet. With no question the options level draws
+ * nothing.
+ *
+ * A function rather than a component, so a host reads the one it gets back
+ * as React reads a child: `null` is no panel at all (the sidebar's column
+ * shows the list instead).
+ */
+export declare function visualizationPanel({ level, focus, result, totals, onTotals, onChange, onLevel, onBack, backLabel, }: VisualizationPanelProps): ReactElement | null;
+/** A command a host that cannot take it answers with: nothing happens. */
+export declare function ignore(): void;
+//# sourceMappingURL=VisualizationPanel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VisualizationPanel.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/VisualizationPanel.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAqB,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAE7E,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAKrE,+EAA+E;AAC/E,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEtD,4DAA4D;AAC5D,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,OAAO,EAAE,SAAS,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAC;IAC9C;;;OAGG;IACH,aAAa,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IACnD,yEAAyE;IACzE,YAAY,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;CACnD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,kBAAkB,GAAG,IAAI,GAC/B,kBAAkB,CAkBpB;AAED,MAAM,WAAW,uBAAuB;IACtC,wDAAwD;IACxD,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACjC,KAAK,EAAE,kBAAkB,CAAC;IAC1B,MAAM,EAAE,IAAI,CACV,wBAAwB,EACtB,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,SAAS,GACT,MAAM,GACN,UAAU,GACV,WAAW,CACd,CAAC;IACF,gEAAgE;IAChE,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,sCAAsC;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACjC,qCAAqC;IACrC,OAAO,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACzC,iEAAiE;IACjE,MAAM,CAAC,IAAI,IAAI,CAAC;IAChB,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,KAAK,EACL,KAAK,EACL,MAAM,EACN,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,MAAM,EACN,SAAS,GACV,EAAE,uBAAuB,GAAG,YAAY,GAAG,IAAI,CAmD/C;AAED,0EAA0E;AAC1E,wBAAgB,MAAM,IAAI,IAAI,CAAG"}

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

@@ -0,0 +1,19 @@
+import { LucideIcon } from 'lucide-react';
+import { ChartType } from '../../model/index.js';
+/**
+ * One glyph per way of drawing a result, drawn wherever that way is named:
+ * the visualization panel's tiles (`ChartPicker`) and the result toolbar's
+ * 「图表」 segment (`AnalysisToolbar`), which shows the type the chart layout
+ * will draw — so the two never disagree about what a pie looks like.
+ */
+export declare const CHART_ICON: Record<ChartType | 'table', LucideIcon>;
+/**
+ * The chart type whose glyph stands for `type`: the type itself, or the
+ * bar — the generic chart — where it is not one this package draws; a config
+ * arrives from a store, and a type a later version wrote is refused by the
+ * kernel, not drawn as a blank. A key rather than the icon, so a caller
+ * looks the component up in `CHART_ICON` as the picker does, and never makes
+ * one during render.
+ */
+export declare function glyphType(type: string | undefined): ChartType;
+//# sourceMappingURL=chartIcons.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chartIcons.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/chartIcons.ts"],"names":[],"mappings":"AAaA,OAAO,EAwBL,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,EAAE,UAAU,CAqC9D,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAM7D"}

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

@@ -0,0 +1,39 @@
+import { DragWordingKeys } from '../kit/dragWording.js';
+import { DropOperation } from '../kit/dragDrop.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+/** The two places one drop on a list is between. */
+export interface ListDrop {
+    from: number;
+    to: number;
+}
+/**
+ * The move a finished drag on one of the panel's lists is, or null.
+ *
+ * Each list carries its rows under a key of its own — a series under the
+ * alias of the metric it draws, a stage under its metric or its value, a
+ * level under its dimension's alias — so the two ids the drop reports are
+ * two of those keys, and no separate identity has to be invented for the
+ * library to hold. Whether there was a drop at all is the guard every
+ * sortable list here shares ({@link dropped}); what is added on top is that
+ * both ids name a row of *this* list, since the panel is not the only
+ * draggable thing the page holds.
+ */
+export declare function listDrop(keys: readonly string[], operation: DropOperation, canceled: boolean | undefined): ListDrop | null;
+/** Where the panel's lists' drag sentences live in the catalogue. */
+export declare const CHART_DRAG_WORDING: DragWordingKeys;
+/**
+ * What a screen reader hears while a row of the panel is being carried: the
+ * shared wording of a drag ({@link dragAccessibility}) said in the panel's
+ * own words, with the keys the library is holding turned back into the
+ * names on screen.
+ */
+export declare function chartDragAccessibility(messages: MessageFormatters, nameOf: (key: string) => string): {
+    screenReaderInstructions: {
+        draggable: string;
+    };
+    announcements: {
+        dragstart: (event: import('../kit/dragAnnounce.js').DragAnnouncement) => string | undefined;
+        dragend: (event: import('../kit/dragAnnounce.js').DragAnnouncement) => string | undefined;
+    };
+};
+//# sourceMappingURL=drag.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drag.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/drag.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC1E,OAAO,EAAW,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,oDAAoD;AACpD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,SAAS,EAAE,aAAa,EACxB,QAAQ,EAAE,OAAO,GAAG,SAAS,GAC5B,QAAQ,GAAG,IAAI,CAOjB;AAED,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,EAAE,eAIhC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM;;;;;;;;EAGhC"}

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

@@ -0,0 +1,69 @@
+import { freeAlias, MetricCondition } from '../../analysis/index.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+import { AnalysisDateUnit, AnalysisGroup, AnalysisMetric } from '../../model/index.js';
+import { AnalysisEditorController, AnalysisFieldOption } from '../../react/index.js';
+export { freeAlias };
+/**
+ * What the tray builds when a field is picked — the dimension or the metric
+ * a field starts as, under a free alias — and what a metric is called. The
+ * shapes are the analysis kernel's one builder of each (`groupOfType`,
+ * `metricOfSummary`); this only picks the tray's alias and first choice.
+ * Pure, so the cards stay markup and the tests read the rules straight.
+ */
+/**
+ * What naming a metric reads: the fields its formula or summary is over,
+ * the other metrics a derived one refers to, and — where there is a runtime
+ * to read them — the fields and kinds its own condition is read by.
+ */
+export type MetricNaming = Pick<AnalysisEditorController, 'fields' | 'metrics'> & Partial<Pick<AnalysisEditorController, 'conditionFields' | 'kinds' | 'approximate'>>;
+/** The condition a metric counts under, read as its result column reads it. */
+export declare function conditionOf(analysis: MetricNaming, metric: AnalysisMetric): MetricCondition | undefined;
+/** Every alias in use, which is the set an addition must stay clear of. */
+export declare function usedAliases(analysis: AnalysisEditorController): string[];
+/**
+ * The dimension a field picked on the tray starts as: the first shape its
+ * capability offers, a time dimension at the granularity recommended for the
+ * range (K4). The shape is the kernel's one builder's (`groupOfType`).
+ */
+export declare function defaultGroup(field: AnalysisFieldOption, taken: readonly string[], unit?: AnalysisDateUnit): AnalysisGroup;
+/** The metric a field picked on the tray starts as: the first way it can be measured. */
+export declare function defaultMetric(field: AnalysisFieldOption, taken: readonly string[]): AnalysisMetric;
+/** The field a metric measures, or none for a count and a derived metric. */
+export declare function fieldOfMetric(metric: AnalysisMetric): string;
+/**
+ * What a metric is called on the tray: the name the analyst gave, else
+ * what the metric composes — the record count's own word, a formula or a
+ * derived metric said as its author would, a field's label otherwise.
+ */
+export declare function metricName(analysis: MetricNaming, metric: AnalysisMetric, messages: MessageFormatters): string;
+/**
+ * What a metric is called *away from its own card* — in「只保留」, in the
+ * sort, as an operand of a derived metric, and in any label that names one.
+ *
+ * The card's own title says the bare field name, because the summary
+ * combobox sits right beside it and says the rest. Everywhere else there is
+ * no such neighbour, so 「金额的总和」 and 「金额的平均」 would read as one
+ * name. This composes the summary in exactly the way the result column and
+ * the chart slots do — `columnTitle` over the same label and the same
+ * function — so a metric reads the same word wherever it is mentioned.
+ * Its own condition goes along too (D20 显示名): two cards over one field
+ * that differ only in what they count are 「金额的总和」 and 「金额的总和 ·
+ * 已发运」 here as they are in the result.
+ */
+export declare function metricReference(analysis: MetricNaming, metric: AnalysisMetric, messages: MessageFormatters): string;
+/**
+ * What a dimension is called away from its own card — in the sort, in a
+ * finding — as its result column is headed: the name the analyst gave, else
+ * its field, a time dimension with its granularity (「创建时间（按日）」) or
+ * its cycle (「下单时间（星期）」).
+ */
+export declare function groupReference(analysis: Pick<MetricNaming, 'fields'>, group: AnalysisGroup, messages: MessageFormatters): string;
+/**
+ * The name a metric falls back to without one of its own. `composed` is for
+ * a name a summary is put around (`metricReference`): a formula is then
+ * bracketed, 「(金额 − 成本)的总和」, as its result column is
+ * (`projectAnalysis`) — bare, the sum read as belonging to 成本 alone. Its
+ * own card says it bare, with the summary control beside it.
+ */
+export declare function metricFallbackName(analysis: MetricNaming, metric: AnalysisMetric, messages: MessageFormatters, composed?: boolean): string;
+//# sourceMappingURL=editing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editing.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/editing.ts"],"names":[],"mappings":"AAaA,OAAO,EAIL,SAAS,EAOT,KAAK,eAAe,EACrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,OAAO,EAAE,SAAS,EAAE,CAAC;AACrB,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;GAMG;AAEH;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAC7B,wBAAwB,EACxB,QAAQ,GAAG,SAAS,CACrB,GACC,OAAO,CACL,IAAI,CAAC,wBAAwB,EAAE,iBAAiB,GAAG,OAAO,GAAG,aAAa,CAAC,CAC5E,CAAC;AAEJ,+EAA+E;AAC/E,wBAAgB,WAAW,CACzB,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE,cAAc,GACrB,eAAe,GAAG,SAAS,CAM7B;AAED,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,QAAQ,EAAE,wBAAwB,GAAG,MAAM,EAAE,CAExE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,IAAI,CAAC,EAAE,gBAAgB,GACtB,aAAa,CAOf;AAED,yFAAyF;AACzF,wBAAgB,aAAa,CAC3B,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,cAAc,CAGhB;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAI5D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,iBAAiB,GAC1B,MAAM,CAIR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,iBAAiB,GAC1B,MAAM,CAsBR;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,EACtC,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,iBAAiB,GAC1B,MAAM,CAoBR;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,UAAQ,GACf,MAAM,CAqBR"}

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

@@ -0,0 +1,60 @@
+import { AnalysisProjection } from '../../analysis/index.js';
+import { CsvOptions } from '../../record/export.js';
+import { ViewRuntime } from '../../runtime/index.js';
+import { DisplayContext } from '../kit/display.js';
+import { ExportWindowProps } from '../kit/ExportDialog.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+/** An analysis result as the file that takes it away holds it. */
+export interface AnalysisFile {
+    /** The header row: what each column is headed in the table. */
+    columns: readonly {
+        label: string;
+    }[];
+    /**
+     * Every row the file holds, as read — before the writer escapes it or
+     * neutralizes a formula in it; the totals row last, where shown.
+     */
+    rows: readonly (readonly string[])[];
+    /** The CSV itself (`writeCsv`), byte order mark included. */
+    text: string;
+}
+/**
+ * The result as its table reads it, as a file (D25 Q28): the group columns
+ * first and the metrics after them, each in the order the table draws it
+ * and headed as the table heads it (`columnTitle`); every group on screen —
+ * the first N, never the probe row that said there are more; and the totals
+ * row last where the table shows one, 「合计」 in its first column.
+ *
+ * It is read off the view (`AnalysisProjection`), never off the chart's
+ * projection: the 0 a chart fills into a missing combination and the
+ * 「其他」 a pie folds its tail into are drawn, not measured (D23 Q14), so
+ * the file is the same whether the table or the chart is showing.
+ *
+ * Every cell is read as the table's cell reads it (`analysisCellText`) —
+ * a count as 1,204 and an amount in its currency, as on screen: every
+ * metric carries the format the kernel settled for it (`metricFormat`), so
+ * the file writes the figure the reader saw rather than a second, rawer one.
+ */
+export declare function analysisFile(view: AnalysisProjection, messages: MessageFormatters, display: DisplayContext, options?: CsvOptions): AnalysisFile;
+/**
+ * What the export window (`ExportDialog`, D14) is handed for one analysis —
+ * the workbench's result toolbar and an analysis panel's 「导出数据…」 alike
+ * (D25 Q28) — or `null` while there is no group to take away: before the
+ * first answer, after one that failed, and over a range that matched
+ * nothing, as the record view offers no export over no result (P-17).
+ *
+ * The rows are in hand, so there is no scope to pick and nothing to wait
+ * for: the window says what the file holds (`holds`), and 「导出」 goes
+ * straight to the outcome. The conditions are those the rows came back
+ * under — the view's own, the host's scope and, in a panel, the board's
+ * filters as they reach it — named as the record export names them.
+ *
+ * Called inside the surface (`ViewSurface`), as `useExportOffer` is: the
+ * wording, the language and the zone are the surface's.
+ */
+export declare function useAnalysisExportOffer({ runtime, title, }: {
+    runtime: ViewRuntime | null;
+    /** The view's or the panel's title, which names the file. */
+    title: string;
+}): ExportWindowProps | null;
+//# sourceMappingURL=exportOffer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exportOffer.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/exportOffer.ts"],"names":[],"mappings":"AAcA,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAO1D,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAG7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,4BAA4B,CAAC;AAKpC,kEAAkE;AAClE,MAAM,WAAW,YAAY;IAC3B,+DAA+D;IAC/D,OAAO,EAAE,SAAS;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACtC;;;OAGG;IACH,IAAI,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC;IACrC,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,kBAAkB,EACxB,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,cAAc,EACvB,OAAO,GAAE,UAAe,GACvB,YAAY,CAsEd;AAoCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,OAAO,EACP,KAAK,GACN,EAAE;IACD,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAC5B,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,iBAAiB,GAAG,IAAI,CA8D3B"}

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

@@ -0,0 +1,66 @@
+import { AnalysisSort } from '../../model/index.js';
+import { AnalysisEditorController } from '../../react/index.js';
+/** What the analysis table's headers read and write the sort through. */
+export interface HeaderSorting {
+    /** The order the rows on screen are in: the sort of the config that ran. */
+    sort: readonly AnalysisSort[];
+    /**
+     * The draft's sort: the order a press is worked out from, and the one
+     * Apply will run while a sort waits for it.
+     */
+    drafted: readonly AnalysisSort[];
+    /**
+     * The sort one plain press on a column's header would leave — what its
+     * name says the press does, worked out exactly as `onToggle` will.
+     */
+    next(alias: string): AnalysisSort[];
+    /**
+     * One press on a column's header. A plain press orders the groups by that
+     * column alone; `exclusive: false` — Shift, Ctrl or ⌘ held — adds it to
+     * the order instead, as the record table's header does.
+     */
+    onToggle(alias: string, options?: {
+        exclusive?: boolean;
+    }): void;
+}
+/**
+ * The sort after one plain press on a header: ascending, descending, then
+ * back to the view's own order.
+ *
+ * The record table's third press takes the column out of the sort, and
+ * there that is the view's order — a record view with no sort is still the
+ * rows the conditions select. An analysis is not: its sort decides **which**
+ * groups 「前 N 组」 keeps, so the order a header press took the table away
+ * from is the one it has to come back to, whatever it was (`base`: the sort
+ * in force when the presses began). Where that order already was this
+ * column descending, descending *is* the way back, and the column turns
+ * between its two directions.
+ */
+export declare function headerSorted(current: readonly AnalysisSort[], alias: string, base: readonly AnalysisSort[]): AnalysisSort[];
+/**
+ * The header's half of the analysis editor: the order on screen, and a press
+ * written through the editor.
+ *
+ * **It runs when nothing else waits** (`sortNow`). A sort is a question
+ * member, so a tray edit to it runs on its own a moment later (「改了就跑」)
+ * — but not while the range waits for Apply, nor with auto-run switched off,
+ * and a header that answered a press by changing nothing on screen would
+ * look broken; so a press on its own runs at once, as the record table's
+ * header does. But it never applies what else the draft holds: with a range
+ * condition or a tray edit waiting, the sort joins them, the pending dot
+ * shows on Apply, and Apply runs them together — the metric card's whole
+ * keeps the same rule.
+ *
+ * Two readings of the sort, on purpose. The arrows and `aria-sort` say the
+ * order of the rows on screen (`shown`, the config that ran): a header that
+ * pointed down over rows that go up would be lying about them. The next
+ * press is worked out from the draft's sort, which is that same order
+ * whenever nothing waits and otherwise the order Apply is about to run —
+ * so pressing twice while it waits still goes ascending, then descending.
+ * `base` remembers the order the presses started from, for as long as the
+ * draft's sort is the one a press wrote; a sort that arrived any other way
+ * — the tray, a saved view, a revert — starts a new run of presses from
+ * itself.
+ */
+export declare function useHeaderSort(analysis: AnalysisEditorController, shown: readonly AnalysisSort[]): HeaderSorting;
+//# sourceMappingURL=headerSort.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"headerSort.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/headerSort.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,yEAAyE;AACzE,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,IAAI,EAAE,SAAS,YAAY,EAAE,CAAC;IAC9B;;;OAGG;IACH,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IACjC;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,EAAE,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;CAClE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,SAAS,YAAY,EAAE,GAC5B,YAAY,EAAE,CAKhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,wBAAwB,EAClC,KAAK,EAAE,SAAS,YAAY,EAAE,GAC7B,aAAa,CA6Bf"}

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

@@ -0,0 +1,40 @@
+import { ViewRuntime } from '../../runtime/index.js';
+import { CaptureChart, ChartImageSlot } from '../charts/image.js';
+/** The two pictures a chart is taken away as (D33 Q58). */
+export type ImageFormat = 'png' | 'svg';
+/**
+ * Where the chart a surface draws hands itself over (`ChartImageTarget`),
+ * and what it handed over: `capture` is set while a drawing is on screen
+ * and taken back as it goes, so an offer of its picture comes and goes
+ * with it.
+ */
+export declare function useChartImageSlot(): {
+    slot: ChartImageSlot;
+    capture: CaptureChart | null;
+};
+/** What a menu offers of the chart on screen as a picture. */
+export interface ChartImageOffer {
+    /** Draw it as a picture of `format` and hand the file to the browser. */
+    take(format: ImageFormat): void;
+    /** The last picture asked for could not be made; `null` otherwise. */
+    failed: ImageFormat | null;
+    /** The failure read: the line that said so goes. */
+    dismiss(): void;
+}
+/**
+ * The chart on screen as a picture to take away (D33 Q58), offered where
+ * 「导出数据…」 is — the result's toolbar, a panel's 「⋯」 (D25 Q28) — or
+ * `null` while no chart is drawn: a table, a metric card (its words are no
+ * drawing), before the first answer.
+ *
+ * The picture's head is the view's title and the conditions the rows came
+ * back under, said as the export window says them; the file is named after
+ * the title and the day, 「图表」 where the view has no title yet.
+ */
+export declare function useChartImageOffer({ runtime, title, capture, }: {
+    runtime: ViewRuntime | null;
+    /** The view's or the panel's title: the picture's head and file name. */
+    title: string;
+    capture: CaptureChart | null;
+}): ChartImageOffer | null;
+//# sourceMappingURL=imageExport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"imageExport.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/imageExport.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAG1D,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAO5B,2DAA2D;AAC3D,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,CAAC;AAOxC;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI;IACnC,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;CAC9B,CAOA;AAED,8DAA8D;AAC9D,MAAM,WAAW,eAAe;IAC9B,yEAAyE;IACzE,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,sEAAsE;IACtE,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IAC3B,oDAAoD;IACpD,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,OAAO,EACP,KAAK,EACL,OAAO,GACR,EAAE;IACD,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAC5B,yEAAyE;IACzE,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;CAC9B,GAAG,eAAe,GAAG,IAAI,CAgDzB"}

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

@@ -0,0 +1,39 @@
+import { Issue } from '../../model/index.js';
+import { AnalysisEditorController } from '../../react/index.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+import { MetricNaming } from './editing.js';
+/**
+ * What a finding's aliases are read against: the draft's dimensions and
+ * metrics — the config the findings are about — and what names their
+ * fields and conditions.
+ */
+export type AnalysisNaming = MetricNaming & Pick<AnalysisEditorController, 'groups'> & Partial<Pick<AnalysisEditorController, 'expandable'>>;
+/**
+ * A finding as a reader is told it, in the words the screen uses — never a
+ * key the program addresses things by. The kernel names what it has: an
+ * alias, a field's path, a function or a unit as Wow spells it. Only the
+ * catalogue knows what those are called, so they are said here:
+ *
+ * - a dimension or a metric (`alias`, `metric`) as its result column is
+ *   headed (`groupReference`, `metricReference` — the words the table
+ *   header, the sort and 「只保留」 use). 「漏斗要一个可累加的指标，avg 不
+ *   是」 named the program's key for 「金额的平均」, which the reader never
+ *   typed and cannot find on screen;
+ * - a field (`field`, `path`) by its label, as the tray's pickers list it;
+ * - a summary (`fn`) as the metric's summary select says it, 「平均」 for
+ *   `AVG`, and the earliest of a moment 「最早」;
+ * - a time unit (`unit`) as the dimension's granularity reads, 「按月」, and
+ *   a calendar part (`part`) as its cycle reads, 「按星期」;
+ * - a dimension type (`type` of `analysis.group.unsupported`) as the
+ *   dimension card offers it, 「数值区间」;
+ * - a condition's operator (`operator`) as its operator select says it.
+ *
+ * `chart.as-table` is said with the chart and its reason, the tile's own
+ * words in the picker: 「柱状图画不了这个结果（最多两个维度），先以表格显示」.
+ *
+ * Anything the draft does not have is left as it is — it has no name on
+ * screen, and the finding is usually that it is missing. Findings of every
+ * other family pass through untouched.
+ */
+export declare function analysisIssueNamer(analysis: AnalysisNaming, messages: MessageFormatters): (found: Issue) => Issue;
+//# sourceMappingURL=issueNames.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"issueNames.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/issueNames.ts"],"names":[],"mappings":"AAaA,OAAO,EAA+B,KAAK,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE/E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAErE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAEtB;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,YAAY,GACvC,IAAI,CAAC,wBAAwB,EAAE,QAAQ,CAAC,GACxC,OAAO,CAAC,IAAI,CAAC,wBAAwB,EAAE,YAAY,CAAC,CAAC,CAAC;AAsBxD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,iBAAiB,GAC1B,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,CAsEzB"}

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

@@ -0,0 +1,42 @@
+/** Which list a press is in, as three selectors read from the press up. */
+export interface ListShape {
+    /** The element holding the items, as a selector above the press. */
+    list: string;
+    /** One item of it: `[data-slot="metric-card"]`. */
+    item: string;
+    /** The way to add one, for the list that can empty out. */
+    add?: string;
+}
+/** The half of a press this needs, which is a click's own `currentTarget`. */
+export interface Press {
+    currentTarget: HTMLElement;
+}
+export interface ListFocus {
+    /** Said from the press: the item at this index is going. */
+    removing(press: Press, at: number): void;
+}
+/**
+ * Where the keyboard stands after the control it was on leaves the page.
+ *
+ * **Why.** The editor and the visualization panel are lists of cards, and
+ * every card carries the button that removes it. Pressing that button with
+ * the keyboard removes the element the focus was on, and a focus with
+ * nothing under it falls to `<body>` — the next Tab then starts the page
+ * again, from the title bar, which for a user taking three dimensions out
+ * means walking back down three times. (A move needs none of this: every
+ * ordered list is carried by its handle, and a row keyed by what it holds
+ * takes the handle's node — and the keyboard on it — along with it.)
+ *
+ * **The rule.** A removal leaves the keyboard where the row was — the item
+ * that took its place, the one before it if the list ended there, and the
+ * list's own 「添加」 when nothing is left.
+ *
+ * **Why an effect and not the press.** The item is still on the page while
+ * the press is being handled — it is React's next render that takes it away
+ * — so the press only says what happened, and the effect after that render
+ * is what places the focus. Nothing here waits on a timer: a timer would be
+ * a guess about when React is finished, and it would move the focus out
+ * from under whoever had taken it meanwhile.
+ */
+export declare function useListFocus(shape: ListShape): ListFocus;
+//# sourceMappingURL=listFocus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listFocus.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/listFocus.ts"],"names":[],"mappings":"AAgBA,2EAA2E;AAC3E,MAAM,WAAW,SAAS;IACxB,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,8EAA8E;AAC9E,MAAM,WAAW,KAAK;IACpB,aAAa,EAAE,WAAW,CAAC;CAC5B;AAED,MAAM,WAAW,SAAS;IACxB,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,CAkBxD"}