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

package/dist/analysis/chart.d.ts

@@ -0,0 +1,108 @@
+import { AnalysisViewConfig, RecordData } from '../model/index.js';
+import { BoxplotData } from './boxplot.js';
+import { CandlestickData } from './candlestick.js';
+import { CartesianData } from './cartesian.js';
+import { FunnelData } from './funnel.js';
+import { GaugeData } from './gauge.js';
+import { MapData } from './map.js';
+import { HierarchyData, SankeyData } from './hierarchy.js';
+import { MetricCardData } from './metricCard.js';
+import { ParallelData, RadarData } from './profiles.js';
+import { CalendarData, ThemeRiverData } from './timeCharts.js';
+import { TreemapData } from './treemap.js';
+import { WaterfallData } from './waterfall.js';
+/**
+ * What a renderer receives. The shaping a chart needs happens here rather than
+ * in a component, so the same numbers reach any UI and the rules stay testable
+ * without a DOM.
+ */
+export type ChartData = CartesianData | PieData | HeatmapData | ScatterData | FunnelData | MetricCardData | WaterfallData | TreemapData | BoxplotData | CandlestickData | GaugeData | RadarData | ParallelData | HierarchyData | SankeyData | CalendarData | ThemeRiverData | MapData;
+export type { MetricCardData, MetricPeriod } from './metricCard.js';
+export { periodRollover } from './metricCard.js';
+export type { WaterfallData, WaterfallStep } from './waterfall.js';
+export type { TreemapData, TreemapTile } from './treemap.js';
+export type { BoxplotBox, BoxplotData } from './boxplot.js';
+export type { Candle, CandlestickData } from './candlestick.js';
+export type { GaugeData } from './gauge.js';
+export type { MapData, MapRegion } from './map.js';
+export type { CalendarData, CalendarDay, RiverStream, ThemeRiverData, } from './timeCharts.js';
+export type { HierarchyData, HierarchyNode, SankeyData, SankeyLink, SankeyNode, } from './hierarchy.js';
+export type { ParallelData, ChartProfile, RadarData } from './profiles.js';
+export type { CartesianData } from './cartesian.js';
+export type { CartesianGap, DerivedGap, DerivedLine } from './derived.js';
+export type { PlacedLine, SeriesExtremes } from './references.js';
+export type { FunnelData, FunnelStage } from './funnel.js';
+export { groupKeyText } from './chartRows.js';
+export interface PieSlice {
+    category: unknown;
+    value: number;
+    /** The merged remainder rather than a queried category. */
+    other?: boolean;
+}
+export interface PieData {
+    type: 'pie';
+    slices: PieSlice[];
+}
+export interface HeatmapData {
+    type: 'heatmap';
+    xs: unknown[];
+    ys: unknown[];
+    /** `cells[y][x]`, null where the query returned no row. */
+    cells: (number | null)[][];
+}
+export interface ScatterData {
+    type: 'scatter';
+    points: {
+        category: unknown;
+        x: number;
+        y: number;
+        size?: number;
+    }[];
+}
+/** What shaping reads besides the config and the rows. */
+export interface ShapeContext {
+    /**
+     * The metric types the source estimates (`AnalysisProjection.approximate`): a
+     * boxplot says its quartiles are approximate when percentiles are among
+     * them. Percentiles when left out (`DEFAULT_APPROXIMATE_METRICS`).
+     */
+    approximate?: readonly string[];
+    /**
+     * The engine's zone: the one a histogram that names none was cut in, and
+     * so the one its missing buckets are stepped in. The host's when left out.
+     */
+    timeZone?: string;
+    /**
+     * When the question was asked — the moment its relative conditions
+     * resolved against. A trend card's headline is the last period that had
+     * ended by then; left out, every bucket counts as ended.
+     */
+    now?: Date;
+    /**
+     * The rows are the first groups of more (`AnalysisProjection.truncated` or
+     * `atLimit`): a line computed across them — a running total, a moving
+     * average — would be wrong, and is not drawn (`derivedGap`).
+     */
+    cutShort?: boolean;
+    /**
+     * The rows of the query grouped by a split chart's axis alone
+     * (`AnalysisProjection.splitWhole`): what a split past the palette folds its
+     * rest into 「其他」 against (D33 Q56). Left out, nothing is folded.
+     */
+    splitWhole?: readonly RecordData[];
+}
+/**
+ * `totals` is the one row of the ungrouped totals query, when it ran. Only
+ * the metric card reads it: over a trend read as the whole, it is the
+ * headline for any metric.
+ *
+ * Every time axis — a cartesian chart's x, a heatmap's rows or columns, the
+ * card's sparkline — and a series split by time run earliest first
+ * (`forwardInTime`); everything else keeps the order the rows came in, which
+ * is the view's sort, because a category has no order of its own to restore.
+ * A time axis also runs without holes (`withoutHoles`), and what fills a
+ * missing bucket or a missing split — 0 or nothing — is `absenceReader`'s
+ * and the metric's to say.
+ */
+export declare function shapeChart(config: AnalysisViewConfig, rows: readonly RecordData[], totals?: RecordData, context?: ShapeContext): ChartData | undefined;
+//# sourceMappingURL=chart.d.ts.map

