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

package/dist/ui/charts/cartesianBrush.d.ts

@@ -0,0 +1,84 @@
+import { CartesianPlan } from './cartesianPlan.js';
+import { ChartTheme } from './theme.js';
+/**
+ * Brushing a stretch of a time axis (D33 batch C, Q52): a drag along the
+ * plot selects the buckets under it, and the follow-up menu a press on one
+ * group opens is asked about all of them at once — 「这几天怎么了」. The
+ * brush only chooses; what the stretch means as a condition is the
+ * kernel's (`drillSpan`), and nothing here edits the view.
+ *
+ * Only along the axis (`lineX`), only one stretch at a time, and never
+ * saved: the cover goes when the menu over it closes.
+ */
+/** Whether a chart of this plan is brushed: upright, over time, pressable. */
+export declare function brushes(plan: CartesianPlan): boolean;
+/**
+ * The id the brush component of this package's charts wears, by which the
+ * toolbox the library injects for it is recognised (`withoutBrushToolbox`).
+ */
+export declare const BRUSH_ID = "fve-brush";
+/**
+ * The brush component a brushed chart carries, or nothing.
+ *
+ * Its cover is a quiet band in the muted ink, and the marks outside it fade as a pressed
+ * group's neighbours do on a board (`FADED_OPACITY`), so what the stretch
+ * holds reads while the drag is under way. No toolbox: the drag is always
+ * on (`BRUSH_CURSOR`), and a press still presses — a drag shorter than the
+ * library's threshold draws no cover, and a click is only a click when the
+ * pointer barely moved.
+ */
+export declare function brushOption(plan: CartesianPlan, theme: ChartTheme): object | undefined;
+/**
+ * The option without the toolbox the library's brush preprocessor put into
+ * it for this package's brush — an option preprocessor, registered after the
+ * brush (`echarts.ts`), so it runs before the library checks what the option
+ * uses. The preprocessor adds a `toolbox` for the buttons it would draw; the
+ * toolbox is not registered (analysis-echarts.md 2.4: +15.1KB for buttons
+ * this package draws itself), so nothing was drawn, but a development build
+ * logged 「Component toolbox is used but not imported」 in every host's
+ * console. Only an option carrying this package's brush (`BRUSH_ID`) is
+ * touched, and only while no toolbox is registered: a host drawing its own
+ * charts with the same library, toolbox and all, keeps its toolbox.
+ */
+export declare function withoutBrushToolbox(option: Record<string, unknown> | undefined, toolboxRegistered: boolean): void;
+/**
+ * What turns the brush on without a toolbox button: taken when a mouse or a
+ * pen goes down on the plot, before the library sees the press, and again
+ * after a whole new option has reset the component (`EChart`).
+ */
+export declare const BRUSH_CURSOR: {
+    readonly type: "takeGlobalCursor";
+    readonly key: "brush";
+    readonly brushOption: {
+        readonly brushType: "lineX";
+        readonly brushMode: "single";
+    };
+};
+/** What clears the cover once the menu over it has gone. */
+export declare const BRUSH_CLEAR: {
+    readonly type: "brush";
+    readonly areas: readonly [];
+};
+/** The first and the last category a brush covers, by index. */
+export interface BrushedSpan {
+    from: number;
+    to: number;
+}
+/**
+ * The categories a finished brush covers, read off the library's `brushEnd`
+ * event — its one area's range along the category axis, which it gives in
+ * category indexes — clamped to the `count` there are; `null` for a brush
+ * that covers none (one taken away by a click, or dragged off the plot).
+ */
+export declare function brushedSpan(said: unknown, count: number): BrushedSpan | null;
+/**
+ * Whether the reader's main pointer is a finger (`pointer: coarse`): a
+ * phone or a tablet, where a chart is brushed not at all. The library takes
+ * a touch on the plot as the start of a drag and holds the page still under
+ * it, so a finger that landed on a chart to scroll past it would brush it
+ * instead; there the first tap reads a mark and the second opens its menu
+ * (`EChart`), and the table layout picks a span with Shift where a keyboard
+ * is. Read live; where the platform cannot say, a desktop is assumed.
+ */
+export declare function useCoarsePointer(): boolean;
+//# sourceMappingURL=cartesianBrush.d.ts.map

