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

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

@@ -0,0 +1,200 @@
+import { ReactNode } from 'react';
+import { FiveNumbers } from '../../analysis/boxplot.js';
+import { Ohlc } from '../../analysis/candlestick.js';
+import { ChartData, DerivedGap } from '../../analysis/index.js';
+import { ChartSpec, DerivedSeries, RecordData } from '../../model/index.js';
+import { ValueLabel } from '../charts/family.js';
+/** An alias offered for a slot, named as its column is titled. */
+export interface Choice {
+    value: string;
+    label: string;
+}
+/** The result on hand, as the options page needs it. */
+export interface OptionsShape {
+    groups: Choice[];
+    /** Every metric: what a card's headline may be. */
+    metrics: Choice[];
+    /**
+     * The metrics a mark can measure: every one but a moment (`momentMetrics`
+     * — the earliest or the latest of a date), which is written out, not drawn.
+     */
+    quantities: Choice[];
+    /** The moments among `metrics`, by alias. */
+    moments: ReadonlySet<string>;
+    /** Metrics that add up across rows: the ones a pie may merge a tail of. */
+    additive: ReadonlySet<string>;
+    /** What each metric is a quantity of (`metricMeasure`), by alias. */
+    measures: ReadonlyMap<string, string>;
+    /**
+     * The dimensions that are date buckets, by alias: an axis of dates never
+     * lies on its side by itself (`drawsHorizontal`).
+     */
+    dated?: ReadonlySet<string>;
+    /**
+     * Each field's five numbers the quantities hold (`fiveNumberSets`): what a
+     * boxplot can draw.
+     */
+    fiveNumbers?: readonly FiveNumbers[];
+    /**
+     * Each field's four numbers of a candle the quantities hold (`ohlcSets`):
+     * what a candlestick can draw.
+     */
+    ohlc?: readonly Ohlc[];
+    /** The dimensions that are date buckets by day: what a calendar lays out. */
+    daily?: ReadonlySet<string>;
+}
+/**
+ * What a hint line under a control wears on this panel.
+ *
+ * `FieldDescription` ships `text-muted-foreground`, which lands at 4.34:1 on
+ * the panel's sidebar ground — under the 4.5:1 axe asks of a 14px line, the
+ * same measurement {@link OptionsSection} records for the same grey. A hint
+ * is the sentence that says why a control is the way it is, so it is toned
+ * rather than faded: quieter than the label above it, and still legible.
+ */
+export declare const HINT = "fve:text-quiet-foreground";
+/** What every options page receives. */
+export interface OptionsPageProps {
+    chart: ChartSpec;
+    shape: OptionsShape;
+    /** The rows that ran, for the choices only they can name (funnel stages). */
+    rows: readonly RecordData[];
+    /** A group value as its field shows it. */
+    label: ValueLabel;
+    onChange(chart: ChartSpec): void;
+    /**
+     * The chart as drawn over the rows on screen, for the choices only its
+     * numbers can judge — a log scale over values that hold 0 (D33 batch E),
+     * a split past the palette (Q56). Left out before any rows.
+     */
+    data?: ChartData;
+    /**
+     * Why a derived line could not be drawn over the result on screen
+     * (`derivedGap`, Q53), with the groups it was cut at; `undefined` when it
+     * can, and left out altogether before any rows — nothing to judge yet.
+     */
+    gapOf?: (derived: Pick<DerivedSeries, 'kind' | 'metric' | 'window'>) => {
+        gap: DerivedGap;
+        limit?: number;
+    } | undefined;
+    /** The window a moving average runs over when none is typed. */
+    defaultWindow?: number;
+}
+/** A slot of the chart, filled from one list of aliases. */
+export declare function SlotSelect<V extends string>({ label, items, value, onChange, }: {
+    label: string;
+    items: readonly Choice[];
+    value: V;
+    onChange(value: V): void;
+}): import('react').JSX.Element;
+/**
+ * A slot that may stay empty. The empty choice is a word rather than a
+ * blank, because a select with nothing in it reads as broken.
+ */
+export declare function OptionalSlotSelect({ label, none, items, value, onChange, }: {
+    label: string;
+    none: string;
+    items: readonly Choice[];
+    value: string | undefined;
+    onChange(value: string | undefined): void;
+}): import('react').JSX.Element;
+/**
+ * One yes-or-no setting, named after itself.
+ *
+ * A `hint` is the line under the label that says why the box is the way it
+ * is — above all why it cannot be ticked. A disabled control that says
+ * nothing is the defect: the analyst sees a setting that refuses the press
+ * and is told neither what it would do nor what is missing. The hint is tied
+ * to the box with `aria-describedby`, so a reader hears the reason with the
+ * name rather than having to go looking for the text beside it.
+ */
+export declare function CheckField({ label, hint, checked, disabled, onChange, 'data-slot': slot, }: {
+    label: string;
+    /** Why the box reads as it does; shown under the label. */
+    hint?: string;
+    checked: boolean;
+    disabled?: boolean;
+    onChange(checked: boolean): void;
+    'data-slot'?: string;
+}): import('react').JSX.Element;
+/** One choice among a few words, all of them on screen at once. */
+export declare function ChoiceField<V extends string>({ label, hint, items, value, onChange, 'data-slot': slot, }: {
+    label: string;
+    /** What the current choice means; shown under the choices. */
+    hint?: string;
+    /** A choice `disabled` stays on screen, greyed; the hint says why. */
+    items: readonly {
+        value: V;
+        label: string;
+        disabled?: boolean;
+    }[];
+    value: V;
+    onChange(value: V): void;
+    'data-slot'?: string;
+}): import('react').JSX.Element;
+/** A number that may be left unset, in the registry's box. */
+export declare function NumberField({ label, hint, value, min, max, onChange, }: {
+    label: string;
+    hint?: string;
+    value: number | undefined;
+    /** Below this the number is refused rather than written. */
+    min?: number;
+    /** Above this, likewise. */
+    max?: number;
+    onChange(value: number | undefined): void;
+}): import('react').JSX.Element;
+/** A few words the analyst types, such as an axis title. */
+export declare function TextField({ label, value, placeholder, onChange, }: {
+    label: string;
+    value: string | undefined;
+    /**
+     * What stands when nothing is typed — the default the chart draws, not a
+     * hint — so it is toned as `NameField`'s is: quieter than a typed value,
+     * still readable. An empty box that hides its default reads as "nothing",
+     * when the axis is in fact titled (2026-09-23 audit).
+     */
+    placeholder?: string;
+    onChange(value: string | undefined): void;
+}): import('react').JSX.Element;
+/**
+ * A name typed where the name is drawn: a box with no label above it,
+ * wearing what the thing would be called as its placeholder.
+ *
+ * {@link TextField} is the shape a setting of its own takes — a label over a
+ * box, on its own line. A name is not a setting beside the thing it names;
+ * it *is* the thing's first line, and a label over every stage of a funnel
+ * would repeat one word down the whole list. So the label is the box's
+ * accessible name and nothing on screen, and the default is the placeholder,
+ * which is also what an emptied box goes back to saying.
+ *
+ * **The placeholder here is not a hint, it is the name.** Until the analyst
+ * renames a stage, the placeholder *is* what that stage is called on screen,
+ * so the registry's `placeholder:text-muted-foreground` — 4.34:1 on this
+ * panel's ground, under the 4.5:1 axe asks — would grey out the only word
+ * naming the row. It is overridden to `text-quiet-foreground`: still quieter
+ * than a typed name, and still readable. The same call `OptionsSection`
+ * records below.
+ */
+export declare function NameField({ label, placeholder, value, onChange, }: {
+    label: string;
+    /** What it is called when nothing has been typed. */
+    placeholder: string;
+    value: string | undefined;
+    onChange(value: string | undefined): void;
+}): import('react').JSX.Element;
+/** A titled run of settings on one page. */
+export declare function OptionsSection({ name, title, className, children, }: {
+    name: string;
+    title?: string;
+    className?: string;
+    children: ReactNode;
+}): import('react').JSX.Element;
+/**
+ * A line's or a band's name, typed where it is set: shown in words, and a
+ * key again where the words are left as shown (`useSaidText`).
+ */
+export declare function ReferenceLabel({ value, onChange, }: {
+    value: string | undefined;
+    onChange(value: string | undefined): void;
+}): import('react').JSX.Element;
+//# sourceMappingURL=optionControls.d.ts.map

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

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

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

