nuxt-charts 3.0.0 → 3.1.0

package/dist/runtime/maps.d.ts

@@ -0,0 +1,2 @@
+export { getMap, getPin } from "./utils/dottedMap.js";
+export type * from "./types/maps";

package/dist/runtime/maps.js

@@ -0,0 +1 @@
+export { getMap, getPin } from "./utils/dottedMap.js";

package/dist/runtime/spec/csv.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CSV serialization for aggregated chart data.
+ *
+ * Kept in the data layer rather than the component so a server route can emit
+ * the same file the download button produces.
+ */
+import type { SpecDatum } from "./types.js";
+/**
+ * Render aggregated data as a CSV document.
+ *
+ * `headers` maps each series key to its display label, so the export carries
+ * the same column names the legend shows rather than internal keys.
+ */
+export declare function toCsv(data: readonly SpecDatum[], series: readonly string[], headers?: Record<string, string>, xHeader?: string): string;

package/dist/runtime/spec/csv.js

@@ -0,0 +1,13 @@
+function escapeField(value) {
+  if (value === null || value === void 0) return "";
+  let text = String(value);
+  if (/^[=+\-@]/.test(text)) text = `'${text}`;
+  return /[",\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+export function toCsv(data, series, headers = {}, xHeader = "x") {
+  const columns = [xHeader, ...series.map((key) => headers[key] ?? key)];
+  const rows = data.map(
+    (datum) => [datum.x, ...series.map((key) => datum[key])].map(escapeField).join(",")
+  );
+  return [columns.map(escapeField).join(","), ...rows].join("\n");
+}

package/dist/runtime/spec/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The data layer: chart specifications and the transform that runs them.
+ *
+ * Importable on its own (`nuxt-charts/spec`) so the same aggregation can run in
+ * a server route, a test, or a build step without pulling in Vue components.
+ */
+export * from "./types.js";
+export * from "./transform.js";
+export * from "./resolve.js";
+export * from "./csv.js";
+export * from "./metric.js";

package/dist/runtime/spec/index.js

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./transform.js";
+export * from "./resolve.js";
+export * from "./csv.js";
+export * from "./metric.js";

package/dist/runtime/spec/metric.d.ts

@@ -0,0 +1,130 @@
+/**
+ * The metric layer: the small amount of logic that sits between "a business
+ * question" and a {@link ChartSpec}.
+ *
+ * Everything here is a pure function, for the same reason the transform stage
+ * is: a metric's value formatting and its time window are things a server
+ * route, a test, or a summary email may need without mounting a component.
+ *
+ * The division of labour is deliberate. This module decides *what window to
+ * ask for* and *how to render a number*; the transform decides *what the
+ * numbers are*. `<MetricChart>` composes the two and draws the chrome.
+ */
+import type { ChartSpec, SpecAggregate, SpecChartType, SpecInterval } from "./types.js";
+/**
+ * How a metric's values are rendered as text.
+ *
+ * A closed union rather than a formatter function, so a metric definition
+ * stays serializable alongside the spec it produces. A caller needing
+ * something else passes their own function through `valueFormatter`.
+ */
+export type MetricFormat = "number" | "currency" | "percent" | "compact" | "duration";
+/**
+ * A selectable time window.
+ *
+ * `days` drives the range arithmetic; `interval` is the bucket width that
+ * keeps the chart readable at that span — 7 days of monthly buckets would be
+ * a single point, and a year of daily buckets is 365 marks of noise.
+ */
+export interface MetricRange {
+    /** Stable key, used as the selector's value and `v-model`. */
+    key: string;
+    /** Short label for the selector button (`30D`). */
+    label: string;
+    /** Accessible name, since `30D` alone does not read well aloud. */
+    title?: string;
+    /** Window length in days, counting back from the anchor date. */
+    days: number;
+    /** Bucket width for this window. */
+    interval: SpecInterval;
+}
+/**
+ * The default range set: a week, a month, a quarter, a year.
+ *
+ * These four cover the overwhelming majority of dashboard use, and their
+ * intervals are chosen so every window lands between roughly 7 and 90 marks —
+ * enough shape to read a trend, few enough to stay legible.
+ */
+export declare const DEFAULT_RANGES: readonly MetricRange[];
+/**
+ * The `{ from, to }` window for a range, counting back from an anchor date.
+ *
+ * Anchored in UTC to match the transform's bucketing: a window computed in
+ * local time can start a day either side of the buckets it is meant to select,
+ * which silently drops or doubles an edge bucket.
+ *
+ * The window is inclusive at both ends, so a 7-day range covers today plus the
+ * six days before it — what "last 7 days" means to a reader, rather than the
+ * eight days a naive `to - 7` would select.
+ */
+export declare function resolveRange(range: Pick<MetricRange, "days">, anchor?: string | number | Date): {
+    from: string;
+    to: string;
+};
+/** Inputs a metric needs to describe itself as a spec. */
+export interface MetricSpecInput {
+    type: SpecChartType;
+    x: string;
+    y?: string;
+    series?: string;
+    aggregate?: SpecAggregate;
+    interval: SpecInterval;
+    compare?: ChartSpec["compare"];
+    range: {
+        from: string;
+        to: string;
+    };
+    label?: string;
+}
+/**
+ * Assemble a {@link ChartSpec} from a metric's props.
+ *
+ * Trivial by design: the value of `<MetricChart>` is that it *produces* a
+ * spec rather than reimplementing aggregation, and keeping that assembly in
+ * one named function makes the boundary visible — and testable without Vue.
+ */
+export declare function metricSpec(input: MetricSpecInput): ChartSpec;
+/** Options for {@link formatMetricValue}. */
+export interface MetricFormatOptions {
+    format?: MetricFormat;
+    /** ISO 4217 code, used only by the `currency` format. Default `EUR`. */
+    currency?: string;
+    locale?: string;
+    /** Overrides the format's own defaults (`maximumFractionDigits`, …). */
+    options?: Intl.NumberFormatOptions;
+}
+/**
+ * Render a metric value as display text.
+ *
+ * Each format carries the fraction-digit defaults that suit it, because the
+ * right precision is a property of what the number *means*: money shows whole
+ * units on a headline, a rate needs a decimal to show movement at all, and a
+ * compact number's whole point is brevity.
+ *
+ * `percent` takes a value already in percent units (`4.8` -> `4.8%`), not the
+ * `0.048` fraction `Intl`'s percent style expects. Metric fields hold rates as
+ * humans record them, and silently multiplying by 100 surprises every caller
+ * whose column is already a percentage.
+ */
+export declare function formatMetricValue(value: number, { format, currency, locale, options }?: MetricFormatOptions): string;
+/**
+ * Render a fractional change (`0.124`) as a signed percentage (`+12.4%`).
+ *
+ * Signed explicitly, including the `+`, because a delta's direction is the
+ * first thing read and an unsigned `12.4%` beside a total is ambiguous.
+ */
+export declare function formatChange(change: number | undefined, locale?: string): string | undefined;
+/**
+ * Which way a delta should read.
+ *
+ * `direction` is the arithmetic sign; `sentiment` is whether that sign is good
+ * news, which is not the same question. For latency, error rates or churn, a
+ * fall is the win — so the colour is driven by `sentiment` and the arrow by
+ * `direction`, and `inverse` flips only the former.
+ */
+export interface MetricDelta {
+    direction: "up" | "down" | "flat";
+    sentiment: "positive" | "negative" | "neutral";
+}
+/** Classify a change into an arrow direction and a sentiment. */
+export declare function metricDelta(change: number | undefined, inverse?: boolean): MetricDelta;

package/dist/runtime/spec/metric.js

@@ -0,0 +1,63 @@
+export const DEFAULT_RANGES = [
+  { key: "7d", label: "7D", title: "Last 7 days", days: 7, interval: "day" },
+  { key: "30d", label: "30D", title: "Last 30 days", days: 30, interval: "day" },
+  { key: "3m", label: "3M", title: "Last 3 months", days: 90, interval: "week" },
+  { key: "1y", label: "1Y", title: "Last 12 months", days: 365, interval: "month" }
+];
+const DAY_MS = 864e5;
+export function resolveRange(range, anchor) {
+  const now = anchor === void 0 ? Date.now() : new Date(anchor).getTime();
+  const end = Number.isFinite(now) ? now : Date.now();
+  const date = new Date(end);
+  const to = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+  const from = to - (Math.max(1, Math.round(range.days)) - 1) * DAY_MS;
+  return { from: isoDate(from), to: isoDate(to) };
+}
+function isoDate(time) {
+  return new Date(time).toISOString().slice(0, 10);
+}
+export function metricSpec(input) {
+  return {
+    type: input.type,
+    dimensions: { x: input.x, y: input.y, series: input.series },
+    transform: { interval: input.interval, aggregate: input.aggregate ?? "sum" },
+    range: input.range,
+    // A series split and a comparison both claim the series dimension; the
+    // transform resolves that in favour of the split, so asking for both here
+    // would render a chart whose legend contradicts the header's "vs previous".
+    compare: input.series ? void 0 : input.compare,
+    label: input.label
+  };
+}
+export function formatMetricValue(value, { format = "number", currency = "EUR", locale, options } = {}) {
+  if (!Number.isFinite(value)) return "\u2014";
+  if (format === "duration") return formatDuration(value, locale, options);
+  const defaults = format === "currency" ? { style: "currency", currency, maximumFractionDigits: 0 } : format === "percent" ? { maximumFractionDigits: 1 } : format === "compact" ? { notation: "compact", maximumFractionDigits: 1 } : { maximumFractionDigits: 0 };
+  const text = new Intl.NumberFormat(locale, { ...defaults, ...options }).format(value);
+  return format === "percent" ? `${text}%` : text;
+}
+function formatDuration(value, locale, options) {
+  const abs = Math.abs(value);
+  const [scaled, unit, digits] = abs < 1e3 ? [value, "ms", 0] : abs < 6e4 ? [value / 1e3, "s", 1] : [value / 6e4, "min", 1];
+  const text = new Intl.NumberFormat(locale, {
+    maximumFractionDigits: digits,
+    ...options
+  }).format(scaled);
+  return `${text}${unit}`;
+}
+export function formatChange(change, locale) {
+  if (change === void 0 || !Number.isFinite(change)) return void 0;
+  return new Intl.NumberFormat(locale, {
+    style: "percent",
+    maximumFractionDigits: 1,
+    signDisplay: "exceptZero"
+  }).format(change);
+}
+export function metricDelta(change, inverse = false) {
+  if (change === void 0 || !Number.isFinite(change) || change === 0) {
+    return { direction: "flat", sentiment: "neutral" };
+  }
+  const direction = change > 0 ? "up" : "down";
+  const good = inverse ? change < 0 : change > 0;
+  return { direction, sentiment: good ? "positive" : "negative" };
+}

package/dist/runtime/spec/resolve.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Spec -> renderer props.
+ *
+ * The transform stage decides *what the numbers are*; this stage decides *what
+ * the chart component is handed*. Separating them keeps the chart adapters
+ * unchanged — `DataChart` produces exactly the `categories` / `xAxis` / `yAxis`
+ * props a hand-written `<LineChart>` would have received.
+ */
+import type { BulletLegendItemInterface } from "../types/shared.js";
+import { type ChartSpec, type SpecInterval } from "./types.js";
+/**
+ * Human-readable label for a series key.
+ *
+ * The synthetic keys get prose; a `series`-split value is already a real label
+ * (a plan name, a region) and is left exactly as the data spelled it.
+ */
+export declare function seriesLabel(key: string, spec: ChartSpec): string;
+/** `createdAt` / `created_at` / `created-at` -> `Created at`. */
+export declare function titleCase(field: string): string;
+/**
+ * Build the `categories` record the chart adapters expect.
+ *
+ * The comparison series is deliberately not given a colour: leaving it
+ * undefined lets `categoriesToSeries` assign the next `--vc-series-*` token,
+ * so a baseline picks up the host theme like any other series instead of
+ * hardcoding a grey that fights the design system in dark mode.
+ */
+export declare function specCategories(series: readonly string[], spec: ChartSpec): Record<string, BulletLegendItemInterface>;
+/**
+ * Format a bucket key (`2026-03-01`) for the x axis.
+ *
+ * Buckets are UTC-anchored, so the formatter is pinned to UTC as well —
+ * otherwise a viewer west of Greenwich sees every month labelled as the
+ * previous one.
+ */
+export declare function formatBucket(key: string, interval: SpecInterval | undefined, locale?: string): string;
+/**
+ * Validate a spec, returning a human-readable reason when it cannot render.
+ *
+ * Specs are expected to arrive from outside the codebase — a database row, an
+ * API response, eventually a model — so the failure mode has to be a message
+ * the caller can show, not a thrown exception mid-render.
+ */
+export declare function validateSpec(spec: ChartSpec | undefined): string | undefined;

package/dist/runtime/spec/resolve.js

@@ -0,0 +1,41 @@
+import { COMPARE_KEY, VALUE_KEY } from "./types.js";
+export function seriesLabel(key, spec) {
+  if (key === COMPARE_KEY) {
+    return spec.compare === "previous-year" ? "Previous year" : "Previous period";
+  }
+  if (key === VALUE_KEY) {
+    return spec.label ?? titleCase(spec.dimensions.y ?? "Count");
+  }
+  return key;
+}
+export function titleCase(field) {
+  const spaced = field.replace(/[_-]+/g, " ").replace(/([a-z\d])([A-Z])/g, "$1 $2").trim();
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+export function specCategories(series, spec) {
+  return Object.fromEntries(
+    series.map((key) => [key, { name: seriesLabel(key, spec) }])
+  );
+}
+export function formatBucket(key, interval, locale) {
+  if (!interval) return key;
+  const time = Date.parse(key);
+  if (!Number.isFinite(time)) return key;
+  const options = interval === "month" ? { month: "short", year: "2-digit", timeZone: "UTC" } : { month: "short", day: "numeric", timeZone: "UTC" };
+  return new Intl.DateTimeFormat(locale, options).format(new Date(time));
+}
+export function validateSpec(spec) {
+  if (!spec) return "No chart spec provided.";
+  if (!spec.dimensions?.x) return "Chart spec is missing `dimensions.x`.";
+  const aggregate = spec.transform?.aggregate ?? "sum";
+  if (aggregate !== "count" && !spec.dimensions.y) {
+    return `Chart spec needs \`dimensions.y\` for the \`${aggregate}\` aggregate.`;
+  }
+  if (spec.compare && !spec.range) {
+    return "Chart spec needs a `range` to compare against a previous period.";
+  }
+  if (spec.compare && !spec.transform?.interval) {
+    return "Chart spec needs `transform.interval` to align a comparison series.";
+  }
+  return void 0;
+}

package/dist/runtime/spec/transform.d.ts

@@ -0,0 +1,58 @@
+import { type ChartSpec, type SpecAggregate, type SpecDatum, type SpecInterval } from "./types.js";
+/**
+ * Parse a value into a timestamp, accepting the shapes application data
+ * actually arrives in: `Date`, epoch milliseconds, or an ISO-ish string.
+ *
+ * Returns `undefined` rather than `NaN` so callers can treat "not a date" as
+ * a category instead of having to guard every arithmetic use.
+ */
+export declare function toTimestamp(value: unknown): number | undefined;
+/**
+ * Snap a timestamp down to the start of its bucket, in UTC.
+ *
+ * Weeks start Monday (ISO-8601), so `getUTCDay()`'s Sunday-as-0 is remapped:
+ * Sunday belongs to the week that began six days earlier, not the one starting
+ * the next day.
+ */
+export declare function floorToInterval(time: number, interval: SpecInterval): number;
+/** Step one bucket forward. Months step calendar-wise, not by a fixed 30 days. */
+export declare function nextBucket(time: number, interval: SpecInterval): number;
+/**
+ * Canonical key for a bucket: the ISO date of its first day (`2026-03-01`).
+ *
+ * A sortable, stable string rather than a formatted label, because it doubles
+ * as the grouping key and as the join key that aligns a comparison series with
+ * the current one. Display formatting happens later, at the axis.
+ */
+export declare function bucketKey(time: number, interval: SpecInterval): string;
+/** Collapse a list of numbers per the requested aggregate. */
+export declare function aggregateValues(values: readonly number[], aggregate: SpecAggregate): number;
+/** Step one bucket backwards. Mirrors {@link nextBucket}. */
+export declare function previousBucket(time: number, interval: SpecInterval): number;
+/** Result of running a spec over rows: the chart data plus what it summarises. */
+export interface TransformResult {
+    /** Aggregated rows, one per x bucket, ready to hand to a chart component. */
+    data: SpecDatum[];
+    /** Series keys present in `data`, in render order. */
+    series: string[];
+    /** Total of the primary series over the window. */
+    total: number;
+    /** Total of the comparison series, when the spec asked for one. */
+    compareTotal?: number;
+    /**
+     * Fractional change from `compareTotal` to `total` (`0.124` = up 12.4%).
+     *
+     * `undefined` when there is no comparison, and when the baseline is zero —
+     * growth from nothing has no meaningful percentage, and reporting `Infinity`
+     * or a bare `100%` would both be lies.
+     */
+    change?: number;
+}
+/**
+ * Run a spec over rows and return the aggregated chart data.
+ *
+ * The single entry point for the data layer. Its output is deliberately plain:
+ * an array of flat records plus the series keys that index them, which is the
+ * exact shape the existing chart adapters already consume.
+ */
+export declare function transform<T>(rows: readonly T[], spec: ChartSpec): TransformResult;

package/dist/runtime/spec/transform.js

@@ -0,0 +1,199 @@
+import { toFiniteNumber } from "../utils/data.js";
+import {
+  COMPARE_KEY,
+  VALUE_KEY
+} from "./types.js";
+const DAY_MS = 864e5;
+export function toTimestamp(value) {
+  if (value instanceof Date) {
+    const time2 = value.getTime();
+    return Number.isFinite(time2) ? time2 : void 0;
+  }
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (typeof value !== "string" || value === "") return void 0;
+  const time = Date.parse(value);
+  return Number.isFinite(time) ? time : void 0;
+}
+export function floorToInterval(time, interval) {
+  const date = new Date(time);
+  if (interval === "month") {
+    return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1);
+  }
+  const midnight = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+  if (interval === "day") return midnight;
+  const dayOfWeek = (new Date(midnight).getUTCDay() + 6) % 7;
+  return midnight - dayOfWeek * DAY_MS;
+}
+export function nextBucket(time, interval) {
+  if (interval === "month") {
+    const date = new Date(time);
+    return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1);
+  }
+  return time + (interval === "week" ? 7 * DAY_MS : DAY_MS);
+}
+export function bucketKey(time, interval) {
+  return new Date(floorToInterval(time, interval)).toISOString().slice(0, 10);
+}
+export function aggregateValues(values, aggregate) {
+  if (aggregate === "count") return values.length;
+  if (values.length === 0) return 0;
+  switch (aggregate) {
+    case "average":
+      return values.reduce((sum, value) => sum + value, 0) / values.length;
+    case "min":
+      return Math.min(...values);
+    case "max":
+      return Math.max(...values);
+    default:
+      return values.reduce((sum, value) => sum + value, 0);
+  }
+}
+function fieldOf(row, field) {
+  return row?.[field];
+}
+function aggregateRows(rows, xField, yField, aggregate, interval) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const rawX = fieldOf(row, xField);
+    if (rawX === null || rawX === void 0 || rawX === "") continue;
+    let key;
+    if (interval) {
+      const time = toTimestamp(rawX);
+      if (time === void 0) continue;
+      key = bucketKey(time, interval);
+    } else {
+      key = String(rawX);
+    }
+    const value = yField === void 0 ? void 0 : toFiniteNumber(fieldOf(row, yField));
+    if (aggregate !== "count" && value === void 0) continue;
+    const bucket = groups.get(key) ?? [];
+    bucket.push(value ?? 0);
+    groups.set(key, bucket);
+  }
+  return new Map(
+    [...groups].map(([key, values]) => [key, aggregateValues(values, aggregate)])
+  );
+}
+const MAX_FILLED_BUCKETS = 5e3;
+function bucketRange(from, to, interval) {
+  const keys = [];
+  let cursor = floorToInterval(from, interval);
+  while (cursor <= to && keys.length < MAX_FILLED_BUCKETS) {
+    keys.push(bucketKey(cursor, interval));
+    cursor = nextBucket(cursor, interval);
+  }
+  return keys;
+}
+function compareBucketKeys(currentKeys, interval, compare) {
+  if (compare === "previous-year") {
+    return currentKeys.map((key) => {
+      const date = new Date(Date.parse(key));
+      return bucketKey(
+        Date.UTC(date.getUTCFullYear() - 1, date.getUTCMonth(), date.getUTCDate()),
+        interval
+      );
+    });
+  }
+  let cursor = Date.parse(currentKeys[0] ?? "");
+  if (!Number.isFinite(cursor)) return [];
+  const back = [];
+  for (let i = 0; i < currentKeys.length; i += 1) {
+    cursor = previousBucket(cursor, interval);
+    back.unshift(cursor);
+  }
+  return back.map((time) => bucketKey(time, interval));
+}
+export function previousBucket(time, interval) {
+  if (interval === "month") {
+    const date = new Date(time);
+    return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() - 1, 1);
+  }
+  return time - (interval === "week" ? 7 * DAY_MS : DAY_MS);
+}
+function resolveRange(spec) {
+  if (!spec.range) return void 0;
+  const from = toTimestamp(spec.range.from);
+  const to = toTimestamp(spec.range.to);
+  if (from === void 0 || to === void 0 || from > to) return void 0;
+  return [from, to];
+}
+function rowsInWindow(rows, xField, [from, to]) {
+  return rows.filter((row) => {
+    const time = toTimestamp(fieldOf(row, xField));
+    return time !== void 0 && time >= from && time <= to;
+  });
+}
+export function transform(rows, spec) {
+  const { x: xField, y: yField, series: seriesField } = spec.dimensions;
+  const aggregate = spec.transform?.aggregate ?? "sum";
+  const interval = spec.transform?.interval;
+  const fillGaps = spec.transform?.fillGaps ?? true;
+  const range = resolveRange(spec);
+  const compare = seriesField ? void 0 : spec.compare;
+  const windowed = range ? rowsInWindow(rows, xField, range) : [...rows];
+  const partitions = /* @__PURE__ */ new Map();
+  if (seriesField) {
+    for (const row of windowed) {
+      const raw = fieldOf(row, seriesField);
+      const key = raw === null || raw === void 0 || raw === "" ? "unknown" : String(raw);
+      const bucket = partitions.get(key) ?? [];
+      bucket.push(row);
+      partitions.set(key, bucket);
+    }
+  } else {
+    partitions.set(VALUE_KEY, windowed);
+  }
+  const aggregated = /* @__PURE__ */ new Map();
+  for (const [key, partitionRows] of partitions) {
+    aggregated.set(key, aggregateRows(partitionRows, xField, yField, aggregate, interval));
+  }
+  let compareByKey;
+  if (compare && range && interval) {
+    const currentKeys = bucketRange(range[0], range[1], interval);
+    const shiftedKeys = compareBucketKeys(currentKeys, interval, compare);
+    const span = shiftedKeys.length ? [Date.parse(shiftedKeys[0]), nextBucket(Date.parse(shiftedKeys.at(-1)), interval) - 1] : void 0;
+    const compareRows = span ? rowsInWindow(rows, xField, [span[0], span[1]]) : [];
+    const raw = aggregateRows(compareRows, xField, yField, aggregate, interval);
+    compareByKey = /* @__PURE__ */ new Map();
+    currentKeys.forEach((key, index) => {
+      const source = shiftedKeys[index];
+      if (source !== void 0) compareByKey.set(key, raw.get(source) ?? 0);
+    });
+  }
+  const keys = /* @__PURE__ */ new Set();
+  if (interval && fillGaps && range) {
+    for (const key of bucketRange(range[0], range[1], interval)) keys.add(key);
+  }
+  for (const buckets of aggregated.values()) {
+    for (const key of buckets.keys()) keys.add(key);
+  }
+  const seriesKeys = [...aggregated.keys()];
+  let ordered = [...keys];
+  const sort = spec.transform?.sort ?? (interval ? "asc" : "none");
+  if (sort !== "none") {
+    const totalFor = (key) => seriesKeys.reduce((sum, series) => sum + (aggregated.get(series)?.get(key) ?? 0), 0);
+    ordered = interval ? ordered.sort((a, b) => sort === "asc" ? a.localeCompare(b) : b.localeCompare(a)) : ordered.sort((a, b) => sort === "asc" ? totalFor(a) - totalFor(b) : totalFor(b) - totalFor(a));
+  }
+  if (spec.transform?.limit !== void 0 && spec.transform.limit > 0) {
+    ordered = ordered.slice(0, Math.floor(spec.transform.limit));
+  }
+  const data = ordered.map((key) => {
+    const datum = { x: key };
+    for (const series of seriesKeys) {
+      const value = aggregated.get(series)?.get(key);
+      datum[series] = value ?? (interval && fillGaps ? 0 : void 0);
+    }
+    if (compareByKey) datum[COMPARE_KEY] = compareByKey.get(key) ?? 0;
+    return datum;
+  });
+  const sumOf = (series) => data.reduce((sum, datum) => sum + (toFiniteNumber(datum[series]) ?? 0), 0);
+  const total = seriesKeys.reduce((sum, series) => sum + sumOf(series), 0);
+  const compareTotal = compareByKey ? sumOf(COMPARE_KEY) : void 0;
+  return {
+    data,
+    series: compareByKey ? [...seriesKeys, COMPARE_KEY] : seriesKeys,
+    total,
+    compareTotal,
+    change: compareTotal === void 0 || compareTotal === 0 ? void 0 : (total - compareTotal) / compareTotal
+  };
+}