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

package/dist/analysis/expand.d.ts

@@ -0,0 +1,51 @@
+import { AnalysisCapability, AnalysisElement, AnalysisGroup, AnalysisMetric, AnalysisViewConfig, DataViewDefinition } from '../model/index.js';
+import { AnalysisScope } from './capability.js';
+/**
+ * The config re-scoped to a new expansion chain (D20 屏 G).
+ *
+ * Expanding an array changes the counting unit: after `orders → lines` the
+ * dimensions and the metrics can only name the line's fields, and a
+ * dimension over the order's warehouse is a question about the wrong thing
+ * (Wow refuses it as outside the element scope). So a step into or out of
+ * the chain takes with it every dimension and metric that no longer names
+ * a field of the new unit — and a metric's own condition that names one —
+ * and, when that leaves nothing to measure, starts the metrics again from
+ * the first thing the new unit can count, as a fresh analysis would. What
+ * still names a field of the unit is kept as it was.
+ *
+ * A derived metric that read a metric that left goes too, and one that read
+ * it after it (`withoutDangling`); one that read nothing before the step
+ * stays for admission to point at. The chart, the sort, the table columns
+ * and the having follow the survivors the way they follow any change of
+ * groups and metrics (`useAnalysisEditor`'s reshape), so this answers only
+ * what is grouped and measured — and, in `dropped`, what the step took
+ * away, so the editor can say so and offer it back (D71: no confirmation,
+ * an undo).
+ */
+export declare function withElements(config: AnalysisViewConfig, elements: AnalysisElement[], definition: DataViewDefinition, capability: AnalysisCapability): Rescoped;
+/** What a step of the chain took out of the question. */
+export interface Dropped {
+    groups: AnalysisGroup[];
+    metrics: AnalysisMetric[];
+}
+/** The config re-scoped to a chain, and what the step took away. */
+export interface Rescoped extends Pick<AnalysisViewConfig, 'elements' | 'groups' | 'metrics'> {
+    dropped: Dropped;
+}
+/** The chain one level deeper: the declared next step, with no gate yet. */
+export declare function withLevel(elements: readonly AnalysisElement[], path: string): AnalysisElement[];
+/** The chain cut at `index`: that level and every level inside it leave. */
+export declare function withoutLevelsFrom(elements: readonly AnalysisElement[], index: number): AnalysisElement[];
+/**
+ * The next level the capability declares beyond what is expanded, or none:
+ * the chain is one line, so there is at most one thing to expand into.
+ */
+export declare function nextExpansion(declaredChain: readonly string[], elements: readonly AnalysisElement[]): string | undefined;
+/** What the level at `index` is called: its array's label, else its path. */
+export declare function levelLabel(definition: DataViewDefinition, scope: AnalysisScope, index: number): string;
+/** The next step of the declared chain, named, or none. */
+export declare function nextLevel(definition: DataViewDefinition, scope: AnalysisScope, elements: readonly AnalysisElement[]): {
+    path: string;
+    label: string;
+} | undefined;
+//# sourceMappingURL=expand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expand.d.ts","sourceRoot":"","sources":["../../src/analysis/expand.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EAExB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKpE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,eAAe,EAAE,EAC3B,UAAU,EAAE,kBAAkB,EAC9B,UAAU,EAAE,kBAAkB,GAC7B,QAAQ,CA8CV;AAED,yDAAyD;AACzD,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,OAAO,EAAE,cAAc,EAAE,CAAC;CAC3B;AAED,oEAAoE;AACpE,MAAM,WAAW,QAAS,SAAQ,IAAI,CACpC,kBAAkB,EAClB,UAAU,GAAG,QAAQ,GAAG,SAAS,CAClC;IACC,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,4EAA4E;AAC5E,wBAAgB,SAAS,CACvB,QAAQ,EAAE,SAAS,eAAe,EAAE,EACpC,IAAI,EAAE,MAAM,GACX,eAAe,EAAE,CAEnB;AAED,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,SAAS,eAAe,EAAE,EACpC,KAAK,EAAE,MAAM,GACZ,eAAe,EAAE,CAEnB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,QAAQ,EAAE,SAAS,eAAe,EAAE,GACnC,MAAM,GAAG,SAAS,CAEpB;AAsBD,6EAA6E;AAC7E,wBAAgB,UAAU,CACxB,UAAU,EAAE,kBAAkB,EAC9B,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,MAAM,GACZ,MAAM,CAQR;AAED,2DAA2D;AAC3D,wBAAgB,SAAS,CACvB,UAAU,EAAE,kBAAkB,EAC9B,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,SAAS,eAAe,EAAE,GACnC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAQ7C"}