@@ -0,0 +1,79 @@
+import { AnalysisColumnView } from '../../analysis/index.js';
+import { RecordData } from '../../model/index.js';
+import { RecordColumnView } from '../../record/index.js';
+import { DisplayContext } from '../kit/display.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+/**
+ * What an analysis column is read as, in the record table's words: the
+ * renderer key its cells take. A metric that is not one of its field's values
+ * is a number whatever it was computed from, so it says `number` — which is
+ * what `isNumeric` reads to put a column's digits, and its header, on the
+ * right edge. A dimension, and a metric that reads as its field (the latest
+ * of a date), keep the field's own reading — except a time bucket, which
+ * reads as the day it starts whatever the field holds its time as.
+ */
+export declare function readingOf(column: AnalysisColumnView): string;
+/**
+ * One value as the result table's cell reads it: the bucket of records with
+ * no value in the surface's words (`missingText`), a number band as the band
+ * it is, a group key or an ANY as its field's values show, and the rest —
+ * anything the field's kind has nothing to say about — as a value, a number
+ * in its column's format.
+ *
+ * The table's cells and the exported file (`analysisFile`) both read through
+ * it, so the file says what the screen said (D25 Q28).
+ *
+ * Money in a currency each record holds reads in the currency its `row`
+ * says (`rowCurrency`) — and a row whose records are in several says
+ * 「多种货币」 where its number would be, the kernel having taken that
+ * number away as no amount.
+ */
+export declare function analysisCellText(value: unknown, column: AnalysisColumnView, messages: MessageFormatters, display: DisplayContext, row?: RecordData): string;
+/**
+ * Whether a column's values are identifiers: the field reads as a value to
+ * take away character for character (`cell: 'copyable'`), which is how the
+ * record view decides the monospace of an id.
+ */
+export declare function isIdentifier(column: AnalysisColumnView): boolean;
+/**
+ * The width a column is drawn at when the table declares none: the room its
+ * header and **the values it was first drawn with** ask for, estimated from
+ * their characters — a full em for a CJK one, 0.6em for anything narrower —
+ * with a floor by reading and a ceiling.
+ *
+ * Estimated rather than measured: a measurement is a second render, and one
+ * more thing that changes. It is taken once per column, and held
+ * (`useHeldWidths`): the answer a column is first seen with sizes it, and a
+ * run that brings back a longer name or a bigger total does not move it.
+ */
+export declare function columnWidthOf(column: AnalysisColumnView, title: string, values: readonly string[]): number;
+/**
+ * Each column's width, held from the first answer it was drawn with.
+ *
+ * An automatic table layout sizes a column by its widest cell *every time*,
+ * so a run that brought back a longer name or a bigger total moved every
+ * column after it, and the column the eye was following was somewhere else
+ * after each question. Here a column is sized once — from its header and the
+ * values it first appeared with, so it fits what it was opened on — and then
+ * keeps that width for as long as it is the same column: same alias, same
+ * title, same declared width. A new column, or a renamed one, is sized from
+ * the answer it arrives with; one that left is forgotten.
+ *
+ * The widths are state kept from an earlier render, so they are set while
+ * rendering when a column is new — React's own pattern for state that
+ * follows a prop — and never in an effect, which would draw one frame at the
+ * automatic width first.
+ */
+export declare function useHeldWidths(columns: readonly {
+    column: AnalysisColumnView;
+    title: string;
+    values: () => readonly string[];
+}[]): readonly number[];
+/**
+ * The analysis column as the record table's header takes it, so the header
+ * is `SortableHeader` itself — the sort button, its marks and place, the
+ * tooltip over a cut name, the one Tab stop — rather than a second copy of
+ * it. The alias is the field: it is what the sort names.
+ */
+export declare function headerColumnOf(column: AnalysisColumnView, title: string, width: number, sortable: boolean): RecordColumnView;
+//# sourceMappingURL=tableColumns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tableColumns.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/tableColumns.ts"],"names":[],"mappings":"AAaA,OAAO,EAAe,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE/E,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAG5D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,cAAc,EACvB,GAAG,CAAC,EAAE,UAAU,GACf,MAAM,CAiBR;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAEhE;AA0BD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,MAAM,CAiBR;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS;IAChB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,SAAS,MAAM,EAAE,CAAC;CACjC,EAAE,GACF,SAAS,MAAM,EAAE,CAanB;AAID;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,OAAO,GAChB,gBAAgB,CASlB"}

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