package/dist/ui/charts/cartesianBrush.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianBrush.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/cartesianBrush.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;;;GASG;AAEH,8EAA8E;AAC9E,wBAAgB,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAOpD;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,cAAc,CAAC;AAEpC;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,UAAU,GAChB,MAAM,GAAG,SAAS,CAoBpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC3C,iBAAiB,EAAE,OAAO,GACzB,IAAI,CAMN;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;CAIf,CAAC;AAEX,4DAA4D;AAC5D,eAAO,MAAM,WAAW;;;CAAwC,CAAC;AAEjE,gEAAgE;AAChE,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAa5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C"}

package/dist/ui/charts/cartesianFit.d.ts

@@ -0,0 +1,72 @@
+import { EChartsCoreOption } from 'echarts/core';
+import { CartesianPlan } from './cartesianPlan.js';
+import { ChartTheme } from './theme.js';
+import { ZoomWindow } from './cartesianZoom.js';
+/**
+ * How far below the axis line the title under the plot sits: a line of
+ * ticks (some 20px) and a clear line of air under it.
+ */
+export declare const TITLE_GAP_UNDER = 36;
+/** How far a value label stands off its mark's end (the library's default). */
+export declare const LABEL_DISTANCE = 5;
+/**
+ * How the category names on a bar chart's axis fit the width they have.
+ *
+ * Side by side while every name fits its band; at a slant once one does
+ * not, each still under its own bar, cut at a length a slant can carry; and
+ * only when a band is narrower than a line of text does the axis name every
+ * few bars instead — the first and the last always among them. Metabase
+ * turns its labels the same way; the library itself only thins them, which
+ * showed every other name of 16 event types with room to spare.
+ */
+export declare function categoryFit(names: readonly string[], width: number, measure: (text: string) => number, horizontal: boolean, 
+/**
+ * The names are the days or months of a time axis, in order. Those are
+ * never slanted: a reader carries a date across the gap between two
+ * ticks, so the axis writes every few flat, the first always among them,
+ * as Metabase's time axis does.
+ */
+dated?: boolean): EChartsCoreOption;
+/**
+ * How the value labels past the marks' ends are written: flat, turned to
+ * run up from the bar's end, or not at all.
+ */
+export type LabelFit = 'flat' | 'upright' | 'none';
+/**
+ * What the plot's size changes about a cartesian chart: how its category
+ * names stand (`categoryFit`), and which value labels it writes.
+ *
+ * The library's `hideOverlap` dropped whichever label it met second, so a
+ * crowded chart kept every other number, or two in three, in no order a
+ * reader could see — and a bar with no number over it reads as a bar with
+ * no value (2026-09-23 audit). The rule here is one a reader can predict:
+ *
+ * - **over the bars' ends**, every label is written flat where the widest
+ *   of them fits the room a bar has, and none where it does not — the
+ *   numbers stay in the tooltip and the accessible table, and a long row's
+ *   highest and lowest keep their flat words. Only where the analyst asked
+ *   for every number (`labels: true`) are they turned to run up from the
+ *   bar's end when a line of text still fits (second review R2-74). All or
+ *   none, per chart.
+ * - **inside a stacked segment**, a part is written where the segment is
+ *   tall enough for a line and wide enough for the number — judged against
+ *   the scale the chart owns (`sharedScales`), so it is the segment's real
+ *   size — and a segment too small keeps its number to the tooltip, as a
+ *   pie's sliver does.
+ * - **on a line or an area**, every point's number where the widest fits
+ *   the step between two points, and none where it does not; two lines'
+ *   numbers at one height are moved apart rather than dropped.
+ *
+ * It also cuts an axis title to the room its side has, rather than letting
+ * it run off the plot.
+ *
+ * Zoomed (`window`), it fits the categories on screen rather than all of
+ * them: a year of days narrowed to a week names every day and has room for
+ * each day's number again.
+ */
+export declare function cartesianFit(plan: CartesianPlan, width: number, height: number, 
+/** How wide a line of text is, at the chart's text size. */
+measure: (text: string) => number, window?: ZoomWindow, 
+/** The chart's type: a value label is a step under its text. */
+text?: Pick<ChartTheme['text'], 'size' | 'labelSize'>): EChartsCoreOption;
+//# sourceMappingURL=cartesianFit.d.ts.map