package/dist/analysis/chart.d.ts.map

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

package/dist/analysis/chartFamilies.d.ts

@@ -0,0 +1,175 @@
+import { CartesianSeries, ChartFamily, ChartSpec, ChartType } from '../model/index.js';
+/**
+ * What a chart family is, in one place (phase-2 review E1). A family is the
+ * unit a new kind of chart is added as, so everything the kernels and the
+ * options panel ask of it by family is a row here rather than a `switch` in
+ * each of them: which pages its options have, whether it has a legend and
+ * value labels, and what shape of result it can draw.
+ *
+ * The fit is the forward reading of `validateChart`'s rules: a family is
+ * offered for a shape exactly when the slots `fitChartSlots` fills for it
+ * pass validation. That agreement is a test over every shape
+ * (test/chartFamilies.test.ts「one rule, read forward and after the fact」);
+ * the day the two drift, it fails rather than a tile being offered that
+ * then refuses to draw.
+ */
+/** The three pages a chart's options are laid out on. */
+export type OptionsTab = 'data' | 'display' | 'axes';
+/**
+ * Why a chart type cannot draw the shape on hand, as a catalogue key. Each
+ * names what the shape lacks, or has too much of, in the analyst's words,
+ * because that is what the greyed tile says under itself (D20 屏 I).
+ */
+export type ChartUnfit = 'chart.fit.needs-dimension' | 'chart.fit.needs-one-dimension' | 'chart.fit.needs-two-dimensions' | 'chart.fit.too-many-dimensions' | 'chart.fit.needs-two-metrics' | 'chart.fit.needs-no-dimension' | 'chart.fit.needs-quantity' | 'chart.fit.needs-category' | 'chart.fit.needs-two-stages' | 'chart.fit.not-steps' | 'chart.fit.needs-additive' | 'chart.fit.needs-share' | 'chart.fit.needs-five-numbers' | 'chart.fit.needs-date' | 'chart.fit.needs-ohlc' | 'chart.fit.needs-three-metrics' | 'chart.fit.too-many-levels' | 'chart.fit.needs-day' | 'chart.fit.needs-date-and-split' | 'chart.fit.needs-region' | 'chart.fit.needs-map';
+/** The facts of a result's shape a family's fit reads. */
+export interface ShapeFacts {
+    /** How many dimensions. */
+    groups: number;
+    /** How many metrics. */
+    metrics: number;
+    /**
+     * How many of them are quantities rather than moments (`momentMetrics`):
+     * what a mark can measure. A moment is read on a card, never drawn.
+     */
+    quantities: number;
+    /** One dimension, and it is a date bucket. */
+    dated: boolean;
+    /**
+     * How many of the quantities may be added up across rows
+     * (`isAdditiveMetric`): a record count or a sum. A trend's headline and a
+     * funnel's stages are counted from these alone.
+     */
+    additive: number;
+    /**
+     * One dimension, and it names categories (`TERMS`) rather than cutting a
+     * scale into buckets: only a category's values can be a funnel's stages.
+     */
+    categorical: boolean;
+    /**
+     * Rows are known and none of the one dimension's values is text: nothing
+     * a stage could be named by.
+     */
+    textless: boolean;
+    /**
+     * How many stages a funnel over the one dimension would have: the text
+     * values the rows on hand give, once each (`stageValues`, what picking the
+     * funnel fills its order with); with no rows, the stages the chart already
+     * names; `undefined` while neither is known.
+     */
+    stages?: number;
+    /**
+     * Whether the quantities hold a box's five numbers of one field — its
+     * lowest, three percentiles and its highest (`fiveNumberSets`).
+     */
+    fiveNumbers: boolean;
+    /**
+     * Whether the quantities hold a candle's four numbers of one field — its
+     * opening value, highest, lowest and closing value (`ohlcSets`).
+     */
+    ohlc: boolean;
+    /** How many of the dimensions are date buckets. */
+    datedGroups: number;
+    /** One dimension, and it is a date bucket by day: a calendar's. */
+    daily: boolean;
+}
+export interface ChartFamilyTraits {
+    /** The pages of its options panel. */
+    tabs: readonly OptionsTab[];
+    /** Whether it draws a legend worth placing. */
+    legend: boolean;
+    /** Whether it can write the values on its marks. */
+    labels: boolean;
+    /**
+     * Which of its marks write their values while nobody has said
+     * (`ChartSpec.labels` left out). A bar does: its length is compared at a
+     * glance but read off the axis only roughly, and the labels give way where
+     * they would land on each other. A line or an area does not — it answers
+     * where the numbers are heading and how two series move together, and a
+     * number on every point drowned a monthly line of 23 points (2026-09-23
+     * audit P1-3; Metabase leaves its data-point values off until asked). A
+     * pie already writes its shares on its slices, so it has no mark here.
+     * `'always'`: a family with no series whose marks write their values
+     * unasked — a heatmap's cells, whose shade is read off a colour scale only
+     * roughly: the numbers are written where every one of them fits a cell
+     * (`heatmapLabelsFit`), and a 6.3× difference two shades apart stayed
+     * unreadable otherwise (second review R2-P1-3).
+     */
+    labelsByDefault: readonly SeriesMark[] | 'always';
+    /** Why it cannot draw this shape, or `null` when it can. */
+    unfit(shape: ShapeFacts): ChartUnfit | null;
+}
+/**
+ * Every family's traits. The fits, in words: a cartesian chart puts one
+ * dimension on its axis and may split by a second, so it needs one and takes
+ * at most two (a third would leave several rows per point, which AVG and
+ * DISTINCT_COUNT cannot be added back up over — D20 left that a table's
+ * job rather than drop a dimension silently); a pie needs exactly one, and
+ * a count or a sum, since its slices are shares of a whole; a heatmap two; a scatter plots two metrics per value of one dimension; a
+ * funnel's stages are the values of one category dimension — two of them at
+ * least, counted in the rows when there are rows — or, with none, the
+ * metrics themselves, and either way it counts only what adds up (a record
+ * count or a sum); a card is one number, or a sparkline over the one
+ * date dimension when its headline adds up. A waterfall steps along one
+ * dimension and a treemap tiles one, or nests a second inside it; both add
+ * their numbers up — into a running total, into a whole — so both count
+ * only what adds up, as a funnel does. A boxplot draws one box per value of
+ * one dimension from a field's five numbers (`fiveNumberSets`); a
+ * candlestick one candle per bucket of one date dimension from a field's
+ * opening, highest, lowest and closing values (`ohlcSets`); a gauge is
+ * the card's one number on a scale; a radar and parallel axes draw each
+ * group of one dimension across three metrics or more. A sunburst, a tree
+ * and a sankey read two to four dimensions as levels, and add their numbers
+ * up as a treemap does.
+ *
+ * Every family but the card measures its metrics as marks — a length, a
+ * slice, a shade, a position against zero — so it counts only the metrics
+ * that are quantities: the earliest or the latest of a date is a moment, and
+ * a shape of nothing else is greyed with `chart.fit.needs-quantity` once its
+ * dimensions would fit. A card writes its headline out, so a moment is one.
+ */
+export declare const CHART_FAMILIES: Readonly<Record<ChartFamily, ChartFamilyTraits>>;
+/** The mark a cartesian series is drawn as. */
+export type SeriesMark = NonNullable<CartesianSeries['type']>;
+/**
+ * The mark one series of a chart of this type is drawn as: a combo's names
+ * its own and is a bar where it names none; every other cartesian type
+ * draws all its series alike.
+ */
+export declare function seriesMark(type: ChartType, series?: Pick<CartesianSeries, 'type'>): SeriesMark;
+/**
+ * The marks a chart draws its series as, once each series: a waterfall's
+ * steps are bars; none for any other family that has no series.
+ */
+export declare function chartMarks(chart: ChartSpec): SeriesMark[];
+/**
+ * Whether a chart writes the values on its marks — or, given a `mark`, on
+ * the series drawn as that mark: what the spec says, and its family's
+ * default for the mark where it says nothing. An explicit `false` is a
+ * choice and stands, as is an explicit `true`, which writes them on every
+ * mark; a family that cannot write them never does.
+ *
+ * Asked of the whole chart, it is whether any of its marks writes them: a
+ * combo of bars and a line writes the bars' values by default — and a
+ * long upright row of bars only its peak and trough (`peaksOnlyLabels`).
+ */
+export declare function valueLabelsOn(chart: ChartSpec | undefined, mark?: SeriesMark): boolean;
+/**
+ * From this many categories a bar chart left to its default writes only
+ * its peak and trough (`peaksOnlyLabels`): about the count where a number
+ * over every bar has to be turned on its side to fit, and the row of
+ * upright numbers is noise rather than a reading (2026-09-26 review P1-6).
+ */
+export declare const PEAKS_ONLY_FROM = 12;
+/**
+ * Whether a cartesian chart's bars, left to their default, write only
+ * their highest and lowest value — as the extremes are marked — rather
+ * than a number over every bar: `labels` unset and `PEAKS_ONLY_FROM`
+ * categories or more. An explicit `labels: true` writes every bar's number
+ * however many there are, and `false` writes none. The kernel finds the
+ * extremes for it (`shapeChart`); which way the bars lie is the drawing's
+ * to decide, and a chart lying on its side keeps a number on each row.
+ */
+export declare function peaksOnlyLabels(chart: ChartSpec | undefined, categories: number): boolean;
+/** The traits of the family a chart type belongs to. */
+export declare function familyOf(type: ChartType): ChartFamilyTraits;
+//# sourceMappingURL=chartFamilies.d.ts.map

