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

package/dist/analysis/boxplot.d.ts

@@ -0,0 +1,80 @@
+import { AnalysisMetric, AnalysisViewConfig, BoxplotSpec, RecordData } from '../model/index.js';
+/** The five numbers of a box, by the slot each fills. */
+export type FiveNumbers = Omit<BoxplotSpec, 'category'>;
+/** The slots of a box, from its lowest to its highest. */
+export declare const FIVE_NUMBER_SLOTS: readonly ["low", "q1", "median", "q3", "high"];
+/**
+ * The percentiles a box's quartiles and median stand at, as the tray adds
+ * them (`fiveNumberMetrics`). A box drawn from other percentiles — a P10 to
+ * P90 box — is read by them: the tooltip and the reading table name every
+ * number by its column, never as 「四分位」.
+ */
+export declare const BOX_PERCENTILES: readonly [25, 50, 75];
+/**
+ * Every complete set of five numbers the metrics hold, one per field (and
+ * condition) that has them: its `MIN`, its `MAX` and three `PERCENTILE`s —
+ * the lowest the lower quartile, the highest the upper, and of the ones
+ * between, the one nearest 50 the median. Only `quantities` are read: the
+ * earliest and the latest of a date are moments, which no box measures.
+ *
+ * In the order the metrics name their fields, so the first set is the one
+ * the analyst added first.
+ */
+export declare function fiveNumberSets(metrics: readonly AnalysisMetric[], quantities?: ReadonlySet<string>): FiveNumbers[];
+/**
+ * Whether the five slots of a spec are a set as `fiveNumberSets` reads
+ * one: the `MIN`, three percentiles rising and the `MAX`, all of one field
+ * under one condition. A box drawn from anything else — two fields, an
+ * average for a median — would draw a shape that says nothing.
+ */
+export declare function isFiveNumberSet(spec: FiveNumbers, metricOf: (alias: string) => AnalysisMetric | undefined): boolean;
+/**
+ * The metrics a box of `metric`'s field still lacks (「补齐箱线图的五个数」):
+ * of its `MIN`, its 25th, 50th and 75th percentiles and its `MAX`, the ones
+ * it is not itself — each under the metric's own condition, named by a free
+ * alias beside `taken`. `undefined` for a metric that measures no field's
+ * values: a count, a distinct count, any one value, a formula.
+ */
+export declare function fiveNumberMetrics(metric: AnalysisMetric, taken: readonly string[]): AnalysisMetric[] | undefined;
+/**
+ * The five numbers a boxplot draws (`fitChartSlots`): the set the spec
+ * names while every alias of it is still one of the sets the metrics hold,
+ * the first set otherwise — a box is five numbers of one field, so a set
+ * is kept or replaced whole, never patched. Empty slots, which validation
+ * names, when there is none.
+ */
+export declare function boxSet(spec: FiveNumbers | undefined, sets: readonly FiveNumbers[]): FiveNumbers;
+/** One box: a group and its five numbers, lowest first. */
+export interface BoxplotBox {
+    /** The group value the box stands for. */
+    group: unknown;
+    low: number;
+    q1: number;
+    median: number;
+    q3: number;
+    high: number;
+}
+export interface BoxplotData {
+    type: 'boxplot';
+    boxes: BoxplotBox[];
+    /**
+     * How many groups have no box: a row missing one of the five — a group
+     * with no value of the field has no lowest, no median, nothing. They stay
+     * in the table; the drawing says how many it left out.
+     */
+    omitted: number;
+    /**
+     * Whether the quartiles and the median are approximate: the source
+     * estimates percentiles (`AnalysisCapability.approximate`, which the
+     * analysis table's 「≈」 reads too).
+     */
+    approximate: boolean;
+}
+/**
+ * A boxplot's boxes, one per row: the five numbers its row measured. A box
+ * over time runs earliest first, as every time axis does; any other
+ * dimension keeps the rows' order, which is the view's sort. A row that
+ * lacks one of the five is no box and is counted instead.
+ */
+export declare function shapeBoxplot(spec: BoxplotSpec, config: AnalysisViewConfig, rows: readonly RecordData[], approximate?: boolean): BoxplotData;
+//# sourceMappingURL=boxplot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boxplot.d.ts","sourceRoot":"","sources":["../../src/analysis/boxplot.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAK3B,yDAAyD;AACzD,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;AAExD,0DAA0D;AAC1D,eAAO,MAAM,iBAAiB,gDAMqB,CAAC;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,uBAAwB,CAAC;AA+BrD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,UAAU,GAAE,WAAW,CAAC,MAAM,CAE7B,GACA,WAAW,EAAE,CAsCf;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,cAAc,GAAG,SAAS,GACtD,OAAO,CAiBT;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,cAAc,EAAE,GAAG,SAAS,CAkD9B;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,IAAI,EAAE,SAAS,WAAW,EAAE,GAC3B,WAAW,CAKb;AAED,2DAA2D;AAC3D,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,WAAW,UAAO,GACjB,WAAW,CAgBb"}