package/dist/analysis/expressions.d.ts

@@ -0,0 +1,12 @@
+import { AnalysisDerivedExpression, AnalysisExpression, Issue, IssuePath, RuntimeLimits } from '../model/index.js';
+import { AnalysisScope } from './capability.js';
+import { BudgetCounter } from './budget.js';
+/** `expressionIssues` behind the budget, which decides whether it runs. */
+export declare function budgetedExpressionIssues(expression: AnalysisExpression, scope: AnalysisScope, path: IssuePath, expressionsAllowed: boolean, limits: RuntimeLimits, counted: BudgetCounter, 
+/** The units a time between two moments may be measured in (`dateDiffUnitsOf`). */
+units?: readonly string[]): Issue[];
+/** `derivedIssues` behind the budget, which decides whether it runs. */
+export declare function budgetedDerivedIssues(expression: AnalysisDerivedExpression | undefined, available: ReadonlySet<string>, path: IssuePath, limits: RuntimeLimits, counted: BudgetCounter, 
+/** The metrics that are moments (`momentMetrics`): no operand is one. */
+moments?: ReadonlySet<string>): Issue[];
+//# sourceMappingURL=expressions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../src/analysis/expressions.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,EACvB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AA2FrB,2EAA2E;AAC3E,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,kBAAkB,EAC9B,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,SAAS,EACf,kBAAkB,EAAE,OAAO,EAC3B,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,aAAa;AACtB,mFAAmF;AACnF,KAAK,GAAE,SAAS,MAAM,EAAO,GAC5B,KAAK,EAAE,CAKT;AA2CD,wEAAwE;AACxE,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,yBAAyB,GAAG,SAAS,EACjD,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,EAC9B,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,aAAa;AACtB,yEAAyE;AACzE,OAAO,GAAE,WAAW,CAAC,MAAM,CAAa,GACvC,KAAK,EAAE,CAKT"}

package/dist/analysis/fitCharts.d.ts

