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

package/dist/analysis/project.d.ts

@@ -0,0 +1,242 @@
+import { CurrencyReading, FieldNumeric, AnalysisDatePart, AnalysisDateUnit, AnalysisViewConfig, DataViewDefinition, FieldOption, NumberFormat, RecordData, EpochTimeUnit, RuntimeLimits } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+import { ChartData, ShapeContext } from './chart.js';
+import { MetricFunction } from './metricFormat.js';
+import { MetricCondition } from './metricCondition.js';
+/** A column of the result table; groups come first, then metrics. */
+export interface AnalysisColumnView {
+    alias: string;
+    /**
+     * The field this column is computed from, as the definition names it. For a
+     * metric it is half a header: the other half is `fn`, and only a catalogue
+     * can put the two in the reader's own order.
+     */
+    label: string;
+    role: 'group' | 'metric';
+    /**
+     * For a metric: which summary it is, so a header can read 「金额的平均」
+     * rather than the alias `amount_1`. Two metrics over one field differ here
+     * and nowhere else, which is exactly why the header cannot be the label.
+     */
+    fn?: MetricFunction;
+    /**
+     * The analyst named this column (`AnalysisNamed.label`): `label` is the
+     * whole title, and `fn` stays only for how the numbers read.
+     */
+    named?: true;
+    /**
+     * For a metric with a condition of its own: the records it counts are
+     * only some of them, and the header says so (D20 显示名) — 「金额的总和 ·
+     * 已发运」 — unless the analyst named the column, and its description
+     * says the whole condition either way.
+     */
+    condition?: MetricCondition;
+    width?: number;
+    /**
+     * How this column's numbers print. A group shows values of its field, so it
+     * takes the field's own format; a metric takes `metricFormat`, because what
+     * an aggregate is decides how it reads, not what it was computed from.
+     */
+    numberFormat?: NumberFormat;
+    /**
+     * What the number is by the source's semantics (`FieldNumeric`), where
+     * that — and not the author's `numberFormat` — decides how it reads: a
+     * file then holds the number itself, and money its currency beside it.
+     */
+    numeric?: FieldNumeric;
+    /**
+     * For a group, or a metric whose value is one of the field's
+     * (`readsAsItsField` — its earliest, its latest, a percentile, any one):
+     * the field's kind, renderer key and choices, so its values show as the
+     * field's do, a date as a date. Other metrics are numbers, whatever they
+     * were computed from.
+     */
+    kind?: string;
+    cell?: string;
+    options?: readonly FieldOption[];
+    /** A field kept in epoch seconds; milliseconds when unsaid. */
+    timeUnit?: EpochTimeUnit;
+    /** For a date histogram group: the width of the buckets its keys start. */
+    dateUnit?: AnalysisDateUnit;
+    /** For a date histogram group: the zone its buckets were cut in. */
+    timeZone?: string;
+    /**
+     * For a calendar part group: which part its keys are (the ISO weekday 1 to
+     * 7, the hour 0 to 23…), so a key reads 「周一」 or 「20时」 rather than a
+     * bare integer, and an axis runs through the part's whole domain
+     * (`DATE_PART_DOMAINS`).
+     */
+    datePart?: AnalysisDatePart;
+    /**
+     * For a value group that keeps a bucket of the records with no value: the
+     * key that bucket comes back under (`AnalysisGroup.missingKey`). The
+     * engine's sentinel (`DEFAULT_MISSING_KEY`) is a key and not a label, so
+     * the interface names that bucket in its own words; a key the analyst
+     * wrote is their name for it.
+     */
+    missingKey?: string;
+    /**
+     * For a number histogram group: the width of the bands its keys start, so
+     * a key reads as the band 「¥0～500」 rather than its lower bound alone.
+     */
+    interval?: number;
+    /**
+     * For a metric: what its number is a quantity of (`metricMeasure`) — the
+     * one token a combo chart puts two metrics on one axis by.
+     */
+    measure?: string;
+    /**
+     * For a metric: whether the source estimates it rather than computes it
+     * (`AnalysisCapability.approximate`); an estimated column wears 「≈」 and
+     * says why. Absent where the capability says nothing, and read then as
+     * `DEFAULT_APPROXIMATE_METRICS` reads it (`isApproximate`).
+     */
+    approximate?: boolean;
+    /**
+     * For a metric of money in a currency each record holds: how each row
+     * tells its currency (`rowCurrency`). A column whose rows are all in one
+     * currency already carries it in `numberFormat`.
+     */
+    currency?: ColumnCurrency;
+    /**
+     * `false` for a metric the rows cannot be ordered by
+     * (`AnalysisCapability.metricSort`); absent otherwise.
+     */
+    sortable?: false;
+}
+/**
+ * How a metric column of money in a currency each record holds is read, row
+ * by row: the companions telling each row's currency (`CurrencyCompanion`)
+ * — its own, or a derived metric's operands' — and whether its number is
+ * written in that currency. A ratio of two amounts (a derived metric with
+ * no currency format) is in none, yet still no number where its operands
+ * mix currencies.
+ */
+export interface ColumnCurrency {
+    /** Per companion, the aliases of its `ANY` and its `DISTINCT_COUNT`. */
+    companions: readonly {
+        code: string;
+        count: string;
+    }[];
+    writes: boolean;
+}
+/**
+ * What one row of a result says about a column's currency: the one its
+ * records are in, several, or nothing known (`companionsReading`).
+ */
+export declare function rowCurrency(row: RecordData | undefined, column: Pick<AnalysisColumnView, 'currency'>): CurrencyReading | undefined;
+export interface AnalysisProjection {
+    /**
+     * The table's columns: every alias the result holds, those `table.columns`
+     * names first and in its order, then the rest as `schema` lists them. The
+     * list orders and sizes columns; it never decides which exist.
+     */
+    columns: AnalysisColumnView[];
+    /**
+     * Every alias the result holds, described as `columns` are, in the order
+     * the question asks them — groups, then metrics — whatever order the table
+     * was dragged into. A chart names its categories through these, and a
+     * reading of the result says them in this order.
+     * `projectAnalysis` always sets it; a view built by hand may leave it out.
+     */
+    schema?: AnalysisColumnView[];
+    /** The groups on screen: at most `limit` of them, the probe row dropped. */
+    rows: RecordData[];
+    /**
+     * Whether groups exist that `rows` does not hold. Known, not guessed: the
+     * query asked Wow for one row more than the limit (`analysisProbeLimit`),
+     * and this says that row came back. It never reaches `rows` — the reader
+     * asked for `limit` groups and gets `limit` groups.
+     *
+     * It matters because every share, percentage and pie slice on a cut-short
+     * result is computed over a prefix, and a complete-looking table is the one
+     * thing a reader cannot check for themselves.
+     */
+    truncated: boolean;
+    /**
+     * The row limit the result exactly filled **when no probe was possible**.
+     *
+     * The configured limit already sits on the ceiling (`analysisProbeLimit`),
+     * so there is no row left to ask for and "came back exactly full" is all
+     * there is — ambiguous, because a grouping of exactly that size looks the
+     * same as one cut down to it. It is reported as "may have been cut short"
+     * for that reason, and never as a fact.
+     *
+     * Absent everywhere else, `truncated` having the answer there: the two are
+     * never both set.
+     */
+    atLimit?: number;
+    /**
+     * Present only when `table.totals` asked for it, the result has a
+     * dimension, and its query succeeded. Without a dimension the one row *is*
+     * every record in the range, and a totals row under it said the same
+     * numbers twice (2026-09-23 audit).
+     *
+     * Every aggregate of the whole range is right for it — a sum, an average
+     * of every record, a distinct count, a percentile, the earliest and the
+     * latest — bar `ANY` (`wholeOf`), which is one record's value: over the
+     * whole range it belongs to nobody, and under 「合计」 it would read as the
+     * whole's. It is left out, and its cell is blank.
+     */
+    totals?: RecordData;
+    /**
+     * 「只保留」 was in force: groups the having dropped are in `totals` and in
+     * no row, so a table says so where its totals are rather than leave the
+     * two to disagree unexplained. Absent without a dimension, where there is
+     * nothing to drop.
+     */
+    narrowed?: true;
+    /**
+     * The ungrouped answer — every record in the range, one row — when the
+     * config asked for it (`asksForWhole`) and its query succeeded. What a
+     * chart reads as "the whole": the headline of a metric card over a trend.
+     * `totals` is the same row when the table was asked to draw it.
+     */
+    overall?: RecordData;
+    /**
+     * The metric types the source estimates (`approximateMetrics`): what a
+     * title marks 「≈」, a derived metric's references included.
+     */
+    approximate?: readonly string[];
+    /**
+     * The rows of one more query, grouped by a split chart's axis alone, when
+     * the split ran past the palette and its metric adds up (`foldsSplit`,
+     * D33 Q56): each category's whole, which 「其他」 is measured against.
+     */
+    splitWhole?: RecordData[];
+    /** Shaped for the configured chart family; absent when it cannot be drawn. */
+    chart?: ChartData;
+}
+/**
+ * The metric columns of a result that are moments — the earliest, the latest
+ * of a date — by alias: those the projection gave a date's reading. It is
+ * `momentMetrics` read off the result rather than the definition, so a
+ * reader holding only the rows (the result block, the options panel) says
+ * the same thing the kernels said.
+ */
+export declare function momentColumns(columns: readonly AnalysisColumnView[]): Set<string>;
+/**
+ * What each metric column's number is a quantity of (`metricMeasure`), by
+ * alias: `metricMeasures` read off the result rather than the definition,
+ * from the summary a column says it is and the format it prints in — so the
+ * options panel and the redraw put a series on the axis the kernel would.
+ */
+export declare function measureColumns(columns: readonly AnalysisColumnView[]): Map<string, string>;
+/**
+ * Turns aggregation rows into table columns plus whatever the chart family
+ * needs. A DERIVED metric is an ordinary column: the backend computed it.
+ *
+ * `kinds` read a metric's own condition (`AnalysisColumnView.condition`);
+ * without them a conditioned column cannot say what it counts, and says
+ * nothing rather than guess.
+ *
+ * `context` is the engine's zone and the moment the question was asked, the
+ * chart is shaped under (`ShapeContext`): a day bucket is stepped in the
+ * engine's zone, not the host's, and a trend card's last period is the last
+ * one over by the time it was asked.
+ *
+ * `limits` are the runtime's the query was compiled under: whether a probe
+ * row was asked for depends on `maxAnalysisRows` (`analysisProbeLimit`).
+ */
+export declare function projectAnalysis(definition: DataViewDefinition, config: AnalysisViewConfig, result: readonly RecordData[], totals?: readonly RecordData[], kinds?: FieldKindRegistry, context?: ShapeContext, limits?: Pick<RuntimeLimits, 'maxAnalysisRows'>): AnalysisProjection;
+//# sourceMappingURL=project.d.ts.map

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

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