package/dist/analysis/chartFamilies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chartFamilies.d.ts","sourceRoot":"","sources":["../../src/analysis/chartFamilies.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,SAAS,EACT,SAAS,EACV,MAAM,mBAAmB,CAAC;AAG3B;;;;;;;;;;;;;GAaG;AAEH,yDAAyD;AACzD,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;AAErD;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAClB,2BAA2B,GAC3B,+BAA+B,GAC/B,gCAAgC,GAChC,+BAA+B,GAC/B,6BAA6B,GAC7B,8BAA8B,GAC9B,0BAA0B,GAC1B,0BAA0B,GAC1B,4BAA4B,GAC5B,qBAAqB,GACrB,0BAA0B,GAC1B,uBAAuB,GACvB,8BAA8B,GAC9B,sBAAsB,GACtB,sBAAsB,GACtB,+BAA+B,GAC/B,2BAA2B,GAC3B,qBAAqB,GACrB,gCAAgC,GAChC,wBAAwB,GACxB,qBAAqB,CAAC;AAE1B,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IACzB,2BAA2B;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,8CAA8C;IAC9C,KAAK,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,IAAI,EAAE,OAAO,CAAC;IACd,mDAAmD;IACnD,WAAW,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,sCAAsC;IACtC,IAAI,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5B,+CAA+C;IAC/C,MAAM,EAAE,OAAO,CAAC;IAChB,oDAAoD;IACpD,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;;;;;;;;;;OAcG;IACH,eAAe,EAAE,SAAS,UAAU,EAAE,GAAG,QAAQ,CAAC;IAClD,4DAA4D;IAC5D,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI,CAAC;CAC7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE,iBAAiB,CAAC,CAyNxE,CAAC;AAqFL,+CAA+C;AAC/C,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;AAE9D;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,SAAS,EACf,MAAM,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,GACrC,UAAU,CAGZ;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,EAAE,CAQzD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,IAAI,CAAC,EAAE,UAAU,GAChB,OAAO,CAST;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,UAAU,EAAE,MAAM,GACjB,OAAO,CAQT;AAED,wDAAwD;AACxD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,iBAAiB,CAE3D"}