@@ -0,0 +1,93 @@
+import { AnalysisGroup, AnalysisMetric, AnalysisViewConfig, ChartSpec, ChartType, RecordData } from '../model/index.js';
+import { ChartUnfit } from './chartFamilies.js';
+export interface ChartFit {
+    available: boolean;
+    /** Why not, when not. */
+    reason?: ChartUnfit;
+    /**
+     * Why a type that can draw the result is not offered as fitting it: it
+     * is drawn, but listed among the other types with this said — a funnel
+     * over categories that are no steps (`AggregationFieldCapability.steps`).
+     */
+    aside?: ChartUnfit;
+    /** The one the shape reads best as; at most one type carries it. */
+    recommended?: true;
+}
+/** The shape a chart is fitted to: what there is to draw. */
+export interface ChartShape {
+    groups: readonly AnalysisGroup[];
+    metrics: readonly AnalysisMetric[];
+    /**
+     * The metrics among them that are moments (`momentMetrics`), by alias:
+     * written out on a card and in the table, never measured by a mark.
+     */
+    moments?: ReadonlySet<string>;
+    /**
+     * The rows the shape answered with, when there are any. A funnel over one
+     * dimension takes its stages from them the moment it is picked
+     * (`withStagesFrom`), so they decide whether it has the two stages a
+     * funnel needs; left out, only the dimension's type is judged.
+     */
+    rows?: readonly RecordData[];
+    /**
+     * The chart as it stands, read while no rows are known: a view that has
+     * not run has nothing to fill a funnel's stages from, so a funnel over the
+     * one dimension has the stages its spec already names (`order`, which
+     * `fitChartSlots` keeps) and no others. Left out, as are the rows, the
+     * stages are not judged.
+     */
+    chart?: ChartSpec;
+    /**
+     * The dimensions, by alias, whose values the definition declares the steps
+     * of one process (`AggregationFieldCapability.steps`). Left out, it is not
+     * judged: a funnel over any category is offered.
+     */
+    steps?: ReadonlySet<string>;
+}
+/**
+ * Which chart types can draw a result of this shape, and which one it reads
+ * best as (K3). The capability decides which types exist at all (D4); this
+ * decides which of them are greyed right now, and why — the answer to Q6.
+ *
+ * Each type answers with its family's fit (`CHART_FAMILIES` in
+ * `chartFamilies.ts`), which is `validateChart`'s rules read forward; a
+ * table draws anything and is not among them.
+ */
+export declare function fitCharts(shape: ChartShape): Record<ChartType, ChartFit>;
+/**
+ * Why the config's chart cannot draw its own shape, or null when it can —
+ * or when its type is none this package has, which `validateChart` names.
+ *
+ * Judged by the shape alone, as the picker judges it before any row: the
+ * dimensions and the metrics, the moments among them. A chart whose type
+ * the shape leaves no room for — a bar over three dimensions, bars over
+ * nothing but dates — is not a config gone wrong but a result the chart
+ * cannot draw (D20): the result is drawn as its table, which draws any
+ * shape, and the chart waits for a shape it can draw. Nothing is shaped
+ * for it (`projectAnalysis`), and its rules are not asked (`validateAnalysis`).
+ */
+export declare function chartUnfit(config: Pick<AnalysisViewConfig, 'groups' | 'metrics' | 'chart'>, moments: ReadonlySet<string>): ChartUnfit | null;
+/** Every type, in the order the picker lays them out. */
+export declare const CHART_PICKER_ORDER: readonly ChartType[];
+/**
+ * The picker's two groups of tiles (D33 Q54): the types that fit, and the
+ * rest — greyed where they cannot draw, pickable where they draw but are not
+ * offered as fitting (`aside`).
+ */
+export interface ChartPickerGroups {
+    /** 「适合这个结果」: every type that can draw it, then the table. */
+    suits: (ChartType | 'table')[];
+    /** 「其他图型」: the types it leaves greyed, each with its reason. */
+    others: ChartType[];
+}
+/**
+ * The picker's tiles in its two groups: what can draw this result first —
+ * the table last among them, since it draws anything — and every other type
+ * under 「其他图型」, still a tile, still saying what it lacks (D33 Q54). The
+ * split is the fit and nothing else: a definition declares no chart types,
+ * because the shape already says which draw, and saying it twice would be
+ * two answers that could part. Each group keeps `CHART_PICKER_ORDER`, so a
+ * type moving between them lands where a reader expects it.
+ */
+export declare function chartPickerGroups(fits: Record<ChartType, ChartFit>): ChartPickerGroups;
+//# sourceMappingURL=fitCharts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fitCharts.d.ts","sourceRoot":"","sources":["../../src/analysis/fitCharts.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAY,KAAK,UAAU,EAAmB,MAAM,oBAAoB,CAAC;AAIhF,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,yBAAyB;IACzB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB;;;;OAIG;IACH,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,oEAAoE;IACpE,WAAW,CAAC,EAAE,IAAI,CAAC;CACpB;AAED,6DAA6D;AAC7D,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IACjC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IACnC;;;OAGG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC9B;;;;;OAKG;IACH,IAAI,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAC7B;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;;;OAIG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,CAyBxE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC,EAChE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3B,UAAU,GAAG,IAAI,CAMnB;AA+ED,yDAAyD;AACzD,eAAO,MAAM,kBAAkB,EAAE,SAAS,SAAS,EAAgB,CAAC;AAEpE;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,6DAA6D;IAC7D,KAAK,EAAE,CAAC,SAAS,GAAG,OAAO,CAAC,EAAE,CAAC;IAC/B,gEAAgE;IAChE,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,GAChC,iBAAiB,CAUnB"}

package/dist/analysis/formula.d.ts