@@ -0,0 +1,66 @@
+import { RefObject } from 'react';
+import { VirtualItem } from '@tanstack/react-virtual';
+/**
+ * How many groups a result holds before its table draws only the rows in
+ * view (ui/analysis.md「长表」). Measured, not guessed: a thousand rows drew
+ * and sorted in about 150ms in every engine, five thousand in about 550ms,
+ * ten thousand in about 1.1s — a second's freeze on every header press.
+ *
+ * Below it every row is in the document, which a reader's find-in-page and
+ * a screen reader's browse mode both want; above it, the rows around the
+ * view are drawn and the table says how many there are (`aria-rowcount`).
+ */
+export declare const VIRTUAL_ROWS_AFTER = 1000;
+/** One piece of the body as drawn: a row, or the room rows not drawn take. */
+export type BodySegment = {
+    kind: 'row';
+    index: number;
+    key: VirtualItem['key'];
+} | {
+    kind: 'gap';
+    key: string;
+    height: number;
+};
+/**
+ * The drawn rows in index order with the room between and around them, so
+ * the body is as tall as every row would make it and each drawn row sits
+ * where it would. A gap between two drawn rows is the row holding the Tab
+ * stop, kept drawn away from the others (`useVirtualRows`).
+ */
+export declare function bodySegments(items: readonly VirtualItem[], total: number, margin: number): BodySegment[];
+/** What the table needs to draw its rows virtually. */
+export interface VirtualRows {
+    /** The body as drawn; `null` when every row is drawn. */
+    segments: BodySegment[] | null;
+    /** Hands a drawn row to the virtualizer, which measures it. */
+    measure: (node: HTMLTableRowElement | null) => void;
+    /**
+     * Brings a row into view and focuses it, once it is drawn; only while the
+     * rows are drawn virtually. `then` is given the row, to take the group's
+     * stop before focus lands.
+     */
+    focusRow: (index: number, then: (row: HTMLTableRowElement) => void) => void;
+    /** Records which row holds the stop, so it stays drawn. */
+    holdStop: (index: number) => void;
+}
+/**
+ * Draws the rows of a long result virtually — only the rows in view and a
+ * few around them — through TanStack Virtual.
+ *
+ * The rows scroll in whatever scrolls them. In a workbench, an expanded
+ * view or a filled embed that is the table's own port, which the header and
+ * the totals stick to; on a board it is the panel's body, and in an embed
+ * laid out at its content's height, the page. The port is the scroller when
+ * it is shorter than what it holds, which the room the rows take makes it
+ * wherever its height is bounded; otherwise the nearest ancestor that
+ * scrolls, otherwise the window.
+ *
+ * The row holding the Tab stop is always drawn, wherever the view is, so a
+ * wheel that scrolls it away never takes focus with it to the page. Printing
+ * draws every row: a sheet of paper has no scroll position.
+ *
+ * `'use no memo'`: the virtualizer is one object that changes inside, which
+ * the React Compiler would take for unchanged.
+ */
+export declare function useVirtualRows(count: number, port: RefObject<HTMLElement | null>, body: RefObject<HTMLTableSectionElement | null>): VirtualRows;
+//# sourceMappingURL=virtualRows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"virtualRows.d.ts","sourceRoot":"","sources":["../../../src/ui/analysis/virtualRows.ts"],"names":[],"mappings":"AAaA,OAAO,EAKL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAEf,OAAO,EAUL,KAAK,WAAW,EACjB,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,OAAQ,CAAC;AAcxC,8EAA8E;AAC9E,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,WAAW,CAAC,KAAK,CAAC,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,WAAW,EAAE,CAiBf;AAED,uDAAuD;AACvD,MAAM,WAAW,WAAW;IAC1B,yDAAyD;IACzD,QAAQ,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IAC/B,+DAA+D;IAC/D,OAAO,EAAE,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,KAAK,IAAI,CAAC;IACpD;;;;OAIG;IACH,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,IAAI,KAAK,IAAI,CAAC;IAC5E,2DAA2D;IAC3D,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EACnC,IAAI,EAAE,SAAS,CAAC,uBAAuB,GAAG,IAAI,CAAC,GAC9C,WAAW,CA4Hb"}

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

