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

package/dist/analysis/metricCard.d.ts

@@ -0,0 +1,155 @@
+import { AnalysisDateUnit, AnalysisViewConfig, RecordData } from '../model/index.js';
+export interface MetricCardData {
+    type: 'metric';
+    /**
+     * The headline. A number, except for a moment (`momentMetrics`) a source
+     * answered as text — the latest of a day kept as `2026-09-18` — which is
+     * written out as its column reads it rather than dropped for not being
+     * one; nothing is measured, compared or aimed at over a moment.
+     */
+    value: number | string | null;
+    /**
+     * The headline against another metric. `unmatched` where the question's
+     * dates cut either metric's own dates short, or miss one altogether
+     * (`metricReach`): 「本月至今」 against 「上月同期」 under a filter of one
+     * day is one day against nothing, and the delta is null rather than a
+     * change that never happened.
+     */
+    compare?: {
+        value: number | null;
+        delta: number | null;
+        unmatched?: true;
+    };
+    target?: number;
+    /**
+     * The sparkline's points; `filled` where the kernel filled a bucket the
+     * rows lack with 0 rather than measured it (decisions.md D21, Q14).
+     */
+    trend?: {
+        x: unknown;
+        value: number | null;
+        filled?: true;
+    }[];
+    /**
+     * Over a trend read as its last period (`MetricTrend.headline` left out or
+     * `last`): which period the headline is, and how it moved from the one
+     * before. Absent in the `whole` reading and without a trend.
+     */
+    period?: MetricPeriod;
+    /** The headline is the whole range, over a trend read as `whole`. */
+    whole?: true;
+    /**
+     * Over a trend read as its last period: the rows stopped at the view's
+     * limit before the latest period, so which period is the latest — and
+     * its number — is not known. The headline is null and no period is said,
+     * rather than the last bucket that fitted read as the latest (2026-09-26
+     * review: 400 days from 2025-01-01 headlined 2026-02-04). The limit is
+     * the one the rows stopped at.
+     */
+    cut?: {
+        limit: number;
+    };
+}
+/**
+ * The period a trend card's headline is, as its bucket key — a key the
+ * card prints the way its column does.
+ */
+export interface MetricPeriod {
+    /** The bucket the headline is. */
+    at: unknown;
+    /**
+     * The part of `at` the headline covers, where the question's own dates
+     * cut the bucket short — a month under a filter of one day is that day,
+     * under 「过去 7 天」 those seven days — as instants `[from, to)` to be
+     * read in `zone`. Absent where the headline is the whole bucket, which
+     * its key names. The card names this span, never the bucket: a month
+     * label over one day's number is the wrong period (2026-09-26 review).
+     */
+    span?: {
+        from: number;
+        to: number;
+        zone: string;
+    };
+    /** The date unit the buckets are cut in, so the card can name one. */
+    unit: AnalysisDateUnit;
+    /**
+     * `at` had not ended when the question was asked either — it is the only
+     * bucket there was — so the headline is the period so far.
+     */
+    partial?: true;
+    /**
+     * The latest bucket, left out of the headline because it had not ended
+     * when the question was asked: a day half over compared with a whole one
+     * reads as a fall every morning.
+     */
+    skipped?: unknown;
+    /**
+     * The period right before `at` and its value; absent when the trend holds
+     * no bucket just before it (the range starts at `at`).
+     */
+    previous?: {
+        at: unknown;
+        value: number | null;
+    };
+    /**
+     * The headline against `previous`: the difference, and the difference as
+     * a share of the previous value — null when either number is missing, or
+     * the share when the previous value is 0.
+     */
+    change?: {
+        delta: number;
+        ratio: number | null;
+    } | null;
+    /**
+     * There is a period right before `at`, but the question's dates cut one
+     * of the two short and not the other the same way — nine days of this
+     * month against the whole of the last — so the two are not compared and
+     * `previous` and `change` are absent. A change across unequal spans reads
+     * as a fall, or a rise, that never happened.
+     */
+    unmatched?: true;
+}
+/**
+ * Without a trend the query is ungrouped, so its one row is the headline.
+ *
+ * With one, the rows are the buckets of the sparkline, and the headline is
+ * what `MetricTrend.headline` says it is. Read as its last period — the
+ * default — it is the last bucket that had ended when the question was
+ * asked, beside its change from the bucket before (`lastPeriod`). Read as
+ * the whole, it is the totals row when its query ran — the ungrouped
+ * aggregation, right for any metric — and otherwise the buckets added up,
+ * which validation admits only for a metric read off sums: one that adds,
+ * or a ratio of sums, divided from the summed operands (D38).
+ *
+ * Compare and target read the same span as the headline: the same period's
+ * row, or the whole. So a comparison with another metric is this period's
+ * against that metric's this period, and a target is a goal for one period.
+ */
+export declare function metricCard(spec: NonNullable<AnalysisViewConfig['chart']['metric']>, config: AnalysisViewConfig, rows: readonly RecordData[], totals: RecordData | undefined, context: MetricContext): MetricCardData;
+/** What a card is shaped against beside its rows. */
+interface MetricContext {
+    timeZone: string;
+    /** When the question was asked; every bucket has ended when left out. */
+    now: Date | undefined;
+    /** The rows are the first groups of more (`ShapeContext.cutShort`). */
+    cutShort?: boolean;
+}
+/**
+ * How long after the question was asked a trend card's headline stops
+ * being its last period, in milliseconds — or undefined when it never
+ * will: no trend, a card read as the whole, or no bucket under way.
+ *
+ * The card skips the period still under way when it is asked (`lastPeriod`),
+ * and that is a statement about a moment: at midnight today is over, the
+ * headline should be today and the day under way tomorrow. A page left open
+ * across it went on saying yesterday (2026-09-23 audit) — the rows are the
+ * ones asked for then, today's only partly counted, so the card cannot just
+ * move along them. The runtime asks again when this has run out
+ * (`RuntimeStoreHost.expiresAt`), and the answer is the card of the new day.
+ */
+export declare function periodRollover(config: AnalysisViewConfig, rows: readonly RecordData[], context: {
+    timeZone: string;
+    now: Date;
+}): number | undefined;
+export {};
+//# sourceMappingURL=metricCard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metricCard.d.ts","sourceRoot":"","sources":["../../src/analysis/metricCard.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,gBAAgB,EAEhB,kBAAkB,EAClB,UAAU,EACX,MAAM,mBAAmB,CAAC;AAc3B,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,CAAC;IACf;;;;;OAKG;IACH,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC9B;;;;;;OAMG;IACH,OAAO,CAAC,EAAE;QACR,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,SAAS,CAAC,EAAE,IAAI,CAAC;KAClB,CAAC;IACF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,KAAK,CAAC,EAAE;QAAE,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,CAAC,EAAE,IAAI,CAAA;KAAE,EAAE,CAAC;IAC9D;;;;OAIG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,qEAAqE;IACrE,KAAK,CAAC,EAAE,IAAI,CAAC;IACb;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,kCAAkC;IAClC,EAAE,EAAE,OAAO,CAAC;IACZ;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAClD,sEAAsE;IACtE,IAAI,EAAE,gBAAgB,CAAC;IACvB;;;OAGG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC;IACf;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACjD;;;;OAIG;IACH,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;IACxD;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,EACxD,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,OAAO,EAAE,aAAa,GACrB,cAAc,CAgEhB;AA2BD,qDAAqD;AACrD,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,GAAG,EAAE,IAAI,GAAG,SAAS,CAAC;IACtB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAqKD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,OAAO,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,GACvC,MAAM,GAAG,SAAS,CAmBpB"}