package/dist/analysis/queryFilter.d.ts

@@ -0,0 +1,32 @@
+import { FieldDefinition, FilterTree, Issue, IssuePath, RuntimeLimits } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+/**
+ * Admits a metric's own filter, which reaches compilation either way.
+ *
+ * Two checks, because the filter is wrong in two different ways. It is an
+ * ordinary filter over the analysis scope, so it must name fields that exist
+ * and hold values its operators can take — nothing was checking that at all.
+ * It is also in metric position, where Wow allows less than it does at the
+ * root.
+ */
+/** Where a filter sits, which decides what it may say and how it is reported. */
+export type QueryFilterPosition = 'metric' | 'element';
+export interface QueryFilterCheck {
+    tree: FilterTree;
+    /**
+     * The fields this filter may name, plus the ones it may not but that exist
+     * elsewhere in the view: a leaf standing on one of those is a finding of
+     * its own (`outOfScope`), and admitting it here is what keeps that the only
+     * finding — its value and its operator are still judged, and one mistake
+     * is reported once.
+     */
+    fields: readonly FieldDefinition[];
+    /** Names among `fields` that this position may not reach. */
+    outOfScope?: ReadonlySet<string>;
+    kinds: FieldKindRegistry;
+    limits: RuntimeLimits;
+    position: QueryFilterPosition;
+    path: IssuePath;
+}
+export declare function queryFilterIssues(check: QueryFilterCheck): Issue[];
+//# sourceMappingURL=queryFilter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queryFilter.d.ts","sourceRoot":"","sources":["../../src/analysis/queryFilter.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,eAAe,EAEf,UAAU,EACV,KAAK,EACL,SAAS,EACT,aAAa,EACd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAQL,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;GAQG;AACH,iFAAiF;AACjF,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,SAAS,CAAC;AAavD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,UAAU,CAAC;IACjB;;;;;;OAMG;IACH,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IACnC,6DAA6D;IAC7D,UAAU,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACjC,KAAK,EAAE,iBAAiB,CAAC;IACzB,MAAM,EAAE,aAAa,CAAC;IACtB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,GAAG,KAAK,EAAE,CAclE"}