@@ -0,0 +1,65 @@
+import { AnalysisDateDiffUnit, AnalysisDerivedExpression, AnalysisExpression, AnalysisExpressionOperator, AnalysisFunction, AnalysisMetric } from '../model/index.js';
+import { MetricCondition } from './metricCondition.js';
+import { MetricFunction } from './metricFormat.js';
+export declare const EXPRESSION_OPERATORS: readonly AnalysisExpressionOperator[];
+/**
+ * How a derived metric's text names another metric it refers to. The kernel
+ * holds no catalogue, so it cannot say 「金额的总和」 or 「记录数」: it writes
+ * the referenced metric's summary and name between control characters, and
+ * `columnTitle` in the UI words each one exactly as that metric's own column
+ * is worded (`wordReferences`) — so an operand reads the same in the
+ * derived column's header, on the derived metric's card, and in the operand
+ * picker beside it. Nothing a definition labels can hold a control
+ * character, so a reference cannot collide with a field's or a metric's
+ * name.
+ *
+ * A referenced metric with a condition of its own carries it along
+ * (`metricCondition`): 「金额的总和 · 已发运 ÷ 记录数」 is a different ratio
+ * from the one without it, and the operand says so as its own column does.
+ * Only what a name reads is written — the one value, or that there is a
+ * condition at all — as a third segment, empty for the second.
+ */
+export declare function metricReferenceText(fn: MetricFunction, label: string, condition?: Pick<MetricCondition, 'value'>): string;
+/**
+ * A derived metric's text with every reference `metricReferenceText`
+ * wrote in it replaced by what `word` makes of its summary, its name and
+ * the condition it counts under, when it has one.
+ */
+export declare function wordReferences(text: string, word: (fn: MetricFunction, label: string, condition?: Pick<MetricCondition, 'value'>) => string): string;
+/** The sign an operator prints as, in every language. */
+export declare const OPERATOR_SIGN: Readonly<Record<AnalysisExpressionOperator, string>>;
+/** A formula's first shape: the first two measurable fields, subtracted, summed. */
+export declare function formulaMetric(left: string, right: string, fn: AnalysisFunction, taken: readonly string[]): AnalysisMetric;
+/** A derived metric's first shape: the first metric divided by the second. */
+export declare function derivedMetric(left: string, right: string, taken: readonly string[]): AnalysisMetric;
+/**
+ * A formula as its author would say it — 「金额 − 成本」 — for a column
+ * header, a legend and the reading, naming each field as the definition
+ * labels it. A nested formula is parenthesised.
+ */
+export declare function expressionText(expression: AnalysisExpression, nameOf: (field: string) => string, nested?: boolean): string;
+/** A derived metric as its author would say it, naming each metric it reads. */
+export declare function derivedText(expression: AnalysisDerivedExpression, nameOf: (metric: string) => string, nested?: boolean): string;
+/**
+ * A time between two moments measured as a metric (N3): the average hours
+ * from `from` to `to` across the group, which the card can change to a
+ * lowest, a highest, a total or a percentile.
+ */
+export declare function durationMetric(from: string, to: string, unit: AnalysisDateDiffUnit, taken: readonly string[]): AnalysisMetric;
+/** Whether a metric measures a time between two moments: the duration card's. */
+export declare function isDuration(metric: AnalysisMetric): metric is Extract<AnalysisMetric, {
+    type: 'NUMERIC' | 'PERCENTILE';
+}> & {
+    expression: Extract<AnalysisExpression, {
+        type: 'DATE_DIFF';
+    }>;
+};
+/** Whether a metric is one the tray's formula card edits: one operation over two operands. */
+export declare function isFormula(metric: AnalysisMetric): metric is Extract<AnalysisMetric, {
+    type: 'NUMERIC';
+}> & {
+    expression: Extract<AnalysisExpression, {
+        type: 'BINARY';
+    }>;
+};
+//# sourceMappingURL=formula.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formula.d.ts","sourceRoot":"","sources":["../../src/analysis/formula.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,oBAAoB,EACpB,yBAAyB,EACzB,kBAAkB,EAClB,0BAA0B,EAC1B,gBAAgB,EAChB,cAAc,EACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAwBxD,eAAO,MAAM,oBAAoB,EAE5B,SAAS,0BAA0B,EAAE,CAAC;AAE3C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,cAAc,EAClB,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,GACzC,MAAM,CAIR;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CACJ,EAAE,EAAE,cAAc,EAClB,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,KACvC,MAAM,GACV,MAAM,CAWR;AAMD,yDAAyD;AACzD,eAAO,MAAM,aAAa,EAAE,QAAQ,CAClC,MAAM,CAAC,0BAA0B,EAAE,MAAM,CAAC,CACe,CAAC;AAE5D,oFAAoF;AACpF,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,gBAAgB,EACpB,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,cAAc,CAYhB;AAED,8EAA8E;AAC9E,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,cAAc,CAWhB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EACjC,MAAM,UAAQ,GACb,MAAM,CAwBR;AAED,gFAAgF;AAChF,wBAAgB,WAAW,CACzB,UAAU,EAAE,yBAAyB,EACrC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,EAClC,MAAM,UAAQ,GACb,MAAM,CAcR;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,oBAAoB,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,cAAc,CAOhB;AAED,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,IAAI,OAAO,CACnE,cAAc,EACd;IAAE,IAAI,EAAE,SAAS,GAAG,YAAY,CAAA;CAAE,CACnC,GAAG;IACF,UAAU,EAAE,OAAO,CAAC,kBAAkB,EAAE;QAAE,IAAI,EAAE,WAAW,CAAA;KAAE,CAAC,CAAC;CAChE,CAKA;AAED,8FAA8F;AAC9F,wBAAgB,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,IAAI,OAAO,CAClE,cAAc,EACd;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CACpB,GAAG;IACF,UAAU,EAAE,OAAO,CAAC,kBAAkB,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC;CAC7D,CAEA"}