package/dist/analysis/metricCondition.d.ts

@@ -0,0 +1,41 @@
+import { AnalysisMetric, FieldDefinition } from '../model/index.js';
+import { FieldKindRegistry, FilterSummaryItem } from '../filter/index.js';
+/**
+ * What a metric's own condition (D20 屏 H, 「只算满足条件的记录」) does to
+ * the way the metric reads.
+ *
+ * A number counted over some of the records is a different number from the
+ * same summary over all of them, and a header that says 「金额的总和」 over
+ * both reads a region with no shipped orders as a region with no sales. So
+ * the condition travels with the metric's name (D20 显示名):
+ *
+ * - `value` — the condition keeps **one value of one field**, and that value
+ *   names itself: 「金额的总和 · 已发运」, as Metabase says "Sum of Total where
+ *   Status is Shipped". Only a value that reads on its own after a 「·」 —
+ *   the label the definition gave an option, or a piece of text — is one: a
+ *   bare 「· 100」 or 「· 是」 does not say what it is about;
+ * - otherwise the metric is **conditioned** without a word for it, and says
+ *   so — 「金额的总和 · 有条件」 — until the analyst names it.
+ *
+ * `items` is the whole condition as the applied bar reads one
+ * (`describeFilter`), for the places with room to say it: the header's
+ * description, the card's 「只算 …」 line.
+ */
+export interface MetricCondition {
+    /** The whole condition, one item per child of its root. */
+    items: FilterSummaryItem[];
+    /** The one value it keeps, as its field names it, when it is one. */
+    value?: string;
+}
+/**
+ * The condition a metric counts under, or `undefined` when it counts every
+ * record: no filter, a derived metric (which reads no records), or a filter
+ * that says nothing yet — every condition in it blank, which never reaches
+ * the query as a condition and is refused before it runs.
+ *
+ * `fields` are the ones the metric's filter may name — the analysis scope —
+ * and `kinds` read them; without kinds nothing can be read, and a condition
+ * nobody can read is left unsaid rather than guessed at.
+ */
+export declare function metricCondition(metric: AnalysisMetric, fields: readonly FieldDefinition[], kinds: FieldKindRegistry | undefined): MetricCondition | undefined;
+//# sourceMappingURL=metricCondition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metricCondition.d.ts","sourceRoot":"","sources":["../../src/analysis/metricCondition.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,SAAS,eAAe,EAAE,EAClC,KAAK,EAAE,iBAAiB,GAAG,SAAS,GACnC,eAAe,GAAG,SAAS,CAM7B"}