package/dist/analysis/references.d.ts

@@ -0,0 +1,41 @@
+import { CartesianSpec, ReferenceLine, ReferenceStatistic } from '../model/index.js';
+import { CartesianData } from './cartesian.js';
+import { CartesianGap } from './derived.js';
+/**
+ * A reference line where the kernel placed it: a constant as written, a
+ * statistic at the number it came to.
+ */
+export interface PlacedLine extends ReferenceLine {
+    value: number;
+}
+/**
+ * Each series' highest and lowest measured value, as point indexes. Only
+ * where the series has two measured values that differ: a flat series has
+ * no peak to point at.
+ */
+export type SeriesExtremes = Record<string, {
+    high: number;
+    low: number;
+}>;
+/** The mean or the middle of some numbers; there is at least one. */
+export declare function statistic(values: readonly number[], of: ReferenceStatistic): number;
+/**
+ * The spec's reference lines placed over `data`: a constant stays where it
+ * is; a statistic is taken of its metric's measured values and stands
+ * there. A statistic over a split is left out — the split made one series
+ * per value, and one line could not say which it measures — one over a
+ * chart of shares, and one over a metric with nothing measured; each says
+ * why in `gaps`. A line with neither a value nor a statistic is not drawn
+ * (validation refuses it).
+ */
+export declare function placeLines(spec: CartesianSpec, data: CartesianData): {
+    lines: PlacedLine[];
+    gaps: CartesianGap[];
+};
+/**
+ * The highest and the lowest measured point of every series, the first of
+ * equals — `CartesianSpec.extremes`. A filled-in 0 is never the lowest: it
+ * is a day with no records, not a day that measured nothing.
+ */
+export declare function seriesExtremes(data: CartesianData): SeriesExtremes;
+//# sourceMappingURL=references.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../src/analysis/references.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,kBAAkB,EACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,UAAW,SAAQ,aAAa;IAC/C,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAsB3E,qEAAqE;AACrE,wBAAgB,SAAS,CACvB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,EAAE,EAAE,kBAAkB,GACrB,MAAM,CAQR;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,aAAa,GAClB;IAAE,KAAK,EAAE,UAAU,EAAE,CAAC;IAAC,IAAI,EAAE,YAAY,EAAE,CAAA;CAAE,CA4B/C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,cAAc,CAelE"}