package/dist/analysis/bucketChange.d.ts

@@ -0,0 +1,25 @@
+import { CartesianData } from './chart.js';
+/**
+ * How one bucket's number moved from the bucket right before it: the
+ * difference, and that difference as a share of the earlier number — `null`
+ * where the earlier number is 0, which no share can be taken of.
+ */
+export interface BucketChange {
+    delta: number;
+    ratio: number | null;
+}
+/**
+ * The change of series `key` at point `index` from the point before it, on
+ * a time axis whose points are consecutive buckets (`CartesianData.timeline`)
+ * — the tooltip's 「较上一期」 (docs/design/decisions.md D33, Q59).
+ *
+ * It asks for nothing the rows do not hold: both numbers are the chart's own,
+ * so there is no second query. And it says nothing it cannot know: not on a
+ * category axis, where the point before is no earlier period; not on a time
+ * axis with a bucket skipped; not for the first bucket, nor for the missing
+ * value's bucket or the one after it; and not where either number is missing
+ * — a hole the kernel could not tell was empty, or `missing: 'gap'`. A 0 the
+ * kernel filled in is a known 0 (`absenceReader`), and is compared like any.
+ */
+export declare function bucketChange(data: CartesianData, key: string, index: number): BucketChange | undefined;
+//# sourceMappingURL=bucketChange.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bucketChange.d.ts","sourceRoot":"","sources":["../../src/analysis/bucketChange.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACZ,YAAY,GAAG,SAAS,CAW1B"}

package/dist/analysis/budget.d.ts

@@ -0,0 +1,37 @@
+import { Issue, IssuePath, RuntimeLimits } from '../model/index.js';
+/**
+ * The budget of an expression, derived or having tree, checked iteratively
+ * before anything recurses into it.
+ *
+ * These trees arrive from a store like a filter does, and the walks below are
+ * plain recursion, so without this a nested `BINARY` chain would exhaust the
+ * stack before any rule ran. The filter budget is reused as the ceiling: Wow
+ * caps an expression at the same depth 8 and 256 nodes it uses for nothing
+ * else, and one pair of limits keeps the caller's override in one place.
+ * Like Wow, depth is per tree and the node count is one budget over every
+ * tree of one kind, so a config cannot slip past by spreading a large tree
+ * across many metrics.
+ */
+export type BudgetOverrun = 'too-deep' | 'too-many-nodes';
+declare const BUDGET_ISSUE_CODES: {
+    readonly expression: {
+        readonly 'too-deep': "analysis.expression.too-deep";
+        readonly 'too-many-nodes': "analysis.expression.too-many-nodes";
+    };
+    readonly having: {
+        readonly 'too-deep': "analysis.having.too-deep";
+        readonly 'too-many-nodes': "analysis.having.too-many-nodes";
+    };
+};
+/** One node counter per tree kind, shared across the metrics of a config. */
+export interface BudgetCounter {
+    nodes: number;
+}
+export declare function checkTreeBudget(root: unknown, children: (node: unknown) => readonly unknown[], limits: RuntimeLimits, counted: BudgetCounter): BudgetOverrun | undefined;
+export declare function budgetIssues(kind: keyof typeof BUDGET_ISSUE_CODES, overrun: BudgetOverrun | undefined, path: IssuePath, limits: RuntimeLimits): Issue[];
+/** The two operands of a BINARY node; anything else is a leaf, sound or not. */
+export declare function binaryChildren(node: unknown): readonly unknown[];
+/** The operands of a having group; a non-array is the walk's to report. */
+export declare function havingChildren(node: unknown): readonly unknown[];
+export {};
+//# sourceMappingURL=budget.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"budget.d.ts","sourceRoot":"","sources":["../../src/analysis/budget.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGzE;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAE1D,QAAA,MAAM,kBAAkB;;;;;;;;;CASd,CAAC;AAEX,6EAA6E;AAC7E,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,SAAS,OAAO,EAAE,EAC/C,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,aAAa,GACrB,aAAa,GAAG,SAAS,CAa3B;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,OAAO,kBAAkB,EACrC,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,aAAa,GACpB,KAAK,EAAE,CAKT;AAED,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,OAAO,EAAE,CAIhE;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,OAAO,EAAE,CAIhE"}