package/dist/analysis/chartOptions.d.ts

@@ -0,0 +1,113 @@
+import { CartesianSeries, CartesianSpec, ChartSpec, ChartType, FunnelSpec, RecordData } from '../model/index.js';
+import { OptionsTab } from './chartFamilies.js';
+/**
+ * The rules behind the visualization panel's second level (D20 屏 J): what
+ * a chart's options are made of, and how one setting changes the spec
+ * without breaking another. The panel itself is markup; every edit that
+ * has a rule in it lives here, where it can be tested without a DOM.
+ */
+/** What the panel shows as chosen: a chart type, or the table. */
+export type Picked = ChartType | 'table';
+/**
+ * Which pages this chart has. Every drawn family has data slots; the
+ * cartesian family and the scatter have numeric axes worth a page — their
+ * titles, bounds, formats and scales (D33 batch E); the table's one option
+ * is its totals row, which is a display choice.
+ */
+export declare function optionTabs(picked: Picked): readonly OptionsTab[];
+/**
+ * An alias put in one slot, taken out of the other if it was there: a chart
+ * that split by the axis it plots along is `chart.splitBy.same-as-x`, so
+ * choosing for one slot what the other holds swaps them rather than
+ * doubling up. The same rule places a heatmap's two axes and a scatter's
+ * two metrics.
+ */
+export declare function withSlot<S extends object, K extends keyof S>(spec: S, at: K, other: K, alias: string): S;
+/**
+ * Whether a series of a chart of this type stacks: a bar or an area does, a
+ * line never. Stacked, a line's point is drawn at the running sum while its
+ * label says its own value — 「¥640」 at the height of ¥1920 — and a line
+ * has no band under it to show the part it adds, so the reader can only
+ * read the point off the axis, and reads the sum (2026-09-23 audit P0-2).
+ * Metabase offers stacking on bars and areas alone.
+ */
+export declare function stacks(type: ChartType, series: Pick<CartesianSeries, 'type'>): boolean;
+/**
+ * Whether the display page offers stacking for this type at all: a line
+ * chart's every series is a line, so there is nothing that could stack.
+ */
+export declare function offersStacking(type: ChartType): boolean;
+/**
+ * Whether every series that can stack is stacked; a lone series is not
+ * "stacked", and neither is a chart with nothing that stacks. A combo's
+ * lines are left out of the question: they draw their own values whatever
+ * the bars do.
+ */
+export declare function isStacked(spec: CartesianSpec, type?: ChartType): boolean;
+/**
+ * Stacking is one choice for the whole chart — series stacked in twos and
+ * threes is a spec the panel does not offer — so every series that can
+ * stack joins the one stack or leaves it. A combo's line stays out of it,
+ * and keeps its axis: it is measured, not added.
+ *
+ * Joining it brings every stacked series back onto the one axis: segments
+ * that sit on top of each other are being added up, and two scales cannot
+ * be added. A stack across two axes is one stack per axis, drawn at the
+ * same place and the same width, so the taller one simply hides the other —
+ * a chart that reads as broken rather than as a sum. Unstacking leaves them
+ * where the stack put them; which series is measured against what is a
+ * choice, and the panel does not guess at an old one.
+ */
+export declare function withStacked(spec: CartesianSpec, on: boolean, type?: ChartType): CartesianSpec;
+/**
+ * Whether the display page offers 「百分比堆叠」 for this chart: a bar or an
+ * area chart — a combo's lines would be drawn against a scale of shares —
+ * whose every series adds up (`additive`: a share is a part of a sum, and
+ * an average has no whole to be part of), with something to stack — a
+ * split, or two series or more. One series alone would be 100% everywhere.
+ */
+export declare function offersPercentStack(spec: CartesianSpec, type: ChartType, additive: ReadonlySet<string>): boolean;
+/** Whether the chart draws its stacks as shares: stacked, and asked to. */
+export declare function isPercentStacked(spec: CartesianSpec, type?: ChartType): boolean;
+/**
+ * 「百分比堆叠」 on or off. On stacks the chart as well (`withStacked`) —
+ * shares are a reading of a stack, and a box that turned on and drew the
+ * same side-by-side bars would be a box that did nothing; off leaves the
+ * stack standing and draws its values again.
+ */
+export declare function withPercentStack(spec: CartesianSpec, on: boolean, type?: ChartType): CartesianSpec;
+export declare function isSmooth(spec: CartesianSpec): boolean;
+export declare function withSmooth(spec: CartesianSpec, on: boolean): CartesianSpec;
+/**
+ * The list with the item at `from` taken out and put back at `to`, or as it
+ * was when either place is not one this list has.
+ *
+ * Every way a list on this panel is reordered ends up here: an arrow key on
+ * a handle names the place one step away, the handle's menu one step away or
+ * either end, and a drop the place it landed on, which may be any of them.
+ */
+export declare function withMovedTo<T>(items: readonly T[], from: number, to: number): T[];
+/**
+ * The values of a group as the result lists them, once each and in the
+ * order the rows came — the order the stages of a funnel are offered in
+ * before the analyst puts them in business order. Only a text value can be
+ * a stage: the kernel reads a stage's name back as a string key, and a
+ * number or a boolean would never match itself.
+ */
+export declare function stageValues(rows: readonly RecordData[], category: string): string[];
+/**
+ * A funnel whose stages are a group's values needs their order, which is
+ * business knowledge the kernel does not have (`fitChartSlots` leaves it
+ * empty). Until the analyst has said otherwise, the order the result came
+ * in is the one to start from — a funnel of no stages draws nothing, and a
+ * chart that draws nothing when picked reads as broken.
+ *
+ * An order of one stage is no order either — a view saved before a funnel
+ * was offered only where it draws can hold one, and picked again it would
+ * refuse again — so it is completed the same way: the stage it names first,
+ * then the values the rows add. An order of two or more is the analyst's
+ * and is kept as it stands.
+ */
+export declare function withStagesFrom(chart: ChartSpec, rows: readonly RecordData[]): ChartSpec;
+export declare function withStageOrder(spec: FunnelSpec, order: string[]): FunnelSpec;
+//# sourceMappingURL=chartOptions.d.ts.map