package/dist/analysis/funnel.d.ts

@@ -0,0 +1,48 @@
+import { AnalysisViewConfig, RecordData } from '../model/index.js';
+export interface FunnelStage {
+    label: string;
+    value: number;
+    /**
+     * For a stage taken from a dimension, that dimension's value as the rows
+     * hold it — what a press on the stage names the group by (D33 batch C),
+     * the stage's key where no row has it. Absent for a metric's stage, which
+     * is no group.
+     */
+    group?: unknown;
+    /**
+     * This stage against the one before it — 1 for the first stage, nothing
+     * when the one before is 0, where there is nothing to convert from.
+     */
+    conversion?: number;
+    /**
+     * This stage against the first — nothing when the first is 0. The last
+     * stage's is the funnel's overall conversion.
+     */
+    share?: number;
+    /**
+     * What the one before it had and this stage has not: the one before's
+     * value minus this one's — negative where this stage is bigger. Absent on
+     * the first stage, which has nothing before it.
+     */
+    drop?: number;
+}
+export interface FunnelData {
+    type: 'funnel';
+    stages: FunnelStage[];
+    /**
+     * Each stage is "reached at least this stage" — itself and every later
+     * one added up — rather than the stage's own rows, because the spec asked
+     * for it (`FunnelStages.cumulative`). Its values then differ from the
+     * table's, and a drawing that does not say so reads as a wrong number.
+     */
+    cumulative?: true;
+    /**
+     * The stage whose drop from the one before is the largest share of the
+     * one before — the step where the funnel loses the most, the first of
+     * equals. Absent when no stage lost anything, or none can say how much of
+     * what it had (the one before was 0).
+     */
+    largestDrop?: number;
+}
+export declare function shapeFunnel(spec: NonNullable<AnalysisViewConfig['chart']['funnel']>, rows: readonly RecordData[]): FunnelData;
+//# sourceMappingURL=funnel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"funnel.d.ts","sourceRoot":"","sources":["../../src/analysis/funnel.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGxE,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,IAAI,CAAC;IAClB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,WAAW,CACzB,IAAI,EAAE,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,EACxD,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,UAAU,CAmBZ"}

package/dist/analysis/gauge.d.ts

@@ -0,0 +1,34 @@
+import { GaugeSpec, RecordData } from '../model/index.js';
+export interface GaugeData {
+    type: 'gauge';
+    /** The one number, `null` when the row has none. */
+    value: number | null;
+    /** Where it should reach, when the spec names a target. */
+    target?: number;
+    /** The share of the target reached (`value / target`), over a target above 0. */
+    reached?: number;
+    /** The scale's two ends, `min` below `max`. */
+    min: number;
+    max: number;
+    /**
+     * The value lies past an end the spec pinned: the needle stops at that
+     * end, and the drawing says the number is off the scale rather than
+     * letting the needle lie about it.
+     */
+    beyond?: 'above' | 'below';
+}
+/**
+ * A gauge's number and its scale: the one row's value, the spec's target,
+ * and the two ends — the spec's where it pins them, otherwise from 0 (or
+ * the value, when it is below 0) to a round number at or past the value
+ * and the target (`roundUp`), so a needle left to the kernel never runs
+ * off its dial and the target always stands on it.
+ */
+export declare function shapeGauge(spec: GaugeSpec, rows: readonly RecordData[]): GaugeData;
+/**
+ * The round number at or above `value`: one, two, two and a half or five
+ * times a power of ten — 870 becomes 1,000, 1,230 becomes 2,000. A scale
+ * whose end is a round number reads its ticks at a glance.
+ */
+export declare function roundUp(value: number): number;
+//# sourceMappingURL=gauge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gauge.d.ts","sourceRoot":"","sources":["../../src/analysis/gauge.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG/D,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,OAAO,CAAC;IACd,oDAAoD;IACpD,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,SAAS,CA8BX;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ7C"}