package/dist/analysis/candidates.d.ts

@@ -0,0 +1,96 @@
+import { AnalysisViewConfig, DataViewDefinition, FieldDefinition, FilterOperatorName, RecordData, RuntimeLimits } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+/**
+ * How many of a field's values a condition is offered, most frequent first:
+ * enough that a field with a few dozen values (a processor, an error code)
+ * lists every one, few enough that the list is read rather than scrolled.
+ * The definition's own `maxLimit` still caps it.
+ */
+export declare const VALUE_CANDIDATE_LIMIT = 50;
+/**
+ * The operators whose value is one of the field's own values: equal to it,
+ * not equal to it, among them, not among them. A substring or a prefix is a
+ * piece of text the user writes — offering whole values there would pick a
+ * value where a fragment was meant — so those stay typed.
+ */
+export declare const VALUE_CANDIDATE_OPERATORS: readonly FilterOperatorName[];
+/** One value the data holds, and how many records hold it. */
+export interface ValueCandidate {
+    value: string;
+    count: number;
+}
+/** What one candidate query answered. */
+export interface ValueCandidates {
+    /** Most frequent first; ties by value, so the order is stable. */
+    values: ValueCandidate[];
+    /**
+     * Whether these are every value the question matches. False when the
+     * source had more than the limit, so a value that is not listed may still
+     * exist — the list is the most frequent, and typing narrows it.
+     */
+    complete: boolean;
+}
+/**
+ * The field a condition's values can be offered for from the data, or
+ * `null` when they cannot.
+ *
+ * Offered when the data can be asked for them and nothing better answers:
+ * the definition lets the field be grouped by value (`TERMS`) and records be
+ * counted, so the question is one Wow already takes; a record holds one
+ * string there, so a group's key is a value an equality can compare against;
+ * and the field declares neither `options` (a closed set lists itself, with
+ * its labels) nor `remote` (the host searches it). A field inside an array's
+ * elements is not a root field and is never offered: its values would be
+ * counted over records, not over the elements a predicate tests.
+ */
+export declare function valueCandidateField(definition: DataViewDefinition, name: string, kinds: FieldKindRegistry): FieldDefinition | null;
+/**
+ * How a typed fragment narrows the candidates at the source, or `null` when
+ * the field lets no condition do it and the list is narrowed where it is.
+ *
+ * A substring is what a user typing into a list means — 「saga」 should find
+ * 「QuotationSaga」 — so `CONTAINS` wins where the field offers it; a prefix
+ * is the next best. Either compiles as the field's own conditions do,
+ * case and all (`stringComparison`), so the source answers what the list
+ * would have shown had it held every value.
+ */
+export declare function valueCandidateNarrowing(field: FieldDefinition, kinds: FieldKindRegistry): 'CONTAINS' | 'STARTS_WITH' | null;
+/** The number of values one candidate query asks for, under every ceiling. */
+export declare function valueCandidateLimit(definition: DataViewDefinition, limits?: RuntimeLimits): number;
+/**
+ * The candidates of `field` as an analysis: records counted by the field's
+ * value, the most frequent first, the first `valueCandidateLimit` of them —
+ * narrowed to the values holding `query` where the field allows it.
+ *
+ * It is an ordinary analysis config on purpose, so it is admitted by
+ * `validateAnalysis` and compiled by `compileAnalysis` like any other, and a
+ * host scope is merged into it by the same `withScopeFilter` — there is no
+ * second spelling of a Wow aggregation to keep in step with the first.
+ *
+ * Its dimension carries no sentinel bucket, unlike the one `groupOfType`
+ * builds: a view that counts by value must not drop the records missing it,
+ * but a list of values to compare against has no use for them — 「has no
+ * value」 is `IS_NULL`, a condition of its own, not a value to pick.
+ */
+export declare function valueCandidatesConfig(definition: DataViewDefinition, field: FieldDefinition, kinds: FieldKindRegistry, query?: string, limits?: RuntimeLimits): AnalysisViewConfig;
+/**
+ * The rows a candidate query answered, as candidates.
+ *
+ * A key that is not a non-empty string is left out: an empty string is not a
+ * value an equality condition takes (`IS_EMPTY_STRING` asks for it), and a
+ * key of any other type cannot be what a text condition compares with.
+ *
+ * Whether the list is whole is read off the probe row `compileAnalysis` asks
+ * for (`analysisProbeLimit`): it came back, so there are more values than the
+ * limit. With no probe — the limit already on a ceiling — a full list is
+ * called incomplete, since it may be.
+ */
+export declare function readValueCandidates(definition: DataViewDefinition, config: AnalysisViewConfig, rows: readonly RecordData[], limits?: Pick<RuntimeLimits, 'maxAnalysisRows'>): ValueCandidates;
+/**
+ * The candidates in hand narrowed to those holding `query`, the way the
+ * source would narrow them: ignoring case unless the field says its case
+ * carries meaning, by substring or by prefix as `valueCandidateNarrowing`
+ * picks — by substring where the source cannot narrow at all.
+ */
+export declare function narrowValueCandidates(values: readonly ValueCandidate[], field: FieldDefinition, kinds: FieldKindRegistry, query: string): ValueCandidate[];
+//# sourceMappingURL=candidates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"candidates.d.ts","sourceRoot":"","sources":["../../src/analysis/candidates.ts"],"names":[],"mappings":"AAcA,OAAO,EAKL,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,UAAU,EACf,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAKzE;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,EAAE,SAAS,kBAAkB,EAKlE,CAAC;AAEF,8DAA8D;AAC9D,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,yCAAyC;AACzC,MAAM,WAAW,eAAe;IAC9B,kEAAkE;IAClE,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,kBAAkB,EAC9B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,iBAAiB,GACvB,eAAe,GAAG,IAAI,CAYxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,iBAAiB,GACvB,UAAU,GAAG,aAAa,GAAG,IAAI,CAMnC;AAED,8EAA8E;AAC9E,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,kBAAkB,EAC9B,MAAM,GAAE,aAAsC,GAC7C,MAAM,CAKR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,kBAAkB,EAC9B,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,iBAAiB,EACxB,KAAK,SAAK,EACV,MAAM,GAAE,aAAsC,GAC7C,kBAAkB,CAmCpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,MAAM,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,iBAAiB,CAAC,GAC9C,eAAe,CAcjB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,SAAS,cAAc,EAAE,EACjC,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,MAAM,GACZ,cAAc,EAAE,CAUlB"}