package/dist/analysis/chartOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chartOptions.d.ts","sourceRoot":"","sources":["../../src/analysis/chartOptions.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAwB,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE3E;;;;;GAKG;AAEH,kEAAkE;AAClE,MAAM,MAAM,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;AAEzC;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,UAAU,EAAE,CAEhE;AAKD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EAC1D,IAAI,EAAE,CAAC,EACP,EAAE,EAAE,CAAC,EACL,KAAK,EAAE,CAAC,EACR,KAAK,EAAE,MAAM,GACZ,CAAC,CAGH;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,GACpC,OAAO,CAET;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEvD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,aAAa,EACnB,IAAI,GAAE,SAAiB,GACtB,OAAO,CAMT;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,OAAO,EACX,IAAI,GAAE,SAAiB,GACtB,aAAa,CAcf;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,GAC5B,OAAO,CAOT;AAED,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,aAAa,EACnB,IAAI,GAAE,SAAiB,GACtB,OAAO,CAET;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,OAAO,EACX,IAAI,GAAE,SAAiB,GACtB,aAAa,CAIf;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAKrD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,OAAO,GAAG,aAAa,CAO1E;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,CAAC,EAAE,CAML;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,QAAQ,EAAE,MAAM,GACf,MAAM,EAAE,CAOV;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,SAAS,CAmBX;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,UAAU,CAG5E"}