@@ -0,0 +1,10 @@
+import { BoxplotData } from '../../analysis/index.js';
+import { FamilyProps } from './family.js';
+/**
+ * A boxplot, drawn by ECharts from `boxplotOption`: a box per group. A
+ * pressed box is its group. Over it, that the quartiles and the median are
+ * approximate — Wow's percentiles are — and how many groups lack one of
+ * the five numbers and are not drawn.
+ */
+export declare function Boxplot({ data, spec, className, label, column, name, onPick, highlight, }: FamilyProps<BoxplotData>): import('react').JSX.Element;
+//# sourceMappingURL=Boxplot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Boxplot.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/Boxplot.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAM3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/C;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,EACtB,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,KAAK,EACL,MAAM,EACN,IAAI,EACJ,MAAM,EACN,SAAS,GACV,EAAE,WAAW,CAAC,WAAW,CAAC,+BAqD1B"}

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

@@ -0,0 +1,9 @@
+import { CandlestickData } from '../../analysis/index.js';
+import { FamilyProps } from './family.js';
+/**
+ * A candlestick (K 线), drawn by ECharts from `candlestickOption`: a candle
+ * per period. A pressed candle is its period. Over it, how many periods lack
+ * one of the four numbers and are not drawn.
+ */
+export declare function Candlestick({ data, spec, className, label, column, name, onPick, highlight, }: FamilyProps<CandlestickData>): import('react').JSX.Element;
+//# sourceMappingURL=Candlestick.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Candlestick.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/Candlestick.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAM/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/C;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAC1B,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,KAAK,EACL,MAAM,EACN,IAAI,EACJ,MAAM,EACN,SAAS,GACV,EAAE,WAAW,CAAC,eAAe,CAAC,+BAyD9B"}

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