package/dist/analysis/candlestick.d.ts

@@ -0,0 +1,73 @@
+import { AnalysisMetric, CandlestickSpec, RecordData } from '../model/index.js';
+/** The four numbers of a candle, by the slot each fills. */
+export type Ohlc = Omit<CandlestickSpec, 'x'>;
+/** The slots of a candle, as a K line reads them: open, high, low, close. */
+export declare const OHLC_SLOTS: readonly ["open", "high", "low", "close"];
+/**
+ * Every complete set of four numbers the metrics hold, one per field (and
+ * condition) that has them: its opening value (`FIRST`), its highest
+ * (`MAX`), its lowest (`MIN`) and its closing value (`LAST`) ordered by
+ * the same time as the open. Only `quantities` are read: the earliest of a
+ * date is a moment, which no candle measures.
+ *
+ * In the order the metrics name their fields, so the first set is the one
+ * the analyst added first.
+ */
+export declare function ohlcSets(metrics: readonly AnalysisMetric[], quantities?: ReadonlySet<string>): Ohlc[];
+/**
+ * Whether the four slots of a spec are a set as `ohlcSets` reads one: the
+ * `FIRST`, `MAX`, `MIN` and `LAST` of one field under one condition, the
+ * two ends ordered by one time. A candle drawn from anything else — two
+ * fields, an average for a close — would draw a shape that says nothing.
+ */
+export declare function isOhlcSet(spec: Ohlc, metricOf: (alias: string) => AnalysisMetric | undefined): boolean;
+/**
+ * The metrics a candle of `metric`'s field still lacks (「补齐 K 线的四个
+ * 数」): of its opening value, its highest, its lowest and its closing
+ * value, the ones it is not itself — each under the metric's own condition,
+ * the two ends ordered by the metric's own time where it names one, named
+ * by a free alias beside `taken`. `undefined` for a metric that is none of
+ * the four of a field.
+ */
+export declare function ohlcMetrics(metric: AnalysisMetric, taken: readonly string[]): AnalysisMetric[] | undefined;
+/**
+ * The four numbers a candlestick draws (`fitChartSlots`): the set the spec
+ * names while every alias of it is still one of the sets the metrics hold,
+ * the first set otherwise — a candle is four numbers of one field, so a set
+ * is kept or replaced whole, never patched. Empty slots, which validation
+ * names, when there is none.
+ */
+export declare function ohlcSet(spec: Ohlc | undefined, sets: readonly Ohlc[]): Ohlc;
+/** One candle: a period and its four numbers. */
+export interface Candle {
+    /** The bucket the candle stands for. */
+    x: unknown;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    /**
+     * Which way the period went, close against open: a candle is coloured by
+     * it in the host's rise/fall convention, and read out by it.
+     */
+    direction: 'rise' | 'fall' | 'flat';
+}
+export interface CandlestickData {
+    type: 'candlestick';
+    candles: Candle[];
+    /**
+     * How many periods have no candle: a row missing one of the four — a
+     * period with no value of the field has no open, no close, nothing. They
+     * stay in the table; the drawing says how many it left out.
+     */
+    omitted: number;
+}
+/**
+ * A candlestick's candles, one per row, earliest first as every time axis
+ * runs. A row that lacks one of the four is no candle and is counted
+ * instead; a period nobody traded is no candle either, so no hole is
+ * filled — a candle is a measurement, and a flat one would say the price
+ * stood still.
+ */
+export declare function shapeCandlestick(spec: CandlestickSpec, rows: readonly RecordData[]): CandlestickData;
+//# sourceMappingURL=candlestick.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"candlestick.d.ts","sourceRoot":"","sources":["../../src/analysis/candlestick.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAK3B,4DAA4D;AAC5D,MAAM,MAAM,IAAI,GAAG,IAAI,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;AAE9C,6EAA6E;AAC7E,eAAO,MAAM,UAAU,2CAKqB,CAAC;AAkC7C;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,UAAU,GAAE,WAAW,CAAC,MAAM,CAE7B,GACA,IAAI,EAAE,CAmCR;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,cAAc,GAAG,SAAS,GACtD,OAAO,CAiBT;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,cAAc,EAAE,GAAG,SAAS,CA8D9B;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,CAK3E;AAED,iDAAiD;AACjD,MAAM,WAAW,MAAM;IACrB,wCAAwC;IACxC,CAAC,EAAE,OAAO,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;CACrC;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,eAAe,CAoBjB"}