package/dist/analysis/chartRefs.d.ts

@@ -0,0 +1,31 @@
+import { AnalysisMetric, ChartSpec, Issue, IssuePath } from '../model/index.js';
+/**
+ * What every family's chart rules read (`validateChart`): the aliases the
+ * result has, which of its metrics are moments, the chart and where it
+ * sits — and the checks a slot is made of: a group the result has, a metric
+ * it has, a quantity a mark can measure, every group consumed.
+ */
+export interface ChartContext {
+    groups: Set<string>;
+    metrics: Map<string, AnalysisMetric>;
+    /** The metrics that are moments (`momentMetrics`): no mark measures one. */
+    moments: ReadonlySet<string>;
+    chart: ChartSpec;
+    path: IssuePath;
+}
+export declare function group(context: ChartContext, alias: string, path: IssuePath): Issue[];
+export declare function metric(context: ChartContext, alias: string, path: IssuePath): Issue[];
+/**
+ * A metric a mark measures: one the result has, and a quantity — a bar, a
+ * slice, a shade or a point has no reading for the earliest of a date.
+ */
+export declare function measure(context: ChartContext, alias: string, path: IssuePath): Issue[];
+/**
+ * Every group alias must appear, or the chart cannot address its own rows.
+ * One finding per dimension left out, each naming its own: a reader is told
+ * which column it is by its header (`chart.*` findings name an alias, which
+ * the surface says as the result names it), and a list joined here could
+ * not be taken apart again to name each.
+ */
+export declare function consumesAll(context: ChartContext, consumed: readonly string[]): Issue[];
+//# sourceMappingURL=chartRefs.d.ts.map

package/dist/analysis/chartRefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chartRefs.d.ts","sourceRoot":"","sources":["../../src/analysis/chartRefs.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,cAAc,EACd,SAAS,EACT,KAAK,EACL,SAAS,EACV,MAAM,mBAAmB,CAAC;AAG3B;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACpB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACrC,4EAA4E;IAC5E,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B,KAAK,EAAE,SAAS,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,wBAAgB,KAAK,CACnB,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,SAAS,GACd,KAAK,EAAE,CAIT;AAED,wBAAgB,MAAM,CACpB,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,SAAS,GACd,KAAK,EAAE,CAIT;AAED;;;GAGG;AACH,wBAAgB,OAAO,CACrB,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,SAAS,GACd,KAAK,EAAE,CAMT;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,KAAK,EAAE,CAKT"}

package/dist/analysis/chartRows.d.ts