package/dist/analysis/splitOther.d.ts

@@ -0,0 +1,80 @@
+import { AnalysisViewConfig, DataViewDefinition, RecordData, RuntimeLimits } from '../model/index.js';
+import { CartesianData } from './cartesian.js';
+/**
+ * A split into more series than the palette has colours (D33 Q56, which
+ * settles Q9). Past `CHART_COLOR_SLOTS` two series would wear one colour and
+ * a legend could not tell them apart, so a split whose metric adds up draws
+ * its seven largest series and one grey 「其他」 for the rest — the pie's
+ * 「其他」, the same colour and the same meaning. The rest is not the sum of
+ * the series the rows hold past the seventh: the limit may have cut some
+ * away. It is the whole of each category, from one more query grouped by
+ * the axis alone (`splitWholeConfig`), less the seven kept. A metric that
+ * does not add up has no rest to subtract, and is drawn whole, its colours
+ * repeating; the display page says so (`CartesianData.crowded`).
+ *
+ * Internal to the package: the runtime asks `foldsSplit` and runs the query,
+ * `shapeCartesian` folds, and `/ui` reads what they left on the data.
+ */
+/**
+ * Whether a config's chart may fold its split at all, whatever the rows: a
+ * cartesian chart split by a dimension, its one metric adding up — a rest
+ * of averages is no average of anything — and no 「只保留」, since a having
+ * drops groups by their numbers, so the axis's whole would count groups the
+ * split never had. The one rule both the runtime (`foldsSplit`, whether to
+ * ask for the whole) and the kernel (`shapeCartesian`, whether to fold a
+ * whole it was handed) read.
+ */
+export declare function splitFoldable(config: AnalysisViewConfig): boolean;
+/**
+ * Whether a config's chart folds its split over these rows: it may
+ * (`splitFoldable`), and the rows hold more split values than colours.
+ */
+export declare function foldsSplit(config: AnalysisViewConfig, rows: readonly RecordData[]): boolean;
+/**
+ * The question the rest is measured by: the same range and metrics, grouped
+ * by the chart's axis alone, every category of it asked for — up to the
+ * ceiling a query may ask (`limitBounds`: the definition's `maxLimit`, the
+ * runtime's `maxAnalysisRows`, Wow's own; D42), since a category the rows
+ * draw and this one cut would have no rest — and in no particular order,
+ * since it is read by key.
+ */
+export declare function splitWholeConfig(definition: DataViewDefinition, config: AnalysisViewConfig, limits?: Pick<RuntimeLimits, 'maxAnalysisRows'>): AnalysisViewConfig;
+/**
+ * How big each of `data`'s series is (`data.series`' order), the one measure
+ * a split's series are ranked by — for the order a legend reads and a stack
+ * builds in (`bySize`), and for which seven a fold keeps (`foldOther`):
+ *
+ * - the series' own metric: a split draws exactly one
+ *   (`chart.splitBy.needs-one-series`), so every series of it measures the
+ *   same thing and the sizes compare;
+ * - the numbers it measured — a value the kernel filled in (`filled`) is a
+ *   known 0 or nothing, never a size — each by its absolute value: a bar
+ *   under the axis is as big as one over it, and a channel that lost ¥1M is
+ *   not smaller than one that broke even (a profit, a net change);
+ * - added up where the metric adds up (`additive`): a total is how much of
+ *   the whole the series holds; otherwise their mean, since a total of
+ *   averages grows with how many categories a series turns up in, not with
+ *   how big its numbers are.
+ *
+ * Computed from the drawn points, so the order is the engine's own and does
+ * not rest on the order a source answers groups in.
+ */
+export declare function seriesSizes(data: Pick<CartesianData, 'points' | 'series'>, additive: boolean): number[];
+/**
+ * A split's series, the largest first (`seriesSizes`): what a reader looks
+ * for first is the biggest, and a stack reads from the bottom up, so the
+ * biggest sits at its base and heads the legend — the palette's first
+ * colour goes to it. Series of one size keep the order they came in.
+ */
+export declare function bySize(data: Pick<CartesianData, 'points' | 'series'>, additive: boolean): CartesianData['series'];
+/**
+ * `data` with its series past the palette folded: the seven largest
+ * (`seriesSizes`), in the order they were drawn, then 「其他」 —
+ * at each category the axis's whole (`whole`, rows of `splitWholeConfig`)
+ * less the seven. Where that cannot be known — a kept value not measured,
+ * a category the whole did not answer — the rest is drawn as nothing,
+ * never as a guess; a category with nothing measured at all is 0, filled
+ * in as the kernel fills any known-empty group.
+ */
+export declare function foldOther(data: CartesianData, config: AnalysisViewConfig, whole: readonly RecordData[]): CartesianData;
+//# sourceMappingURL=splitOther.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"splitOther.d.ts","sourceRoot":"","sources":["../../src/analysis/splitOther.ts"],"names":[],"mappings":"AAaA,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,UAAU,EACf,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAKpD;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAYjE;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,OAAO,CAKT;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,kBAAkB,EAC1B,MAAM,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,iBAAiB,CAAC,GAC9C,kBAAkB,CAYpB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,GAAG,QAAQ,CAAC,EAC9C,QAAQ,EAAE,OAAO,GAChB,MAAM,EAAE,CAaV;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,GAAG,QAAQ,CAAC,EAC9C,QAAQ,EAAE,OAAO,GAChB,aAAa,CAAC,QAAQ,CAAC,CAMzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,SAAS,UAAU,EAAE,GAC3B,aAAa,CA4Df"}