package/dist/analysis/granularity.d.ts

@@ -0,0 +1,22 @@
+import { AnalysisDateUnit, AnalysisGroup, FilterTree, RecordData } from '../model/index.js';
+/**
+ * The coarsest offered unit that cuts `span` milliseconds into at least a
+ * handful of buckets, or the finest offered one when nothing does, or the
+ * first offered one when there is no span to read.
+ */
+export declare function recommendDateUnit(span: number | null, offered: readonly AnalysisDateUnit[]): AnalysisDateUnit;
+/**
+ * The span the applied range pins on `field`, in milliseconds, or null when
+ * it pins none. Only the conditions the tree ANDs together count — a
+ * condition under an OR is one alternative, not a bound — and a window
+ * needs both ends: a lower bound alone runs to now, an upper bound alone
+ * says nothing about where the data starts.
+ */
+export declare function rangeSpan(filter: FilterTree, field: string, now: Date, timeZone: string): number | null;
+/**
+ * The span a result already cut on `field`, from its first bucket's start
+ * to its last bucket's end, or null when the result has no time dimension
+ * on the field or no rows.
+ */
+export declare function resultSpan(rows: readonly RecordData[], groups: readonly AnalysisGroup[], field: string, timeZone: string): number | null;
+//# sourceMappingURL=granularity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"granularity.d.ts","sourceRoot":"","sources":["../../src/analysis/granularity.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACb,UAAU,EACV,UAAU,EACX,MAAM,mBAAmB,CAAC;AA4C3B;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,OAAO,EAAE,SAAS,gBAAgB,EAAE,GACnC,gBAAgB,CAUlB;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,IAAI,EACT,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CAKf;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CAgBf"}

package/dist/analysis/having.d.ts

@@ -0,0 +1,38 @@
+import { AnalysisHavingExpression } from '../model/index.js';
+/**
+ * 「只保留」 (D20 屏 B; Wow `having`): the grouped rows kept, said as rows of
+ * one comparison each — 「金额总和 大于 10,000」 — all of which must hold.
+ * Wow's having is a small expression language (conditions, ranges, sets,
+ * null checks, and/or trees); the tray offers the one shape an analyst
+ * reaches for, a conjunction of comparisons, and reads any other shape a
+ * stored config holds as "not editable here" rather than flattening it
+ * into something it is not.
+ */
+/** The comparisons one row may make: the model's, never listed again. */
+export type HavingOperator = Extract<AnalysisHavingExpression, {
+    type: 'CONDITION';
+}>['operator'];
+export declare const HAVING_OPERATORS: readonly HavingOperator[];
+/** One row of the editor: keep the groups whose metric compares so. */
+export interface HavingRow {
+    metric: string;
+    operator: HavingOperator;
+    /** `null` while the row is being filled in. */
+    value: number | null;
+}
+/**
+ * The rows a having expression is made of, or `null` when it is a shape the
+ * rows cannot say: a range, a set, a null check, an OR anywhere. A stored
+ * config may hold those; the editor then shows the expression is there
+ * and offers to clear it, but does not pretend to edit it.
+ */
+export declare function havingRows(having: AnalysisHavingExpression | undefined): HavingRow[] | null;
+/**
+ * The expression the rows say: one condition on its own, several under
+ * one AND, none at all as no having. A row still being filled in — no
+ * value yet — is written as a condition on `NaN` is not: it is left out
+ * of the query and kept only by the editor, so the config on disk is
+ * always one Wow accepts.
+ */
+export declare function withHavingRows(rows: readonly HavingRow[]): AnalysisHavingExpression | undefined;
+//# sourceMappingURL=having.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"having.d.ts","sourceRoot":"","sources":["../../src/analysis/having.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAElE;;;;;;;;GAQG;AAEH,yEAAyE;AACzE,MAAM,MAAM,cAAc,GAAG,OAAO,CAClC,wBAAwB,EACxB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CACtB,CAAC,UAAU,CAAC,CAAC;AAiBd,eAAO,MAAM,gBAAgB,EAExB,SAAS,cAAc,EAAE,CAAC;AAE/B,uEAAuE;AACvE,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,cAAc,CAAC;IACzB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,wBAAwB,GAAG,SAAS,GAC3C,SAAS,EAAE,GAAG,IAAI,CAkBpB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,SAAS,EAAE,GACzB,wBAAwB,GAAG,SAAS,CAmBtC"}