package/dist/analysis/metricFormat.d.ts

@@ -0,0 +1,136 @@
+import { AnalysisDerivedExpression, AnalysisExpression, AnalysisFunction, AnalysisMetric, FieldDefinition, NumberFormat } from '../model/index.js';
+/**
+ * Which summary a metric is, in one token.
+ *
+ * A `NUMERIC` metric names its function; every other metric type *is* its
+ * function, so the two vocabularies are folded into one here — that is what
+ * lets a column header, a format rule and a catalogue key all be chosen from
+ * the same word.
+ */
+export type MetricFunction = AnalysisFunction | 'COUNT' | 'DISTINCT_COUNT' | 'PERCENTILE' | 'FIRST' | 'LAST' | 'ANY' | 'DERIVED';
+export declare function metricFunctionOf(metric: AnalysisMetric): MetricFunction;
+/**
+ * How a metric's number prints, which is *not* how its field's own values
+ * print.
+ *
+ * A field's `numberFormat` describes one stored value — an integer count of
+ * items, an amount in yuan — and applying it to every aggregate of that field
+ * said things the query never computed: the average of an integer column came
+ * out as an integer, and a distinct count of amounts came out as money. What
+ * the aggregate is decides instead:
+ *
+ * - `COUNT` and `DISTINCT_COUNT` count records, so they are whole numbers in
+ *   nobody's currency;
+ * - `AVG`, `STDDEV` and `VARIANCE` are computed, so they keep the field's
+ *   format — an average of money is still money — and take two decimals from
+ *   it rather than the field's own precision;
+ * - `SUM`, `MIN`, `MAX` and `PERCENTILE` are values of the field, so they read
+ *   exactly as the field does, and so does `ANY`, which *is* one of its values
+ *   (of a date field they are no number at all — `readsAsItsField`);
+ * - `DERIVED` is arithmetic over other metrics and belongs to no field at all,
+ *   so it reads as its own `format` says (D38) — for which `field` stands
+ *   for what its operands share (`derivedOperandFormat`), the currency a
+ *   `currency` format left out — and without one, a plain number with two
+ *   decimals.
+ */
+export declare function metricFormat(metric: AnalysisMetric, field?: Pick<FieldDefinition, 'numberFormat' | 'numeric'>): NumberFormat | undefined;
+/**
+ * What a derived metric's operands share, as far as a format goes: the one
+ * currency every operand in a currency is in — GMV ÷ orders is in GMV's, a
+ * count being in none — or nothing, when none is or two differ. `formatOf`
+ * answers an operand metric's own format by alias.
+ */
+export declare function derivedOperandFormat(expression: AnalysisDerivedExpression, formatOf: (alias: string) => NumberFormat | undefined): NumberFormat | undefined;
+/**
+ * Every metric's number format, by alias, in the order the metrics are
+ * declared — so a derived metric reads its operands' formats, which come
+ * before it: a summary of a field in the field's format, a formula in the
+ * one its fields share (`formulaFormat`), a derived one as its own `format`
+ * says over what its operands share.
+ */
+export declare function metricFormats(metrics: readonly AnalysisMetric[], fieldOf: (name: string) => Pick<FieldDefinition, 'numberFormat' | 'numeric'> | undefined): Map<string, NumberFormat | undefined>;
+/**
+ * The format a formula's per-record number shares with the fields it is
+ * computed from, or none.
+ *
+ * A formula summarises no one field, so `metricFormat` had nothing to go on
+ * and 「金额 − 成本」 — money minus money — came out as a bare number beside
+ * the ¥ of every other amount on screen (2026-09-23 audit). The rule is the
+ * one a unit follows through arithmetic:
+ *
+ * - a sum or a difference of operands in **one** format is in that format —
+ *   ¥ − ¥ is ¥ — and of two formats is in neither;
+ * - a product or a quotient with a plain number (a `CONSTANT`) keeps the
+ *   other side's format — ¥ × 1.13 is ¥, ¥ ÷ 2 is ¥ — unless the plain
+ *   number is divided by it: 2 ÷ ¥ is no money;
+ * - a product or a quotient of two fields is a new quantity — ¥ × ¥ is no
+ *   money, ¥ ÷ ¥ is a ratio — and gets no format.
+ *
+ * `formatOf` answers a field's own format, `undefined` for a plain one.
+ */
+export declare function formulaFormat(expression: AnalysisExpression, formatOf: (field: string) => NumberFormat | undefined): NumberFormat | undefined;
+/**
+ * The one field a metric summarises, when it has one: a value metric
+ * (`ANY`, `FIRST`, `LAST`) names it, and the
+ * three expression-carrying kinds through a `FIELD` expression. A formula, a
+ * count and a derived metric summarise no single field.
+ */
+export declare function metricFieldOf(metric: AnalysisMetric): string | undefined;
+/**
+ * Whether a metric's value is one of its field's own values, on the field's
+ * own scale — its smallest, its largest, a percentile of it, any one of it —
+ * and so reads as the field reads a value: a date as a date, a code as the
+ * label the definition gave it. A sum, an average, a deviation and a count
+ * are new numbers the query computed, and read as numbers whatever they were
+ * computed from.
+ */
+export declare function readsAsItsField(metric: AnalysisMetric): boolean;
+/**
+ * The metrics whose value is a moment — the earliest, the latest, a
+ * percentile or any one of a date field — by alias.
+ *
+ * A moment is not a quantity. It has no zero a bar could grow from, no share
+ * of a whole a slice could take, nothing two of which add up to; so a chart
+ * measures quantities only, and a moment is read where a value is written out
+ * — the table, its totals row, a card's headline. `fields` is the analysis
+ * scope's (`analysisScope(...).fields`), which is how an element field is
+ * found under its path.
+ */
+export declare function momentMetrics(metrics: readonly AnalysisMetric[], fields: ReadonlyMap<string, Pick<FieldDefinition, 'kind' | 'cell'>>): Set<string>;
+/**
+ * What a metric's number is a quantity of, as one token: two metrics with
+ * the same token can share a scale, two with different ones cannot — a
+ * count of orders drawn on the scale of their amount lies flat along zero.
+ *
+ * Read off what the metric is, never off its values (the chart layer that
+ * uses it sees no rows): its function and the format its number prints in
+ * (`metricFormat`), which carries the field's declared unit.
+ *
+ * - `COUNT` and `DISTINCT_COUNT` count things: `count`;
+ * - `DERIVED` is arithmetic over other metrics — a ratio, a difference —
+ *   whose unit only its own `format` declares: a value in that unit, else
+ *   `derived`;
+ * - everything else is a function of a field, and the token is its scale
+ *   and its unit. A sum is a total (`total:`); an average, a bound, a
+ *   percentile, a deviation and any one value are on the scale of a single
+ *   value (`value:`) — a sum and an average of the same amount are both
+ *   money, a hundred times apart; a variance is in the square of the unit
+ *   (`square:`). The unit is the declared currency, percent or unit.
+ *
+ * A number with no declared unit is a quantity of its own: `own` — the
+ * field it measures, or a formula's alias — stands in for the unit. Two
+ * plain numbers were once one measure because nothing said they differed,
+ * and the weight in kilograms and the count of parcels shared a scale on
+ * which one of them lay flat along zero (2026-09-23 audit); nothing says
+ * they are alike either, and the one field is the only sameness known —
+ * its sum with and without a condition still share an axis. A derived
+ * metric is likewise its own.
+ */
+export declare function metricMeasure(fn: MetricFunction | undefined, format: NumberFormat | undefined, own: string): string;
+/**
+ * `metricMeasure` of every metric, by alias, from the definition: each
+ * metric's format as `metricFormat` reads it off its one field. `fields`
+ * is the analysis scope's, as `momentMetrics` takes it.
+ */
+export declare function metricMeasures(metrics: readonly AnalysisMetric[], fields: ReadonlyMap<string, Pick<FieldDefinition, 'numberFormat' | 'numeric'>>): Map<string, string>;
+//# sourceMappingURL=metricFormat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metricFormat.d.ts","sourceRoot":"","sources":["../../src/analysis/metricFormat.ts"],"names":[],"mappings":"AAaA,OAAO,EAKL,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EAEnB,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GACtB,gBAAgB,GAChB,OAAO,GACP,gBAAgB,GAChB,YAAY,GACZ,OAAO,GACP,MAAM,GACN,KAAK,GACL,SAAS,CAAC;AAEd,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAEvE;AAQD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,cAAc,EACtB,KAAK,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,SAAS,CAAC,GACxD,YAAY,GAAG,SAAS,CAiB1B;AA8BD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,yBAAyB,EACrC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,YAAY,GAAG,SAAS,GACpD,YAAY,GAAG,SAAS,CAgB1B;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,EAAE,CACP,IAAI,EAAE,MAAM,KACT,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,SAAS,CAAC,GAAG,SAAS,GACjE,GAAG,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAAC,CAuBvC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,kBAAkB,EAC9B,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,YAAY,GAAG,SAAS,GACpD,YAAY,GAAG,SAAS,CAG1B;AAiED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAWxE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAa/D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,GAClE,GAAG,CAAC,MAAM,CAAC,CAUb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,cAAc,GAAG,SAAS,EAC9B,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,GAAG,EAAE,MAAM,GACV,MAAM,CAiBR;AAgBD;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,MAAM,EAAE,WAAW,CACjB,MAAM,EACN,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,SAAS,CAAC,CAClD,GACA,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAiBrB"}