package/dist/analysis/timeAxis.d.ts

@@ -0,0 +1,173 @@
+import { AnalysisGroup, AnalysisViewConfig, FilterTree } from '../model/index.js';
+/**
+ * A time axis as the chart projection draws one: earliest first whatever
+ * the rows' order (`forwardInTime`), and without holes between its first
+ * and its last bucket (`withoutHoles`). What a hole holds is the caller's
+ * to say; where it falls is time's.
+ */
+export type DateGroup = Extract<AnalysisGroup, {
+    type: 'DATE_HISTOGRAM';
+}>;
+/**
+ * The time dimension — a date bucket — `alias` names in the config the rows
+ * came from, if it names one.
+ */
+export declare function timeGroup(config: AnalysisViewConfig, alias: string | undefined): DateGroup | undefined;
+export type PartGroup = Extract<AnalysisGroup, {
+    type: 'DATE_PART';
+}>;
+/** The calendar part dimension — the weekday, the hour — `alias` names, if it names one. */
+export declare function partGroup(config: AnalysisViewConfig, alias: string | undefined): PartGroup | undefined;
+/**
+ * `items` along a calendar part's cycle: its keys in their own order —
+ * Monday to Sunday, 0 to 23 o'clock — and every key of the part's domain
+ * (`DATE_PART_DOMAINS`) there, whatever the rows held. A Wednesday with no
+ * orders is still a Wednesday, and a week read 周一 周二 周四 hides the day
+ * the question was about; unlike a time axis the run is known before any row
+ * arrives, so it never depends on the rows at either end. What a hole holds
+ * is the caller's to say (`hole`). A key outside the domain — a
+ * missing-value sentinel — follows the cycle, in the order it came.
+ */
+export declare function alongPart<T>(items: readonly T[], at: (item: T) => unknown, group: PartGroup, hole: (key: number) => T): T[];
+/**
+ * `items` by the number each one's key reads as, without filling a domain:
+ * a calendar part's order (Monday to Sunday, 0 to 23 o'clock), or a band's
+ * — a `HISTOGRAM` key is its band's lower bound. A key that reads as no
+ * number, a missing-value sentinel, comes last, in the order it came.
+ */
+export declare function inNumberOrder<T>(items: readonly T[], at: (item: T) => unknown): T[];
+/**
+ * `items` earliest first, by the bucket `at` reads off each.
+ *
+ * A time axis runs forward whatever order the rows came in. The rows are in
+ * the view's sort, and a view of the last thirty days is sorted newest first
+ * on purpose — its table leads with today — but the same rows drawn in that
+ * order put today on the left and yesterday to its right: every line slopes
+ * the wrong way and every bar reads backwards, with nothing on screen to say
+ * so. The table is the view's to order; an axis is time's.
+ *
+ * A bucket is read the way the drill reads it (`readInstant`), so a key that
+ * arrives as epoch milliseconds, as a string of digits or as a wall-clock day
+ * sorts the same. One that names no instant — a missing-value sentinel — is
+ * no point in time, so it goes after the last one, and ties and unreadable
+ * keys keep the order they came in.
+ */
+export declare function forwardInTime<T>(items: readonly T[], at: (item: T) => unknown): T[];
+/**
+ * `items` — already earliest first (`forwardInTime`) — with a hole for every
+ * bucket of `group`'s unit that is missing between the first and the last.
+ *
+ * A time axis is time: a day with no rows is still a day. Drawn as a
+ * category axis of the buckets that came back, 8/20 sat next to 8/23, a bar
+ * chart read as consecutive days and a line smoothed three days of zero into
+ * a slope — and "which days did nothing happen" is the question an operator
+ * looks at a daily chart to answer.
+ *
+ * The buckets are stepped with the drill's own `bucketRange`, in the zone the
+ * histogram was cut in: the group's `timeZone`, else the engine's. A bucket
+ * written as a wall-clock day (`2026-09-18`) names a day and no zone, and is
+ * stepped at UTC, where `readInstant` reads it. Every present bucket must lie
+ * on the stepped run — a key cut in another zone, or a week that starts on
+ * another day, does not — and when one does not, nothing is filled: a hole
+ * the kernel cannot place is left out rather than invented. So is a `dense`
+ * histogram, which the source has filled already. A bucket that names no
+ * moment — the missing-value sentinel — stays after the last one, and a hole
+ * is written the way the first bucket was (a number, digits, a day), so the
+ * UI reads it as its column does.
+ *
+ * Given a `window` — the instants `[from, to)` the question was over — the
+ * run reaches out to the buckets holding its two ends as well, so a quiet
+ * first or last day is a day too. It is the caller's to pass one only when a
+ * bucket the rows lack there is known to be empty. With a window one bucket,
+ * or none, is an axis already; with none there is no key to write a hole
+ * like, and a hole is the epoch milliseconds a Wow histogram answers with.
+ */
+export declare function withoutHoles<T>(items: readonly T[], at: (item: T) => unknown, group: DateGroup, timeZone: string, hole: (key: unknown) => T, window?: TimeWindow): T[];
+/** Instants `[from, to)` in epoch milliseconds: what a question was over. */
+export interface TimeWindow {
+    from: number;
+    to: number;
+}
+/**
+ * The window a time axis runs to, when every bucket of it the rows lack is
+ * known to have had no records: what the conditions pin on the axis's field
+ * — a view's own 「近 30 天」, or the window a board anchored it to, which
+ * reaches it as a condition too — read at the moment the question was
+ * asked, and never past that moment's bucket, since a day that has not come
+ * yet had no records only so far.
+ *
+ * Known empty is the whole result's to say (D14, `absenceReader`): no
+ * 「只保留」 to have dropped a bucket by its numbers, and fewer rows than the
+ * limit, so none was cut off an end. Otherwise, or with no moment to read
+ * the conditions at, or no lower bound to start from, there is no window,
+ * and the axis runs between the buckets that came back. A trend card's
+ * sparkline (D39) and a chart's time axis ask the same question here.
+ */
+export declare function knownWindow(axis: DateGroup, config: AnalysisViewConfig, rows: number, now: Date | undefined, timeZone: string): TimeWindow | undefined;
+/**
+ * The window the applied conditions pin on `field`: the latest lower bound
+ * and the earliest upper bound among the conditions the tree ANDs together
+ * at any depth — a condition under an OR is one alternative, not a bound —
+ * as instants `[from, to)`, each `null` where nothing bounds that side.
+ * Relative and named dates resolve at `now` in `timeZone`, as they did when
+ * the question compiled.
+ */
+export declare function appliedWindow(filter: FilterTree, field: string, now: Date, timeZone: string): {
+    from: number | null;
+    to: number | null;
+};
+/**
+ * The bucket `key` starts, as the moments it runs from and to, stepped in
+ * the zone `withoutHoles` steps in: a wall-clock key at UTC, where
+ * `readInstant` reads it, anything else in the group's zone or the engine's
+ * — the zone its `from` and `to` read in (`zone`).
+ * `ended` says whether it was over at `now`: a wall-clock key names a day
+ * and no zone, so it is over once the clock in that zone has passed its end;
+ * `left` is how long it still ran from `now`, where it had not ended.
+ *
+ * With a `window` — the instants the question's conditions pin on the
+ * axis's field (`appliedWindow`) — the span is the part of the bucket inside
+ * it, and `clipped` says the window cut the bucket short: a month bucket
+ * under a filter of one day holds that day, and is over when the day is.
+ * A window that misses the bucket altogether cuts nothing; no row of the
+ * answer stands there.
+ *
+ * Undefined for a key that names no moment — the missing-value sentinel.
+ */
+export declare function bucketSpan(group: DateGroup, key: unknown, timeZone: string, now?: Date, window?: {
+    from: number | null;
+    to: number | null;
+}): {
+    from: number;
+    to: number;
+    ended: boolean;
+    left?: number;
+    clipped?: true;
+    zone: string;
+} | undefined;
+/**
+ * The period still under way at the end of a time axis: the last of `keys`
+ * that names a moment, when its bucket — as much of it as the applied
+ * conditions hold (`appliedWindow`) — had not ended at `now`. A chart draws
+ * it and marks it, and reads nothing from it (second review R2-P1-7): the
+ * nine days of a month so far are no month, and a line that ends in them
+ * reads as a fall. Nothing without `now`, or on an axis that is not time.
+ */
+export declare function unfinishedBucket(config: AnalysisViewConfig, alias: string | undefined, keys: readonly unknown[], timeZone: string, now: Date | undefined): {
+    at: unknown;
+} | undefined;
+/**
+ * Whether the buckets `items` stand for — earliest first — run one after
+ * another, each starting where the one before it ended (`bucketSpan`), so
+ * the point before one is its previous period. Items naming no moment (the
+ * missing-value sentinel, last) are no bucket and are passed over. A time
+ * axis `withoutHoles` could not fill, or one cut in a zone the kernel does
+ * not step in, is not consecutive, and nothing reads a change across it.
+ */
+export declare function consecutive<T>(items: readonly T[], at: (item: T) => unknown, group: DateGroup, timeZone: string): boolean;
+/**
+ * The host's zone, which is the engine's unless the host configured another
+ * (`runtime/environment.ts`); a caller that knows the engine's passes it.
+ */
+export declare function hostTimeZone(): string;
+//# sourceMappingURL=timeAxis.d.ts.map

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

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