package/dist/ui/charts/cartesianFit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianFit.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/cartesianFit.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGtD,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,oBAAoB,CAAC;AAQrE,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAE5B;;;GAGG;AACH,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC,+EAA+E;AAC/E,eAAO,MAAM,cAAc,IAAI,CAAC;AAuBhC;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACjC,UAAU,EAAE,OAAO;AACnB;;;;;GAKG;AACH,KAAK,UAAQ,GACZ,iBAAiB,CAsCnB;AAqED;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM;AACd,4DAA4D;AAC5D,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACjC,MAAM,CAAC,EAAE,UAAU;AACnB,gEAAgE;AAChE,IAAI,GAAE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,CAAuB,GACzE,iBAAiB,CA8PnB"}

package/dist/ui/charts/cartesianMarks.d.ts

@@ -0,0 +1,116 @@
+import { DerivedKind } from '../../model/index.js';
+import { CartesianPlan, DrawnSeries } from './cartesianPlan.js';
+import { ChartTheme } from './theme.js';
+type Side = 'left' | 'right';
+/** How a mark names the value axis it stands on, for the plan's direction. */
+export type AxisIndex = (side: Side) => object;
+/**
+ * The reference lines and target bands of each axis, on one carrier: a
+ * series with no points of its own, so it takes no slot beside the bars in
+ * a category's band. Here each is named inside the plot — a line over its
+ * right end, a band in its top left corner — which is where a chart with no
+ * room for a margin keeps them; `referenceCaptions` moves the names out
+ * beside the plot where there is room.
+ */
+export declare function referenceSeries(plan: CartesianPlan, theme: ChartTheme, axisIndex: AxisIndex): object[];
+/**
+ * The period still under way (second review R2-P1-7), shaded behind its
+ * marks across its whole category and named 「进行中」 at the top: it is
+ * drawn, as a card's sparkline draws it, but its days so far are no period,
+ * and a last bar or a line that ends low in them read as a fall. On a
+ * carrier of its own, as the target bands are, so it takes no slot.
+ */
+export declare function ongoingSeries(plan: CartesianPlan, theme: ChartTheme, axisIndex: AxisIndex): object[];
+/** How far a name beside the plot stands off the plot's edge. */
+export declare const CAPTION_DISTANCE = 6;
+/**
+ * Where the reference lines' and target bands' names stand on a chart of
+ * this size: out of the plot, in a margin on its right (`right`, the room
+ * the grid keeps there), or inside it, as `referenceSeries` put them.
+ *
+ * Inside, a line's name sat over its right end and a band's in its top
+ * left corner, on whatever the marks put there: the last bars and their
+ * numbers, the lowest point's word, the first date under the axis (the
+ * 2026-09-26 review P1-5 — 「48 小时」 through the numbers of the last
+ * warehouse, 「目标 ≤ 3%」 over 「最低 0%」 and the first week, 「日均」
+ * on 「中位数」). Beside the plot, level with its line or its band's
+ * middle, nothing of the data is under a name; two names nearer than a line
+ * of text are set a line apart, each as near its own height as that allows,
+ * and none below the plot's floor.
+ *
+ * Only an upright chart with the one value axis has that margin: a right
+ * axis's ticks stand there, and lying on its side a chart's lines stand up
+ * and are named at their top. Nor where the widest name would take more
+ * than a quarter of the width: a narrow panel keeps its plot, and the
+ * names stay inside.
+ */
+export declare function referenceCaptions(plan: CartesianPlan, width: number, 
+/** The plot's height, as near as the fit can say it before drawing. */
+plotHeight: number, 
+/** How wide a line of text is, at the chart's text size. */
+measure: (text: string) => number, 
+/** The height a name takes: two are set this far apart at least. */
+lineHeight: number): {
+    right?: number;
+    series: object[];
+};
+/**
+ * The highest and the lowest point of one series, as the library pins a
+ * mark on it: a dot in the series' colour ringed by the ground, and beside
+ * it 「最高 1.2万」 and 「最低 980」. The series' own value label is not
+ * written at those two points (`extremeIndexes`): the mark says the number
+ * already.
+ *
+ * On a bar both words stand past the bar's end, where its own number would:
+ * under the lowest bar's end the word ran down its body and over the bars
+ * beside it (2026-09-26 review P1-5, 「最低 ¥1,940」). On a line the highest
+ * point's word stands over it and the lowest's under it — over it too near
+ * the plot's floor, where under it the word fell on the first category's
+ * name (「最低 0%」 on 「2024年8月26日」).
+ */
+export declare function extremeMarks(plan: CartesianPlan, entry: DrawnSeries, fill: string, theme: ChartTheme): object;
+/**
+ * The highest and the lowest point's marks, each with its word, always flat
+ * (second review R2-74): the two are the only words on a row whose own
+ * numbers are not written, so nothing beside them can collide, and a word
+ * turned on its side — 「最高 5」 read from the bottom up — was the hardest
+ * text on the busiest charts. Over a short bar the word may cross a taller
+ * neighbour's body; its ground-coloured outline keeps it legible there. A
+ * word near either end of the row is set off to the side the plot has room
+ * on, so it stays inside the plot.
+ */
+export declare function extremePoints(plan: CartesianPlan, entry: DrawnSeries): object[] | undefined;
+/** The dot on the highest and the lowest point, in pixels. */
+export declare const EXTREME_DOT = 8;
+/**
+ * The highest and the lowest point's words as the series' own value
+ * labels, where it writes every value: 「最高 ¥4.53万」 in the highest
+ * bar's own label, in its own slot, turned as its neighbours are, the
+ * mark a dot without a caption. Beside the mark, the word stood flat over
+ * the row of upright numbers beside it (second review R2-P1-8: 「最低
+ * ¥1,940」 over 「¥5,359」 and 「¥3,046」). Where the series writes only
+ * its peak and trough, or nothing, the mark says them: `undefined`.
+ */
+export declare function carriedExtremes(plan: CartesianPlan, entry: DrawnSeries): ReadonlyMap<number, string> | undefined;
+/** The highest and the lowest point's words, by their index, if marked. */
+export declare function extremeWords(plan: CartesianPlan, entry: DrawnSeries): ReadonlyMap<number, string> | undefined;
+/** Every series' carried extremes' texts, for the room the labels take. */
+export declare function carriedTexts(plan: CartesianPlan): string[];
+/** The points of a series whose value its extreme marks already write. */
+export declare function extremeIndexes(plan: CartesianPlan, entry: DrawnSeries): ReadonlySet<number>;
+/**
+ * How each derived line is dashed: two of them on one chart — a trend and a
+ * moving average — are both the foreground, so the stroke is what tells
+ * them apart, here and in the legend (`DERIVED_STROKE`).
+ */
+export declare const DERIVED_STROKE: Record<DerivedKind, 'dashed' | 'dotted'>;
+/**
+ * The derived lines: the foreground in dashes over the marks, on the axis
+ * of the series each is computed from, never stacked and without dots — a
+ * computed line is read along, not point by point. The tooltip names each
+ * as computed (`cartesianTooltip`); a press on one opens nothing, since it
+ * stands for no group.
+ */
+export declare function derivedSeries(plan: CartesianPlan, theme: ChartTheme, axisIndex: AxisIndex): object[];
+export {};
+//# sourceMappingURL=cartesianMarks.d.ts.map