package/dist/analysis/metricOrder.d.ts

@@ -0,0 +1,47 @@
+import { AnalysisColumn, AnalysisMetric } from '../model/index.js';
+/**
+ * Why a metric could not go as far as it was asked: the metric it reads,
+ * which it must stay after (`after`), or the derived metric that reads it,
+ * which it must stay before (`before`).
+ */
+export interface MetricMoveStop {
+    side: 'after' | 'before';
+    /** The alias of the metric it stopped at. */
+    at: string;
+}
+/** A metric moved in the list, as far as the rule lets it go. */
+export interface MetricMove {
+    metrics: AnalysisMetric[];
+    /** Where it landed; its old index when it did not move at all. */
+    to: number;
+    /** Set when it landed short of where it was asked to go. */
+    stop?: MetricMoveStop;
+}
+/**
+ * The metric at `from` moved to `to`, where the order allows it (D71).
+ *
+ * A derived metric is read in list order — admission refuses one that reads
+ * a metric declared after it (`analysis.derived.unknown-metric`), and the
+ * editor's cascade takes it with that reading — so the order is part of the
+ * question, not only of the table. A move is therefore **clamped**: a
+ * derived metric goes no earlier than just after the last metric it reads,
+ * and a metric goes no later than just before the first derived metric that
+ * reads it. The move still happens as far as it can, and `stop` says which
+ * metric it stopped at, so the editor can say why.
+ *
+ * `to` is the index the metric ends at in the new list. A metric that
+ * would have to stand both after one and before another that come the
+ * other way round has no place at all, and does not move.
+ */
+export declare function moveMetric(metrics: readonly AnalysisMetric[], from: number, to: number): MetricMove;
+/**
+ * The table's declared columns after the metric `alias` moved to where it
+ * stands in `metrics`: its column goes just after the column of the
+ * nearest metric before it that has one, or else just before the column of
+ * the nearest after it — so a moved metric's column follows it (D71) and
+ * every other column keeps its place. A metric with no declared column, or
+ * none around it with one, leaves the columns as they are: undeclared
+ * columns already follow the config's order.
+ */
+export declare function columnsAfterMove(columns: readonly AnalysisColumn[], metrics: readonly AnalysisMetric[], alias: string): AnalysisColumn[];
+//# sourceMappingURL=metricOrder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metricOrder.d.ts","sourceRoot":"","sources":["../../src/analysis/metricOrder.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxE;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAC;IACzB,6CAA6C;IAC7C,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,iEAAiE;AACjE,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,kEAAkE;IAClE,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,UAAU,CAyCZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,KAAK,EAAE,MAAM,GACZ,cAAc,EAAE,CAqBlB"}