@@ -0,0 +1,39 @@
+import { AnalysisViewConfig, RecordData } from '../model/index.js';
+export declare function seriesKey(value: unknown): string;
+/**
+ * The key of a split's folded 「其他」 series (`foldOther`): tagged, so no
+ * group value's key is ever the same — a tag letter no value is given.
+ */
+export declare const OTHER_SERIES_KEY = "\u0001o";
+export declare function num(row: RecordData, alias: string): number | null;
+/**
+ * Whether a group the rows lack had no records — so an additive metric over
+ * it is 0 — rather than records the query left out, which nobody can put a
+ * number on. `at` is the missing group's values by alias, as far as known.
+ *
+ * A row is left out by two things. `having` (「只保留」) drops groups by
+ * their numbers, so under it nothing absent is known to be empty. The limit
+ * cuts the rows at the end of the view's sort: a result shorter than the
+ * limit is every group there is, and one that fills it may have lost rows —
+ * but only past its last row in the sort's leading dimension, so a group
+ * whose leading value comes before that row's is still whole. Sorted by day,
+ * newest first, thirty days of a longer history are thirty whole days, and
+ * a day between two of them with no row is a day with no records.
+ */
+export declare function absenceReader(config: AnalysisViewConfig, rows: readonly RecordData[]): (at: Readonly<Record<string, unknown>>) => boolean;
+/**
+ * Whether `record` holds `key` itself: a split value may be any string,
+ * `toString` included, and `in` would find that one on every object.
+ */
+export declare function owns(record: object, key: string): boolean;
+/**
+ * A group value as text: the one spelling of a category or a split value
+ * wherever a string has to name it — the key of `ChartSpec.colors` (see its
+ * contract in `model/chart.ts`), a pivot series' legend label, a React key.
+ * Nothing and null print as empty, a number or a boolean as `String` has it,
+ * anything else as JSON. The kernel labels a split series with it and every
+ * chart family looks a pinned colour up by it, so a key written once colours
+ * the same category in a pie and in a split.
+ */
+export declare function groupKeyText(value: unknown): string;
+//# sourceMappingURL=chartRows.d.ts.map

package/dist/analysis/chartRows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chartRows.d.ts","sourceRoot":"","sources":["../../src/analysis/chartRows.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AA0BxE,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAUhD;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,YAAiB,CAAC;AAE/C,wBAAgB,GAAG,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,OAAO,CASpD;AAED;;;GAGG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAMnD"}

package/dist/analysis/chartSlots.d.ts

@@ -0,0 +1,73 @@
+import { AnalysisGroup, AnalysisMetric, ChartSpec } from '../model/index.js';
+/**
+ * The chart, with the family its `type` asks for filled in from the groups and
+ * metrics the analysis actually has.
+ *
+ * A chart addresses its rows by alias, so it is not a setting that survives
+ * the query changing shape: a `type` switched without its sub-object reported
+ * `chart.family.missing` and drew nothing, and a group added or removed under
+ * a chart that still named the old ones reported `chart.group.unconsumed` or
+ * `chart.group.unknown`. Both are the same question — which alias sits in
+ * which slot — so there is one answer, run on every change to the type, the
+ * groups or the metrics.
+ *
+ * **A slot the user chose is kept while it is still valid**; only a slot whose
+ * alias is gone, or that the new shape has no room for, is filled again. Every
+ * other family's sub-object is carried over untouched, so switching away and
+ * back returns to the settings that family had.
+ *
+ * **The family follows the shape where the shape leaves it undrawable.** Every
+ * family but the metric card and a metric-staged funnel addresses its rows by
+ * a dimension, so an analysis with none can only be a card; and a card is one
+ * number, so an analysis with a dimension it cannot draw as a sparkline is not
+ * one. Those two are not preferences the user gave up — removing the last
+ * dimension is a change to the question, not to the chart — so the type moves
+ * rather than the config turning red.
+ *
+ * What it does not do is invent a shape: a heatmap of one dimension, a scatter
+ * of one metric and a funnel whose stages nobody has named are not
+ * expressible, and the slot is left empty so that `validateChart` says which
+ * one is missing rather than the family being absent altogether. Those are
+ * types the user picked against a shape that cannot carry them; which types a
+ * given shape *offers* is a separate question, answered where they are listed.
+ *
+ * **A mark measures quantities, never a moment** (`momentMetrics`, passed as
+ * `moments`): every slot a mark is drawn from — a series, a slice, a shade, a
+ * scatter axis, a funnel stage — is filled from the metrics that are not
+ * moments, and a card's comparison, target and number format stay only over
+ * a headline that is a quantity. A shape with dimensions and nothing to
+ * measure is drawn as bars with no series: a chart that is valid and empty,
+ * which the picker greys (`chart.fit.needs-quantity`) and the result block
+ * shows as its table.
+ *
+ * **A combo puts on the right axis what measures something else**
+ * (`measures`, `metricMeasures`): a series arriving in a combo takes the
+ * right axis when its metric is a quantity of another kind than the first
+ * series' (`comboAxis`). Left out, every metric reads as one measure.
+ */
+export declare function fitChartSlots(chart: ChartSpec, groups: readonly AnalysisGroup[], metrics: readonly AnalysisMetric[], moments?: ReadonlySet<string>, measures?: ReadonlyMap<string, string>): ChartSpec;
+/**
+ * The mark a combo gives the series at `index` when nobody has chosen one:
+ * the first metric as bars, every other as a line — Metabase's combo, and
+ * the only reading of 「组合图」 that is not a bar chart under another name.
+ * Picking it used to draw every series as bars, and the analyst who asked
+ * for bars with a line saw nothing change (2026-09-23 audit P1-8). A mark
+ * the analyst picked on the options page is kept.
+ */
+export declare function comboMark(index: number): 'bar' | 'line';
+/**
+ * The axis a combo gives `metric` when nobody has chosen one: the first
+ * series' side (`leadSide`) when it measures the same kind of thing as the
+ * first series (`lead`), the other side when it does not.
+ *
+ * Decided by what the metrics are, not by their values, which this layer
+ * never sees (`metricMeasure`): a count beside an amount, an amount beside
+ * an average, a percent beside a count are two scales, and drawn on one the
+ * smaller lies flat along zero — the combo's second metric always sat on the
+ * left axis, and a count beside money read as nothing. Two metrics of one
+ * measure stay together even when their values are far apart: nothing says
+ * they differ, and one scale is what lets them be compared. An axis the
+ * analyst picked on the options page is theirs and is kept.
+ */
+export declare function comboAxis(measures: ReadonlyMap<string, string>, lead: string | undefined, metric: string, leadSide?: 'left' | 'right'): 'left' | 'right';
+//# sourceMappingURL=chartSlots.d.ts.map