package/dist/ui/charts/cartesianMarks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianMarks.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/cartesianMarks.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,sBAAsB,CAAC;AAEvE,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,KAAK,IAAI,GAAG,MAAM,GAAG,OAAO,CAAC;AAE7B,8EAA8E;AAC9E,MAAM,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC;AAiD/C;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,SAAS,GACnB,MAAM,EAAE,CAwDV;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,SAAS,GACnB,MAAM,EAAE,CA6BV;AAKD,iEAAiE;AACjE,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAWlC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,MAAM;AACb,uEAAuE;AACvE,UAAU,EAAE,MAAM;AAClB,4DAA4D;AAC5D,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;AACjC,oEAAoE;AACpE,UAAU,EAAE,MAAM,GACjB;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAiFtC;AAgDD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,UAAU,GAChB,MAAM,CA4BR;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,WAAW,GACjB,MAAM,EAAE,GAAG,SAAS,CAuDtB;AAED,8DAA8D;AAC9D,eAAO,MAAM,WAAW,IAAI,CAAC;AAS7B;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,WAAW,GACjB,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAIzC;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAC1B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,WAAW,GACjB,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAYzC;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,EAAE,CAI1D;AAED,0EAA0E;AAC1E,wBAAgB,cAAc,CAC5B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,WAAW,GACjB,WAAW,CAAC,MAAM,CAAC,CAGrB;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,WAAW,EAAE,QAAQ,GAAG,QAAQ,CAKnE,CAAC;AAOF;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,SAAS,GACnB,MAAM,EAAE,CAmBV"}

package/dist/ui/charts/cartesianOption.d.ts