package/dist/analysis/hierarchy.d.ts

@@ -0,0 +1,73 @@
+import { AnalysisViewConfig, HierarchySpec, RecordData, SankeySpec } from '../model/index.js';
+/**
+ * One part of a hierarchy: a value of its level's dimension, its number —
+ * a leaf's own row's, a parent's the sum of its parts — and the group
+ * values from the outermost level down to it.
+ */
+export interface HierarchyNode {
+    /** The group value it stands for, on its own level. */
+    group: unknown;
+    value: number;
+    /** Its own and its parents' group values, by alias: what a press drills. */
+    path: RecordData;
+    /** Its parts, on the next level; left out on the innermost one. */
+    children?: HierarchyNode[];
+}
+export interface HierarchyData {
+    type: 'sunburst' | 'tree';
+    /** The outermost level's parts, each holding the next. */
+    nodes: HierarchyNode[];
+    /** How many levels deep: the spec's levels. */
+    depth: number;
+    /**
+     * How many rows have no size to draw: a number that is not above zero,
+     * which no part of a whole can be. They stay in the table.
+     */
+    omitted: number;
+}
+/**
+ * A sunburst's or a tree's parts: every row a leaf under its parents, one
+ * level a dimension, each parent the sum of its parts; each level laid out
+ * largest first, a date level earliest first.
+ */
+export declare function shapeHierarchy(type: 'sunburst' | 'tree', spec: HierarchySpec, config: AnalysisViewConfig, rows: readonly RecordData[]): HierarchyData;
+/** One node of a sankey: a value of one level's dimension. */
+export interface SankeyNode {
+    /** Which level, from the left: the index into the spec's levels. */
+    level: number;
+    /** The group value it stands for. */
+    group: unknown;
+    /** Its size: the larger of what flows in and what flows out. */
+    value: number;
+}
+/** One band of a sankey, between two nodes of neighbouring levels. */
+export interface SankeyLink {
+    /** Index into `nodes`: where it flows from. */
+    from: number;
+    /** Index into `nodes`: where it flows to. */
+    to: number;
+    value: number;
+}
+export interface SankeyData {
+    type: 'sankey';
+    /** Level by level, each level largest first (a date level earliest first). */
+    nodes: SankeyNode[];
+    /** Largest first. */
+    links: SankeyLink[];
+    omitted: number;
+}
+/**
+ * A sankey's nodes and bands: every row adds its number to the band between
+ * each two neighbouring levels' values; a node is as large as the larger of
+ * what flows in and out. A value that appears on two levels is two nodes —
+ * a flow runs left to right and never back. Rows not above zero are no
+ * band and are counted.
+ */
+export declare function shapeSankey(spec: SankeySpec, config: AnalysisViewConfig, rows: readonly RecordData[]): SankeyData;
+/**
+ * The levels a hierarchy or a flow draws (`fitChartSlots`): the ones the
+ * spec lists that are still dimensions, in its order — the analyst's — and
+ * every other dimension after them, since a chart consumes every group.
+ */
+export declare function chartLevels(listed: readonly string[] | undefined, groups: readonly string[]): string[];
+//# sourceMappingURL=hierarchy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hierarchy.d.ts","sourceRoot":"","sources":["../../src/analysis/hierarchy.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,UAAU,EACX,MAAM,mBAAmB,CAAC;AAI3B;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,uDAAuD;IACvD,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,IAAI,EAAE,UAAU,CAAC;IACjB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;IAC1B,0DAA0D;IAC1D,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAqBD;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,GAAG,MAAM,EACzB,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,aAAa,CAyCf;AAED,8DAA8D;AAC9D,MAAM,WAAW,UAAU;IACzB,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;CACf;AAED,sEAAsE;AACtE,MAAM,WAAW,UAAU;IACzB,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,8EAA8E;IAC9E,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,qBAAqB;IACrB,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,UAAU,CA0DZ;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EACrC,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,MAAM,EAAE,CAKV"}