package/dist/analysis/chartSlots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chartSlots.d.ts","sourceRoot":"","sources":["../../src/analysis/chartSlots.ts"],"names":[],"mappings":"AAaA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,cAAc,EAGnB,KAAK,SAAS,EASf,MAAM,mBAAmB,CAAC;AAO3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,GAAE,WAAW,CAAC,MAAM,CAAc,EACzC,QAAQ,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAe,GAClD,SAAS,CA+IX;AAkND;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,CAEvD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACrC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAM,GAAG,OAAgB,GAClC,MAAM,GAAG,OAAO,CAOlB"}

package/dist/analysis/chartSwitch.d.ts

@@ -0,0 +1,34 @@
+import { ChartSpec, ChartType } from '../model/index.js';
+/**
+ * The metric a chart is about: the one its first mark measures.
+ *
+ * A cartesian chart's first series, a pie's or a heatmap's value, a
+ * scatter's horizontal measure, a funnel's stage value (or its first stage),
+ * a card's headline, a waterfall's steps, a treemap's areas, a box's median,
+ * a gauge's needle, a radar's or parallel axes' first axis. Undefined when
+ * the family has not been filled yet.
+ */
+export declare function leadMetric(chart: ChartSpec): string | undefined;
+/**
+ * The chart as `type` draws it, measuring what the chart being left measured.
+ *
+ * Picking another type changes how the numbers are drawn, not which numbers
+ * (the user's 2026-09-23 decision, audit P0-10): a bar chart of 「金额的总和」
+ * turned into a pie used to become a pie of 「记录数」, because a family
+ * never visited fills its value slot with the first metric, and one visited
+ * before kept whatever it measured then. So the lead metric is carried into
+ * the new family's slot; everything else the family had — a pie's donut, a
+ * card's target, a funnel's order — stays as it was, and `fitChartSlots`
+ * still judges the result, so a metric the new family cannot measure (a
+ * moment, or one that does not add up under a card's trend) falls back there
+ * as before.
+ *
+ * The legend's setting goes with the family it was set for: another family
+ * starts from 「自动」.
+ *
+ * A cartesian chart draws a list: the lead joins it at the front when it is
+ * not already drawn, and is the one series of a pivot. A family with nothing
+ * written yet draws every metric, which already includes it.
+ */
+export declare function switchChartType(chart: ChartSpec, type: ChartType): ChartSpec;
+//# sourceMappingURL=chartSwitch.d.ts.map

package/dist/analysis/chartSwitch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chartSwitch.d.ts","sourceRoot":"","sources":["../../src/analysis/chartSwitch.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CA4C/D;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,SAAS,CA8G5E"}