@@ -0,0 +1,32 @@
+import { EChartsCoreOption } from 'echarts/core';
+import { CartesianData } from '../../analysis/index.js';
+import { CartesianContext, CartesianPlan } from './cartesianPlan.js';
+import { ChartTheme } from './theme.js';
+export { drawnSeries, type CartesianContext, type DrawnSeries, } from './cartesianPlan.js';
+/**
+ * Past this many points a line draws no dot on each: a dot per day of a year
+ * is a smear, and the tooltip names the point under the pointer anyway.
+ */
+export declare const DOTS_UP_TO = 60;
+/**
+ * A bar, line, area or combo chart as the library draws it, from the
+ * kernel's shape.
+ *
+ * What it adds to the data is only display: which axis carries the numbers
+ * and on what scale (`sharedScales`, so two axes share their gridlines),
+ * how they are written (short on the ticks and over the bars, whole in the
+ * tooltip — all through the column's own format), where a value label goes,
+ * the totals over a stack, and the reference lines. Which labels the plot
+ * has room for is decided by its size (`cartesianFit`), never by the
+ * library dropping whichever one it met second. Everything a mark stands
+ * for was decided by `shapeChart`.
+ */
+export declare function cartesianOption(data: CartesianData, context: CartesianContext, theme: ChartTheme): EChartsCoreOption;
+/** The option for a plan already made — `Cartesian` makes it once. */
+export declare function optionOf(plan: CartesianPlan, theme: ChartTheme): EChartsCoreOption;
+/** The library's bounds on a bar's width, from the theme's. */
+export declare function barBounds(theme: ChartTheme): {
+    barMaxWidth: number;
+    barMinWidth?: number;
+};
+//# sourceMappingURL=cartesianOption.d.ts.map

package/dist/ui/charts/cartesianOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianOption.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/cartesianOption.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAC;AAe5B,OAAO,EAAgC,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAE3E,OAAO,EACL,WAAW,EACX,KAAK,gBAAgB,EACrB,KAAK,WAAW,GACjB,MAAM,oBAAoB,CAAC;AAE5B;;;GAGG;AACH,eAAO,MAAM,UAAU,KAAK,CAAC;AAE7B;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,UAAU,GAChB,iBAAiB,CAEnB;AAED,sEAAsE;AACtE,wBAAgB,QAAQ,CACtB,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,UAAU,GAChB,iBAAiB,CAiXnB;AAED,+DAA+D;AAC/D,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAOA"}

package/dist/ui/charts/cartesianPlan.d.ts