@@ -0,0 +1,9 @@
+import { CartesianData } from '../../analysis/index.js';
+import { FamilyProps } from './family.js';
+/**
+ * Bar, line, area and combo, drawn by ECharts from `cartesianOption`
+ * (docs/design/decisions.md D21): the legend beside the plot, the category
+ * names fitted to the width, and a press on a mark handed back as its group.
+ */
+export declare function Cartesian({ data, spec, className, label, column, seriesName, toneOf, dateTicks, name, onPick, highlight, filled, hidden, onToggleSeries, zoomGestures, }: FamilyProps<CartesianData>): import('react').JSX.Element;
+//# sourceMappingURL=Cartesian.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Cartesian.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/Cartesian.tsx"],"names":[],"mappings":"AAcA,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAc5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAQ/C;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EACxB,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,KAAK,EACL,MAAM,EACN,UAAU,EACV,MAAM,EACN,SAAS,EACT,IAAI,EACJ,MAAM,EACN,SAAS,EACT,MAAM,EACN,MAAM,EACN,cAAc,EACd,YAAY,GACb,EAAE,WAAW,CAAC,aAAa,CAAC,+BA6P5B"}

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

@@ -0,0 +1,47 @@
+import { ReactNode } from 'react';
+export interface LegendEntry {
+    key: string;
+    label: string;
+    /** A CSS colour: a theme slot or the one the spec pinned. */
+    color: string;
+    /** A number beside the name — a slice's share — in figures that align. */
+    value?: string;
+    /** Switched off in the legend: not drawn, still listed (`onToggle`). */
+    hidden?: boolean;
+    /**
+     * A computed line rather than a series: a dash in the text's own ink
+     * stands for it where a series has its dot (D33 batch B).
+     */
+    dashed?: 'dashed' | 'dotted';
+}
+/**
+ * The legend, as text beside the drawing rather than inside it.
+ *
+ * It is the page's own type — it can be selected and read, and it never
+ * overlaps the plot, which a legend the library draws into its canvas does
+ * once the names run long. A dot per series, as Metabase draws its legend;
+ * top and left-aligned by default, so it reads before the marks do.
+ *
+ * Above or below the plot it keeps to one line: the entries that do not
+ * fit are counted at its end — 「还有 3 个」 — and a press opens the whole
+ * list, as Metabase folds its own. Twenty split values would otherwise push
+ * the plot down to a sliver in a dashboard panel. Beside the plot it is a
+ * column that scrolls.
+ *
+ * Given `onToggle`, each entry is a switch for its series (D33 batch A): a
+ * button whose `aria-pressed` says whether the series is drawn, reached by
+ * Tab and pressed by Enter or Space like any button — the library's own
+ * legend is drawn into the picture and no keyboard reaches it.
+ */
+export declare function ChartLegend({ entries, at, lead, onToggle, }: {
+    entries: readonly LegendEntry[];
+    at: 'top' | 'bottom' | 'right';
+    /** What comes before the entries, when the family has something to say. */
+    lead?: ReactNode;
+    /**
+     * Makes each entry a switch for its series: pressed, the series is drawn;
+     * pressed again, it is not. Left out, the entries are text.
+     */
+    onToggle?: (key: string) => void;
+}): import('react').JSX.Element;
+//# sourceMappingURL=ChartLegend.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ChartLegend.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/ChartLegend.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAqC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAM1E,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,EAAE,EACF,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IAChC,EAAE,EAAE,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IAC/B,2EAA2E;IAC3E,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,+BAiGA"}

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

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { LegendPlace } from './EChart.js';
+/**
+ * What a drawing says over itself about what it could not draw, or how to
+ * read what it did: groups left out, numbers that are approximate, a value
+ * off the scale. Quiet text above the plot, one sentence each, in the
+ * place a legend would stand — the families that have no legend of their
+ * own put it there (`EChart`'s `legend`).
+ */
+export declare function chartNotes(notes: readonly string[], slot: string, legend?: ReactNode | ((placed: LegendPlace) => ReactNode)): {
+    at: LegendPlace;
+    node: (placed: LegendPlace) => ReactNode;
+} | undefined;
+//# sourceMappingURL=ChartNotes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ChartNotes.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/ChartNotes.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,MAAM,EAAE,WAAW,KAAK,SAAS,CAAC,GACxD;IAAE,EAAE,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,SAAS,CAAA;CAAE,GAAG,SAAS,CAoB3E"}

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

@@ -0,0 +1,15 @@
+import { ChartReading } from './reading.js';
+/**
+ * The chart's numbers as a table, for whoever cannot see the marks.
+ *
+ * It is the same registry `Table` that `AnalysisTable` draws with, filled
+ * from the chart projection rather than the row projection, so it says what
+ * this layout actually put on screen. `sr-only` takes the whole thing out of
+ * flow, so it costs the drawing no space and changes nothing that is looked
+ * at — and it stays a real table, because a table is how a screen reader
+ * walks numbers by row and column.
+ */
+export declare function ChartReadingTable({ reading }: {
+    reading: ChartReading;
+}): import('react').JSX.Element | null;
+//# sourceMappingURL=ChartReading.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ChartReading.d.ts","sourceRoot":"","sources":["../../../src/ui/charts/ChartReading.tsx"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,YAAY,CAAA;CAAE,sCA8CvE"}