package/dist/analysis/metricWindow.d.ts

@@ -0,0 +1,28 @@
+import { AnalysisViewConfig, RecordData } from '../model/index.js';
+/**
+ * How a metric's own dates sit in the question's: `out` where the two do
+ * not meet at all — 「上月同期」 on a board narrowed to one day this month
+ * counts nothing, and a 0 there reads as a month with no sales — and
+ * `clipped` where the question's dates cut the metric's short, so it
+ * counts only part of the span its name says.
+ */
+export type MetricReach = 'out' | 'clipped';
+/**
+ * Each metric whose own conditions pin a date the question's conditions
+ * narrow (`appliedWindow` on both, at the moment the question was asked),
+ * by alias: `out` where the two windows do not meet, `clipped` where the
+ * question's cut the metric's short. A derived metric reads what its
+ * operands read: out when one is out, clipped when one is clipped. Nothing
+ * without that moment.
+ */
+export declare function metricReach(config: AnalysisViewConfig, context: {
+    now?: Date;
+    timeZone: string;
+}): Map<string, MetricReach>;
+/**
+ * `rows` with every metric out of the question's dates (`metricReach`)
+ * read as null: it was not measured over any of them, and its 0 is no
+ * number of the period it names.
+ */
+export declare function withoutOutOfReach(rows: readonly RecordData[], reach: ReadonlyMap<string, MetricReach>): RecordData[];
+//# sourceMappingURL=metricWindow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metricWindow.d.ts","sourceRoot":"","sources":["../../src/analysis/metricWindow.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAGV,kBAAkB,EAClB,UAAU,EACX,MAAM,mBAAmB,CAAC;AAI3B;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,SAAS,CAAC;AAE5C;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACxC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CA8B1B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GACtC,UAAU,EAAE,CAQd"}