@@ -0,0 +1,263 @@
+import { CartesianData, DerivedLine, PlacedLine } from '../../analysis/index.js';
+import { ChartSpec } from '../../model/index.js';
+import { ColumnTitle, FilledNote, SeriesName, ToneOf, ValueLabel } from './family.js';
+import { MarkWords } from './markWords.js';
+import { NiceScale } from './scale.js';
+import { drawnSeries, withoutHidden, DrawnSeries } from './cartesianSeries.js';
+export { drawnSeries, withoutHidden, type DrawnSeries };
+/** What a cartesian drawing reads besides its data. */
+export interface CartesianContext {
+    spec?: ChartSpec;
+    label: ValueLabel;
+    column: ColumnTitle;
+    /**
+     * What a pivoted series is called (`useSeriesName`): 「新客：是」 for a
+     * split by a yes/no field; left out, its value as its column reads it.
+     */
+    seriesName?: SeriesName;
+    /**
+     * The tone a split value's option gives it (`useToneOf`): a series split
+     * by a toned enum wears its tone's colour, as the pie's slice and the
+     * value's badge do (`heldTones`).
+     */
+    toneOf?: ToneOf;
+    locale?: string;
+    /** Whether the marks grow into place (`useChartMotion`). */
+    animate: boolean;
+    /** Whether a press on a mark opens the follow-up menu. */
+    pickable: boolean;
+    /**
+     * The category ticks written short, one per point, where the axis is a
+     * date bucket (`shortDateTicks`); a point with none is written as its
+     * column reads it. The tooltip still names the whole bucket.
+     */
+    ticks?: readonly (string | undefined)[];
+    /**
+     * The short ticks of some of the axis's buckets, as `ticks` writes all of
+     * them: where a thinned axis names every few, the year is written where
+     * it changes among the ones named, not among all (`datedFit`).
+     */
+    tickFor?: (values: readonly unknown[]) => (string | undefined)[] | undefined;
+    /**
+     * What joins two column titles into one axis title, 「、」 or ", " — an
+     * axis of a two-axis chart that measures several metrics names them all.
+     */
+    join?: string;
+    /** A filled-in value as the tooltip says it (`useFilledNote`). */
+    filled?: FilledNote;
+    /**
+     * The series the reader switched off in the legend, by key. They keep
+     * their colour and their place in the legend, and are drawn nowhere else:
+     * not as marks, not in a stack's shares or totals, not on a scale, not in
+     * the tooltip — the axis is fitted to what is left (D33 batch A).
+     */
+    hidden?: ReadonlySet<string>;
+    /**
+     * What a change in the tooltip is measured against, 「较上一期」: given,
+     * a time axis's tooltip says how each number moved from the bucket
+     * before (`bucketChange`); left out, it says only the numbers.
+     */
+    against?: string;
+    /**
+     * Whether a long axis also zooms by gesture — a pinch, Ctrl + wheel — as
+     * well as by its slider (`zoomOption`): a workbench's chart, not a
+     * dashboard panel's or a read-only embedding's.
+     */
+    zoomGestures?: boolean;
+    /**
+     * Whether a drag along the axis brushes a stretch of it for the follow-up
+     * menu (D33 Q52, `brushOption`): a time axis whose marks are pressable.
+     */
+    brushes?: boolean;
+    /**
+     * What the marks drawn over the chart say (D33 batch B): a derived line's
+     * name, a statistic line's caption, the words by the highest and lowest
+     * points. Left out, those say nothing but their numbers.
+     */
+    words?: MarkWords;
+}
+type Side = 'left' | 'right';
+/** What decides the stack a series stands in. */
+type Stackable = Pick<DrawnSeries, 'side' | 'configured' | 'kind'>;
+/**
+ * The widest a category name is drawn upright before the bars lie on their
+ * side, in pixels at the page's 12px: some eight CJK characters or a dozen
+ * Latin ones. Past it the names slant, and a slanted name of a ranking is
+ * read with the head tilted — Metabase and every BI tool turn such a chart
+ * into a row chart instead (2026-09-23 audit).
+ */
+export declare const LONG_NAME = 96;
+/**
+ * Whether a bar chart lies on its side: as the analyst said, and — where
+ * they said nothing — when a category's name is too long to stand under
+ * its bar. A time axis never does: dates read left to right, and they are
+ * short. Lines, areas and combos stay upright: a line lying on its side is
+ * no line chart anyone reads.
+ */
+export declare function drawsHorizontal(spec: ChartSpec | undefined, names: readonly string[], dated: boolean, measure?: (text: string) => number): boolean;
+/**
+ * The stacks of a cartesian chart and the shares they are drawn as.
+ *
+ * A stack as the library draws it is the spec's name on one axis. Series
+ * measured against two axes are two scales, and stacking a count on top
+ * of an amount drew the count at the amount's height; each axis stacks
+ * its own. A line never stacks: its point would stand at the running sum
+ * while its label says its own value (「¥640」 at ¥1920), with no band
+ * under it to show the part it adds — it draws its own values.
+ *
+ * Stacked to 100% (`percentStack`): a bar or an area chart only — a
+ * combo's line would stand on a scale of shares — whose stacks are then
+ * drawn as each part's share of its stack at that category, so every
+ * stack reaches the top. The reading table says the same shares.
+ */
+export declare function stackPlan(data: CartesianData, spec: ChartSpec | undefined): {
+    stackOf(series: Stackable): string | undefined;
+    /** Whether the stacks are drawn as shares. */
+    percent: boolean;
+    /** A series' share of its stack at one point, when it is drawn as one. */
+    shareAt(key: string, index: number): number | undefined;
+};
+/**
+ * Everything a cartesian chart decides before it knows its theme or its
+ * size: which way it lies, its series and their stacks, what each mark
+ * draws, the scale of each value axis, and the text each label writes.
+ * The option (`cartesianOption`) and the size's adjustments
+ * (`cartesianFit`) both read it, so the two cannot disagree about, say,
+ * which labels there are.
+ */
+export interface CartesianPlan {
+    data: CartesianData;
+    context: CartesianContext;
+    horizontal: boolean;
+    /** The category names, as their column reads them. */
+    names: string[];
+    /**
+     * A category's tick, by its name — the library hands a tick its name and
+     * an index counted from the zoom's first category, so the name is the
+     * one to go by: short on a time axis (`ticks`), cut for its axis else.
+     */
+    tickOf(name: string): string;
+    /** The series drawn: every one the legend has not switched off. */
+    series: DrawnSeries[];
+    /**
+     * Every series, switched off or not, in the colour each keeps either way:
+     * what the legend lists.
+     */
+    legend: DrawnSeries[];
+    /** The value axes there are: the left, and the right when anything is on it. */
+    sides: Side[];
+    stackOf(entry: DrawnSeries): string | undefined;
+    /** The members of each stack, by the stack's name. */
+    stacks: Map<string, DrawnSeries[]>;
+    /** Whether a series stands in a stack of more than one. */
+    stacked(entry: DrawnSeries): boolean;
+    /** Whether a series is drawn as its shares of a 100% stack. */
+    asShares(entry: DrawnSeries): boolean;
+    shareAt(entry: DrawnSeries, index: number): number | undefined;
+    /** What a series draws at one point: its value, or its share. */
+    drawnAt(entry: DrawnSeries, index: number): number | null;
+    /** A drawn number as text: a share as a percentage, a value as its column. */
+    drawnText(entry: DrawnSeries, value: number): string;
+    /** Whether a series writes its values at all (`valueLabelsOn`). */
+    labelled(entry: DrawnSeries): boolean;
+    /**
+     * Whether a series' bars, left to their default, write only their peak
+     * and trough (`peaksOnlyLabels`), as its extremes are marked, rather than
+     * a number over every bar: an upright chart of `PEAKS_ONLY_FROM` bars or
+     * more that stand on their own and have a peak apart from their trough.
+     * Zoomed to fewer than that, every bar on screen writes its number again
+     * (`cartesianFit`).
+     */
+    peaksOnly(entry: DrawnSeries): boolean;
+    /**
+     * Whether the kernel filled a series' value at one point rather than
+     * measured it (`CartesianData.points[].filled`): a known 0, still drawn —
+     * the line drops to it, the bar stands at nothing — but never labelled,
+     * since a screen of 「0」 buried the bars that have a number (D23, Q14).
+     */
+    filledAt(entry: DrawnSeries, index: number): boolean;
+    /**
+     * What a stacked bar's segment writes inside itself at one point: its
+     * part — and nothing for a part of nothing, or for the one part a stack
+     * has, which is its total and is written over it.
+     */
+    insideText(entry: DrawnSeries, index: number): string;
+    /**
+     * The bar stacks that write a total over themselves, and each total:
+     * `every` is each stack's sum, `texts` what is written over it — the same,
+     * or on a long upright row of stacks left to its default only its highest
+     * and lowest, with their words (「最高 ¥4.5万」), as a long row of single
+     * bars writes only its peak and trough (`peaksOnly`). Zoomed to fewer
+     * stacks than that, `cartesianFit` writes `every` again.
+     */
+    totals: {
+        members: DrawnSeries[];
+        texts: string[];
+        every: string[];
+        peaksOnly: boolean;
+    }[];
+    /** Every value label written past a mark's end, a total's included. */
+    outerTexts: string[];
+    /**
+     * The value axes' scales, where the chart owns them (`sharedScales`):
+     * every axis, unless one carries a bound the analyst set — then the
+     * library rounds, and two axes are lined up by its `alignTicks`.
+     */
+    scales: Partial<Record<Side, NiceScale>>;
+    /** The span each value axis runs, owned or as far as the marks reach. */
+    span(side: Side): {
+        min: number;
+        max: number;
+    };
+    /**
+     * The highest and the lowest the marks reach on one axis, and — with
+     * `withLines` — its reference lines.
+     */
+    reach(side: Side, withLines: boolean): {
+        high: number;
+        low: number;
+    };
+    /** Whether an axis steps in whole numbers only. */
+    wholeOn(side: Side): boolean;
+    /** Whether an axis measures shares: a 100% stack stands on it. */
+    sharesOn(side: Side): boolean;
+    /**
+     * Whether an axis is stepped by powers of ten: the spec asks, and every
+     * number on it is above zero (`logScaleFits`, D33 batch E).
+     */
+    logOn(side: Side): boolean;
+    /** The axes the spec asks a log scale of and whose numbers refuse it. */
+    logRefused: Side[];
+    /** Every value an axis carries: its series' and its reference lines'. */
+    valuesOn(side: Side): number[];
+    /** The reference lines, where the kernel placed them. */
+    lines: PlacedLine[];
+    /** The derived lines drawn: every one the legend has not switched off. */
+    derived: DrawnDerived[];
+    /** Every derived line, switched off or not: what the legend lists. */
+    derivedLegend: DrawnDerived[];
+    /**
+     * Whether a series marks its highest and lowest point: the spec asks or
+     * its bars write only those two (`peaksOnly`), the
+     * kernel found two to mark, and it stands on its own — a segment of a
+     * stack stands at the stack's height, and past `LARGE_FROM` bars there is
+     * no mark to hang one on.
+     */
+    extremesOf(entry: DrawnSeries): {
+        high: number;
+        low: number;
+    } | undefined;
+}
+/**
+ * Whether 「自动」 writes only the highest and the lowest total over some
+ * stack of these bars: one of more than one bar whose totals differ. Where
+ * none does, every total is written (`CartesianPlan.totals`).
+ */
+export declare function stackPeaksFound(data: CartesianData, spec: ChartSpec | undefined): boolean;
+/** A derived line as drawn: the kernel's, its name and its axis. */
+export interface DrawnDerived extends DerivedLine {
+    name: string;
+    side: Side;
+}
+export declare function cartesianPlan(data: CartesianData, context: CartesianContext): CartesianPlan;
+//# sourceMappingURL=cartesianPlan.d.ts.map