package/dist/analysis/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The analysis kernel. The configuration is isomorphic to Wow's aggregation
+ * protocol, so compilation is a mapping and the interesting work is admission
+ * and the shaping each chart family needs.
+ */
+export * from './bucketChange.js';
+export * from './candidates.js';
+export * from './capability.js';
+export * from './chart.js';
+export * from './chartFamilies.js';
+export * from './chartOptions.js';
+export * from './chartSlots.js';
+export * from './chartSwitch.js';
+export * from './compile.js';
+export * from './defaults.js';
+export { bucketRange, drillConditions, drillGroups, focusOn, groupFor, splitBy, wallClockAt, type BucketRange, type DrillContext, type DrilledGroup, } from './drill.js';
+export { drillFilter, narrowsTo } from './drillFilter.js';
+export * from './fitCharts.js';
+export * from './formula.js';
+export * from './expand.js';
+export * from './granularity.js';
+export * from './having.js';
+export * from './metricCondition.js';
+export { columnsAfterMove, moveMetric, type MetricMove, type MetricMoveStop, } from './metricOrder.js';
+export { formulaFormat, metricFieldOf, metricFormat, metricFunctionOf, metricMeasure, metricMeasures, momentMetrics, readsAsItsField, type MetricFunction, } from './metricFormat.js';
+export * from './project.js';
+export * from './validate.js';
+export { isAdditiveMetric, isChartColor, validateChart, } from './validateChart.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/analysis/index.ts"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAG9B,OAAO,EACL,WAAW,EACX,eAAe,EACf,WAAW,EACX,OAAO,EACP,QAAQ,EACR,OAAO,EACP,WAAW,EACX,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC1D,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,OAAO,EACL,gBAAgB,EAChB,UAAU,EACV,KAAK,UAAU,EACf,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,aAAa,EACb,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,aAAa,EACb,eAAe,EACf,KAAK,cAAc,GACpB,MAAM,mBAAmB,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,aAAa,GACd,MAAM,oBAAoB,CAAC"}

package/dist/analysis/logScale.d.ts

@@ -0,0 +1,20 @@
+import { CartesianSpec } from '../model/index.js';
+import { CartesianData } from './cartesian.js';
+/**
+ * Whether a log scale can carry these numbers (D33 batch E): every one of
+ * them above zero. A log axis steps by powers of ten and has no place for 0
+ * or a negative number — the library drops such a mark without a word — so
+ * over values that hold one the choice is greyed with why, and a saved log
+ * scale is drawn linear and says so. A value not measured is no number and
+ * is not judged; nor is an axis with none, which has nothing to misdraw.
+ *
+ * Internal: the options page and the renderers read it off this module.
+ */
+export declare function logScaleFits(values: readonly (number | null | undefined)[]): boolean;
+/**
+ * The numbers one value axis of a cartesian chart measures: every point of
+ * every series the spec puts on that side, a filled-in 0 among them — it is
+ * drawn at 0, which a log axis has no place for either.
+ */
+export declare function cartesianAxisValues(data: CartesianData, spec: CartesianSpec | undefined, side: 'left' | 'right'): (number | null)[];
+//# sourceMappingURL=logScale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logScale.d.ts","sourceRoot":"","sources":["../../src/analysis/logScale.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GAC7C,OAAO,CAET;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,aAAa,GAAG,SAAS,EAC/B,IAAI,EAAE,MAAM,GAAG,OAAO,GACrB,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAcnB"}

package/dist/analysis/map.d.ts

@@ -0,0 +1,28 @@
+import { MapSpec, RecordData } from '../model/index.js';
+/** One region of a map: a value of the region dimension and its number. */
+export interface MapRegion {
+    /** The group value it stands for. */
+    group: unknown;
+    value: number;
+}
+export interface MapData {
+    type: 'map';
+    /** The measured regions, largest first — the order the reading lists them. */
+    regions: MapRegion[];
+    /** The smallest and the largest measured number: the colour scale's ends. */
+    low: number;
+    high: number;
+    /**
+     * How many rows have no number: a region with nothing measured is no
+     * shade, and is left out rather than drawn as 0.
+     */
+    omitted: number;
+}
+/**
+ * A map's regions: each row a region and its number, largest first. Which of
+ * them the map has an area for is the map's to say, and the drawing counts
+ * the ones it could not place (`drawnRegions` in `/ui`); the scale's ends
+ * are measured regions only, never a 0 written in.
+ */
+export declare function shapeMap(spec: MapSpec, rows: readonly RecordData[]): MapData;
+//# sourceMappingURL=map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/analysis/map.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG7D,2EAA2E;AAC3E,MAAM,WAAW,SAAS;IACxB,qCAAqC;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,KAAK,CAAC;IACZ,8EAA8E;IAC9E,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,6EAA6E;IAC7E,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,UAAU,EAAE,GAAG,OAAO,CAiB5E"}