package/dist/analysis/profiles.d.ts

@@ -0,0 +1,53 @@
+import { AnalysisViewConfig, ParallelSpec, RadarSpec, RecordData } from '../model/index.js';
+/**
+ * A group's profile: its value on each of several metrics, in the order
+ * the spec lists them — one shape of a radar, one line of parallel axes.
+ */
+export interface ChartProfile {
+    /** The group value it stands for. */
+    group: unknown;
+    /** One number per metric, in the spec's order. */
+    values: number[];
+}
+export interface RadarData {
+    type: 'radar';
+    /** The metric aliases, one axis each, in the order they go round. */
+    metrics: string[];
+    /** One shape per group, at most `CHART_COLOR_SLOTS`, in the rows' order. */
+    profiles: ChartProfile[];
+    /**
+     * How many groups are not drawn: past the palette's size a shape would
+     * wear another's colour, and past a handful the shapes cover each other
+     * anyway — the first ones in the view's sort are drawn, the table has all.
+     * A group missing one of the numbers is counted here too: a shape with a
+     * hole in it is no outline.
+     */
+    omitted: number;
+}
+export interface ParallelData {
+    type: 'parallel';
+    /** The metric aliases, one axis each, left to right. */
+    metrics: string[];
+    /** One line per group, in the rows' order. */
+    profiles: ChartProfile[];
+    /** How many groups miss one of the numbers, which no line can cross. */
+    omitted: number;
+}
+/**
+ * A radar's or parallel axes' metrics (`fitChartSlots`): the ones the spec
+ * lists that the shape still measures, in its order — the analyst's, set
+ * on the options page — once each, and every quantity while it lists none.
+ */
+export declare function profileAxes(listed: readonly string[] | undefined, quantities: readonly string[]): string[];
+/**
+ * A radar's shapes: every group's profile up to the palette's size, the
+ * rest counted rather than drawn in a colour another shape already wears.
+ */
+export declare function shapeRadar(spec: RadarSpec, config: AnalysisViewConfig, rows: readonly RecordData[]): RadarData;
+/**
+ * Parallel axes' lines: every group's profile. Lines past the palette's
+ * size are drawn in one hue (`parallelOption`), since a line is read by
+ * where it runs, and the tooltip names it.
+ */
+export declare function shapeParallel(spec: ParallelSpec, config: AnalysisViewConfig, rows: readonly RecordData[]): ParallelData;
+//# sourceMappingURL=profiles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"profiles.d.ts","sourceRoot":"","sources":["../../src/analysis/profiles.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAI3B;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,qCAAqC;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,kDAAkD;IAClD,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,OAAO,CAAC;IACd,qEAAqE;IACrE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,4EAA4E;IAC5E,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,UAAU,CAAC;IACjB,wDAAwD;IACxD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,8CAA8C;IAC9C,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EACrC,UAAU,EAAE,SAAS,MAAM,EAAE,GAC5B,MAAM,EAAE,CAGV;AA2BD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,SAAS,CAQX;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,YAAY,CAQd"}