package/dist/analysis/capability.d.ts

@@ -0,0 +1,129 @@
+import { AggregationFieldCapability, AnalysisCapability, AnalysisViewConfig, DataViewDefinition, FieldDefinition, FilterTree } from '../model/index.js';
+/**
+ * What an analysis may name, and where.
+ *
+ * Wow's `elements` is one ordered parent-to-child chain, not a list of
+ * sibling arrays, and the chain decides the counting unit: without it a
+ * record is a root document, with it a record is one entry of the innermost
+ * expanded element. Three different domains follow from that, and a merged
+ * map of "everything reachable" could answer none of them:
+ *
+ * - the **root filter** names the definition's own fields, absolutely;
+ * - **element `i`'s filter** names the fields that element holds;
+ * - a **dimension, a metric, a numeric expression or a metric filter** names
+ *   the fields of the innermost expanded element — or the root's, when the
+ *   config expands nothing. A root field there is refused by Wow ("requires
+ *   its declared element scope"), so it is refused here.
+ *
+ * Names are the config's spelling throughout: fully qualified from the
+ * query-model root (`state.orders.lines.sku`), which is unambiguous to
+ * validate and to show. Compilation strips the prefix of the scope a name is
+ * sent in, because that is the spelling Wow reads (`relativeFields` and
+ * `relativeTree` below).
+ */
+export interface AnalysisScope {
+    /**
+     * Fields a dimension, a metric, an expression or a metric filter may name:
+     * the innermost expanded element's, or the definition's when the config
+     * expands nothing.
+     */
+    fields: Map<string, FieldDefinition>;
+    /** How those same fields may be aggregated. */
+    aggregations: Map<string, AggregationFieldCapability>;
+    /** Fields the root filter may name — always the definition's own. */
+    rootFields: FieldDefinition[];
+    /** The expanded chain, outermost first; empty when nothing is expanded. */
+    elements: AnalysisScopeElement[];
+    /** The chain the capability declares, outermost first, as it writes it. */
+    declaredChain: string[];
+    /**
+     * Every field the view can name somewhere, by its config spelling.
+     *
+     * Not a domain of its own: it is how a field that exists but sits in the
+     * wrong one is told apart from a field that does not exist at all, which
+     * are two different findings for the reader.
+     */
+    reachable: Map<string, FieldDefinition>;
+}
+/** One expanded level of the chain. */
+export interface AnalysisScopeElement {
+    /** As the config and Wow write it: relative to the previous element. */
+    path: string;
+    /** The absolute logical path from the query-model root. */
+    absolute: string;
+    /** The fields this element holds, under their config spelling. */
+    fields: Map<string, FieldDefinition>;
+    aggregations: Map<string, AggregationFieldCapability>;
+}
+export declare function analysisScope(definition: DataViewDefinition, capability: AnalysisCapability, config?: Pick<AnalysisViewConfig, 'elements'>): AnalysisScope;
+/**
+ * The level the counting unit is: the last one expanded, or none at all.
+ *
+ * `undefined` is the root, and it is the ordinary case — an analysis that
+ * expands nothing counts root documents.
+ */
+export declare function innermostElement(elements: readonly AnalysisScopeElement[]): AnalysisScopeElement | undefined;
+/**
+ * An element field's full path, from the scope it sits in and its own name.
+ *
+ * It always prefixes. It used to leave a name alone when that name already
+ * began with the path, which accepted both spellings of the same reference
+ * and so papered over a convention that had never been decided — and made
+ * `items.sku` mean one thing at the root of an element and another inside a
+ * nested object that happened to share the array's name. A declaration names
+ * what it holds relative to itself; composing the path is this function's
+ * job alone.
+ */
+export declare function qualify(path: string, field: string): string;
+/**
+ * The fields element `i`'s own gate filter may name: the ones that element
+ * holds, under the config's spelling.
+ *
+ * Admission and compilation both need this list and must agree on it — a
+ * filter admitted against one set of fields and compiled against another is
+ * how a `compileFilter` throw gets past a validator — so the rule is written
+ * once, here, rather than spelled out at each end. Compilation then renames
+ * them relative to that element, which is how Wow reads them.
+ */
+export declare function elementFilterFields(scope: AnalysisScope, index: number): FieldDefinition[];
+/**
+ * Names that exist somewhere in this view but not in the domain given.
+ *
+ * A dimension over a root field while the config expands `state.orders` is
+ * not a typo — the field is right there in the range panel — so it is
+ * reported as standing outside the counting unit rather than as unknown.
+ */
+export declare function outOfScopeNames(scope: AnalysisScope, domain: ReadonlyMap<string, FieldDefinition>): Set<string>;
+/**
+ * Which finding a name no aggregation capability covers deserves.
+ *
+ * A name the view can reach somewhere exists — it is in the range panel, or
+ * in an outer level of the expansion — and naming it as a dimension or a
+ * metric means reaching outside the counting unit, which Wow refuses. A name
+ * nothing declares is simply unknown, and the two send a reader to different
+ * places.
+ */
+export declare function unknownOrOutside(scope: AnalysisScope, field: string): string;
+/** The fields of `domain`, plus the ones outside it, for a filter's admission. */
+export declare function withOutOfScope(scope: AnalysisScope, domain: ReadonlyMap<string, FieldDefinition>): FieldDefinition[];
+/**
+ * The prefix a name in `absolute` position loses on its way to Wow.
+ *
+ * Empty for the root, where the config's spelling is already Wow's.
+ */
+export declare function scopePrefix(absolute: string): string;
+/** One name, relative to the scope it is sent in. */
+export declare function relativeName(field: string, prefix: string): string;
+/** The same fields, named as the scope they are compiled in names them. */
+export declare function relativeFields(fields: readonly FieldDefinition[], prefix: string): FieldDefinition[];
+/**
+ * The same tree, with every field name relative to the scope it is compiled
+ * in — the leaves' own, and the ones inside a predicate a leaf holds.
+ *
+ * A predicate's fields are written with the same absolute spelling as the
+ * leaf that holds it (`elementFields` composes them from the leaf's field
+ * name), so the same prefix comes off both. Nothing else about the tree
+ * changes, and a tree at the root passes through untouched.
+ */
+export declare function relativeTree(tree: FilterTree, prefix: string): FilterTree;
+//# sourceMappingURL=capability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capability.d.ts","sourceRoot":"","sources":["../../src/analysis/capability.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EAEpB,KAAK,UAAU,EAEhB,MAAM,mBAAmB,CAAC;AAG3B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACrC,+CAA+C;IAC/C,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;IACtD,qEAAqE;IACrE,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,2EAA2E;IAC3E,QAAQ,EAAE,oBAAoB,EAAE,CAAC;IACjC,2EAA2E;IAC3E,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CACzC;AAED,uCAAuC;AACvC,MAAM,WAAW,oBAAoB;IACnC,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACrC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;CACvD;AAED,wBAAgB,aAAa,CAC3B,UAAU,EAAE,kBAAkB,EAC9B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,CAAC,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,GAC5C,aAAa,CAuDf;AAiBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,SAAS,oBAAoB,EAAE,GACxC,oBAAoB,GAAG,SAAS,CAElC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,MAAM,GACZ,eAAe,EAAE,CAEnB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,GAC3C,GAAG,CAAC,MAAM,CAAC,CAKb;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAI5E;AAED,kFAAkF;AAClF,wBAAgB,cAAc,CAC5B,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,GAC3C,eAAe,EAAE,CAKnB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,qDAAqD;AACrD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAIlE;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAC5B,MAAM,EAAE,SAAS,eAAe,EAAE,EAClC,MAAM,EAAE,MAAM,GACb,eAAe,EAAE,CAMnB;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAMzE"}