package/dist/ui/charts/cartesianPlan.d.ts.map

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

package/dist/ui/charts/cartesianSeries.d.ts

@@ -0,0 +1,41 @@
+import { CartesianData } from '../../analysis/index.js';
+import { CartesianSeries } from '../../model/index.js';
+import { CartesianContext } from './cartesianPlan.js';
+/**
+ * `data` without the series `hidden` names — what the marks, the scales and
+ * the reading table say once the legend switched them off. The same object
+ * when nothing is hidden.
+ */
+export declare function withoutHidden(data: CartesianData, hidden: ReadonlySet<string> | undefined): CartesianData;
+/** One series as drawn: the kernel's, and what the spec says about it. */
+export interface DrawnSeries {
+    key: string;
+    metric: string;
+    /** Its name in the legend and the tooltip. */
+    name: string;
+    /** A CSS colour: a theme slot or the one the spec pinned. */
+    color: string;
+    side: 'left' | 'right';
+    configured?: CartesianSeries;
+    /** The mark: the chart's own, or — in a combo — the one the spec names. */
+    kind: 'bar' | 'line' | 'area';
+}
+/** The series as the legend, the tooltip and the marks all name them. */
+export declare function drawnSeries(data: CartesianData, { spec, label, column, seriesName, words, toneOf, }: Pick<CartesianContext, 'spec' | 'label' | 'column' | 'seriesName' | 'words' | 'toneOf'>): DrawnSeries[];
+/**
+ * A stack's total at each point: the sum of its parts that measured
+ * something. A stack made only of filled parts measured nothing: `null`.
+ */
+export declare function stackSums(members: readonly {
+    key: string;
+}[], points: CartesianData['points']): (number | null)[];
+/**
+ * The places of the highest and the lowest of some numbers, the first of
+ * each where several tie; nothing where there are fewer than two numbers,
+ * or all are equal, which have no peak and trough to tell apart.
+ */
+export declare function peaksOf(values: readonly (number | null)[]): {
+    high: number;
+    low: number;
+} | undefined;
+//# sourceMappingURL=cartesianSeries.d.ts.map

package/dist/ui/charts/cartesianSeries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianSeries.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/cartesianSeries.ts"],"names":[],"mappings":"AAaA,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,GACtC,aAAa,CASf;AAED,0EAA0E;AAC1E,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,2EAA2E;IAC3E,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;CAC/B;AAED,yEAAyE;AACzE,wBAAgB,WAAW,CACzB,IAAI,EAAE,aAAa,EACnB,EACE,IAAI,EACJ,KAAK,EACL,MAAM,EACN,UAAkB,EAClB,KAAK,EACL,MAAM,GACP,EAAE,IAAI,CACL,gBAAgB,EAChB,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,OAAO,GAAG,QAAQ,CAChE,GACA,WAAW,EAAE,CA2Cf;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,SAAS;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,EACnC,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,GAC9B,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAUnB;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CACrB,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GACjC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAS3C"}