package/dist/analysis/cartesian.d.ts

@@ -0,0 +1,102 @@
+import { AnalysisViewConfig, ChartType, RecordData } from '../model/index.js';
+import { CartesianGap, DerivedLine } from './derived.js';
+import { PlacedLine, SeriesExtremes } from './references.js';
+export interface CartesianData {
+    type: 'cartesian';
+    chart: ChartType;
+    /**
+     * One entry per x value, already pivoted when `splitBy` is configured.
+     * `filled` names the series whose value here the kernel filled in rather
+     * than measured — a day the rows lack, a split combination they lack —
+     * so a drawing can tell a known 0 from a counted one (decisions.md D21,
+     * Q14): it writes no label on it, and says why in the tooltip.
+     */
+    points: {
+        x: unknown;
+        values: Record<string, number | null>;
+        filled?: string[];
+    }[];
+    /**
+     * One entry per drawn line or bar. `key` is the record key of the points'
+     * values and is injective over group values, so it may carry a type tag;
+     * `label` is what a legend shows, the value as it prints. A pivoted series
+     * also keeps the raw split `value`, for a UI to show as its field does.
+     */
+    series: {
+        key: string;
+        label: string;
+        metric: string;
+        value?: unknown;
+        /**
+         * The split's folded rest (D33 Q56): every split value past the seven
+         * drawn, at each category the axis's whole less them (`foldOther`). No
+         * group of the rows, so it names no value and no press follows it up.
+         */
+        other?: true;
+    }[];
+    /**
+     * The x is a time axis whose points are its buckets one after another —
+     * earliest first, no bucket skipped (`consecutive`), the missing value's
+     * last — so two points side by side are a bucket and the one before it
+     * (`bucketChange`). Absent where the axis is not time, or where a hole
+     * could not be placed and the points may skip one.
+     */
+    timeline?: true;
+    /**
+     * The period still under way at the axis's end (`unfinishedBucket`): drawn
+     * and marked, and left out of what the chart is read to say. Absent when
+     * every period had ended, or when the question carries no `now`.
+     */
+    unfinished?: {
+        at: unknown;
+    };
+    /**
+     * The spec's reference lines where the kernel placed them — a statistic
+     * at the number it came to over the measured values (`placeLines`).
+     * Absent when the spec has none.
+     */
+    references?: PlacedLine[];
+    /**
+     * The lines computed from a drawn metric over the time axis (D33 batch B):
+     * a trend, a moving average, a running total. Absent when none is drawn.
+     */
+    derived?: DerivedLine[];
+    /**
+     * Each series' highest and lowest measured point, when the spec asks —
+     * or when its bars, left to their default, write only those two
+     * (`peaksOnlyLabels`).
+     */
+    extremes?: SeriesExtremes;
+    /**
+     * What the spec asked for that the kernel did not draw, each with why —
+     * a running total over rows cut short, an average over a split (Q53).
+     */
+    gaps?: CartesianGap[];
+    /**
+     * More series than the palette has colours, drawn all the same, so some
+     * wear one colour twice: a split whose metric does not add up has no rest
+     * to fold into 「其他」 (D33 Q56), and the display page suggests another
+     * reading. Absent where every series has a colour of its own.
+     */
+    crowded?: true;
+}
+/**
+ * A pivot fills every combination its rows lack: 0 for a metric that adds
+ * when the combination is known to have had no records (`absenceReader`) —
+ * 「华东 has no 已取消」 is a count of zero, and left out it drew as no data,
+ * a stacked area of lone dots floating at the stack's height — and nothing
+ * otherwise: an average of no records is no number, and a combination the
+ * limit or 「只保留」 cut is not known to be empty. A time x runs without
+ * holes (`withoutHoles`), each hole filled by the same rule — and out to
+ * the window its conditions pin on the axis's field, when the result is
+ * whole (`knownWindow`, the trend card's rule): 「近 30 天」 with no records
+ * on the first five is thirty days, the first five known zeros, not an axis
+ * that starts on the sixth. A split fills each of its series there, one
+ * combination at a time, as it does between the buckets. The spec's
+ * `missing: 'gap'` fills every one of them with nothing instead; the holes
+ * still stand on the axis, where their time is.
+ */
+export declare function shapeCartesian(type: ChartType, spec: NonNullable<AnalysisViewConfig['chart']['cartesian']>, config: AnalysisViewConfig, rows: readonly RecordData[], timeZone: string, cutShort?: boolean, splitWhole?: readonly RecordData[], 
+/** When the question was asked: the moment its conditions resolved at. */
+now?: Date): CartesianData;
+//# sourceMappingURL=cartesian.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cartesian.d.ts","sourceRoot":"","sources":["../../src/analysis/cartesian.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAkB3B,OAAO,EAAe,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,cAAc,EACpB,MAAM,iBAAiB,CAAC;AAKzB,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,SAAS,CAAC;IACjB;;;;;;OAMG;IACH,MAAM,EAAE;QACN,CAAC,EAAE,OAAO,CAAC;QACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;QACtC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;KACnB,EAAE,CAAC;IACJ;;;;;OAKG;IACH,MAAM,EAAE;QACN,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB;;;;WAIG;QACH,KAAK,CAAC,EAAE,IAAI,CAAC;KACd,EAAE,CAAC;IACJ;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB;;;;OAIG;IACH,UAAU,CAAC,EAAE;QAAE,EAAE,EAAE,OAAO,CAAA;KAAE,CAAC;IAC7B;;;;OAIG;IACH,UAAU,CAAC,EAAE,UAAU,EAAE,CAAC;IAC1B;;;OAGG;IACH,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,YAAY,EAAE,CAAC;IACtB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AASD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,WAAW,CAAC,CAAC,EAC3D,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,QAAQ,EAAE,MAAM,EAChB,QAAQ,UAAQ,EAChB,UAAU,CAAC,EAAE,SAAS,UAAU,EAAE;AAClC,0EAA0E;AAC1E,GAAG,CAAC,EAAE,IAAI,GACT,aAAa,CAwHf"}