drizzle-cube 0.6.0 → 0.6.2

package/dist/cjs/client/components/charts/RetentionHeatmap.config.d.ts

@@ -0,0 +1,2 @@
+import { ChartTypeConfig } from '../../charts/chartConfigs.js';
+export declare const retentionHeatmapConfig: ChartTypeConfig;

package/dist/cjs/client/components/charts/RetentionHeatmap.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { ChartProps } from '../../types.js';
+/**
+ * RetentionHeatmap Component
+ */
+declare const RetentionHeatmap: React.NamedExoticComponent<ChartProps>;
+export default RetentionHeatmap;

package/dist/cjs/client/components/charts/SankeyChart.config.d.ts

@@ -0,0 +1,9 @@
+import { ChartTypeConfig } from '../../charts/chartConfigs.js';
+/**
+ * Configuration for the sankey chart type
+ *
+ * Sankey charts visualize flow data between nodes.
+ * They work with data from flow queries which provide
+ * nodes and links representing user journeys.
+ */
+export declare const sankeyChartConfig: ChartTypeConfig;

package/dist/cjs/client/components/charts/SankeyChart.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { ChartProps } from '../../types.js';
+/**
+ * SankeyChart Component
+ *
+ * Renders a Sankey diagram visualization from FlowChartData.
+ * Shows flow paths with nodes at each layer and links between them.
+ */
+declare const SankeyChart: React.NamedExoticComponent<ChartProps>;
+export default SankeyChart;

package/dist/cjs/client/components/charts/ScatterChart.config.d.ts

@@ -0,0 +1,5 @@
+import { ChartTypeConfig } from '../../charts/chartConfigs.js';
+/**
+ * Configuration for the scatter chart type
+ */
+export declare const scatterChartConfig: ChartTypeConfig;

package/dist/cjs/client/components/charts/ScatterChart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChartProps } from '../../types.js';
+declare const ScatterChart: React.NamedExoticComponent<ChartProps>;
+export default ScatterChart;

package/dist/cjs/client/components/charts/ScatterChart.helpers.d.ts

@@ -0,0 +1,43 @@
+import { CHART_MARGINS } from '../../utils/chartConstants.js';
+import { AxisFormatConfig, ChartAxisConfig, ChartDisplayConfig, CubeQuery } from '../../types.js';
+export interface ScatterRenderState {
+    showLegend: boolean;
+    showGrid: boolean;
+    showTooltip: boolean;
+    /** Whether to render one Scatter per series group vs a single series. */
+    hasSeries: boolean;
+    xAxisFormat?: AxisFormatConfig;
+    /** For scatter charts the y-axis uses the left-axis format config. */
+    yAxisFormat?: AxisFormatConfig;
+    chartMargins: typeof CHART_MARGINS;
+}
+/**
+ * Resolve all render-time display flags, axis formats and margins for the
+ * scatter chart from the display config and the transformed series keys.
+ */
+export declare function resolveScatterRenderState(displayConfig: ChartDisplayConfig | undefined, seriesKeys: string[]): ScatterRenderState;
+export interface ScatterAxisFields {
+    xAxisField: string;
+    yAxisField: string;
+    seriesFields: string[];
+    /** Set when the config is invalid (no usable axis fields). */
+    errorCode?: 'axisInvalid' | 'axisFields';
+}
+/** Resolve x/y/series fields supporting both the new and legacy config shapes. */
+export declare function resolveScatterAxisFields(chartConfig: ChartAxisConfig | undefined): ScatterAxisFields;
+export interface ScatterPoint {
+    x: number;
+    y: number;
+    name: string;
+    timeValues: Record<string, string>;
+    originalItem: Record<string, any>;
+}
+export interface ScatterTransform {
+    scatterData: ScatterPoint[];
+    seriesGroups: Record<string, ScatterPoint[]>;
+}
+/**
+ * Transform rows into scatter points, grouping by series when configured.
+ * Null x/y coordinates are filtered out. Mirrors the original two-branch logic.
+ */
+export declare function transformScatterData(data: Record<string, any>[], xAxisField: string, yAxisField: string, seriesFields: string[], timeDimensionFields: string[], queryObject: CubeQuery | undefined): ScatterTransform;

package/dist/cjs/client/components/charts/ScatterSeries.d.ts

@@ -0,0 +1,17 @@
+import { ColorPalette } from '../../types.js';
+import { ScatterPoint } from './ScatterChart.helpers.js';
+interface ScatterSeriesProps {
+    hasSeries: boolean;
+    seriesKeys: string[];
+    seriesGroups: Record<string, ScatterPoint[]>;
+    scatterData: ScatterPoint[];
+    colorPalette?: ColorPalette;
+    hoveredLegend: string | null;
+}
+/**
+ * Renders the `<Scatter>` series for ScatterChart — one per series group when
+ * `hasSeries`, otherwise a single series. Returned as a fragment so it composes
+ * inside the Recharts chart children. Behaviour matches the original inline JSX.
+ */
+export declare function ScatterSeries({ hasSeries, seriesKeys, seriesGroups, scatterData, colorPalette, hoveredLegend }: ScatterSeriesProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/charts/ScatterTooltip.d.ts

@@ -0,0 +1,21 @@
+import { AxisFormatConfig } from '../../types.js';
+import { ScatterPoint } from './ScatterChart.helpers.js';
+interface ScatterTooltipProps {
+    active?: boolean;
+    payload?: Array<{
+        payload?: ScatterPoint;
+    }>;
+    xAxisField: string;
+    yAxisField: string;
+    xAxisFormat?: AxisFormatConfig;
+    yAxisFormat?: AxisFormatConfig;
+    getFieldLabel: (field: string) => string;
+}
+/**
+ * Custom Recharts tooltip content for ScatterChart.
+ *
+ * Extracted from the inline `content` render prop to keep the chart body lean.
+ * Renders the point name, any time-dimension values, and the formatted x/y.
+ */
+export declare function ScatterTooltip({ active, payload, xAxisField, yAxisField, xAxisFormat, yAxisFormat, getFieldLabel }: ScatterTooltipProps): import("react").JSX.Element | null;
+export {};

package/dist/cjs/client/components/charts/SunburstChart.config.d.ts

@@ -0,0 +1,9 @@
+import { ChartTypeConfig } from '../../charts/chartConfigs.js';
+/**
+ * Configuration for the sunburst chart type
+ *
+ * Sunburst charts visualize hierarchical flow data as concentric rings.
+ * They work with the same flow data as Sankey but show only "after" steps
+ * radiating outward from the central starting step.
+ */
+export declare const sunburstChartConfig: ChartTypeConfig;

package/dist/cjs/client/components/charts/SunburstChart.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { ChartProps } from '../../types.js';
+/**
+ * SunburstChart Component
+ *
+ * Renders a sunburst diagram visualization from FlowChartData.
+ * Shows hierarchical flow paths radiating from a central starting step.
+ */
+declare const SunburstChart: React.NamedExoticComponent<ChartProps>;
+export default SunburstChart;

package/dist/cjs/client/components/charts/TreeMapChart.config.d.ts

@@ -0,0 +1,5 @@
+import { ChartTypeConfig } from '../../charts/chartConfigs.js';
+/**
+ * Configuration for the treemap chart type
+ */
+export declare const treemapChartConfig: ChartTypeConfig;

package/dist/cjs/client/components/charts/TreeMapChart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChartProps } from '../../types.js';
+declare const TreeMapChart: React.NamedExoticComponent<ChartProps>;
+export default TreeMapChart;

package/dist/cjs/client/components/charts/TreeMapChart.helpers.d.ts

@@ -0,0 +1,37 @@
+import { AxisFormatConfig, ChartAxisConfig, ColorPalette, CubeQuery } from '../../types.js';
+export interface TreemapDatum {
+    name: string;
+    size: number;
+    fill?: string;
+    series?: string;
+    [key: string]: unknown;
+}
+export interface TreemapBuildResult {
+    treemapData: TreemapDatum[];
+    isNumericSeries: boolean;
+    seriesField?: string;
+}
+/**
+ * Build treemap data (config or auto-detect), then drop non-positive sizes.
+ * Returns `null` when the legacy path can't find a usable size field.
+ */
+export declare function buildTreemapData(data: Record<string, any>[], chartConfig: ChartAxisConfig | undefined, queryObject: CubeQuery | undefined, colorPalette: ColorPalette | undefined): TreemapBuildResult | null;
+/** Min/max of the (numeric) series field across the raw rows. */
+export declare function seriesMinMax(data: Record<string, any>[], seriesField: string): {
+    min: number;
+    max: number;
+};
+/** Format a numeric value with the optional axis format (or `.toFixed(2)`). */
+export declare function formatSeriesValue(value: number, format: AxisFormatConfig | undefined): string;
+export interface LegendEntry {
+    value: string;
+    type: 'rect';
+    color: string;
+}
+/**
+ * Build the legend entries for the treemap: a gradient ramp for numeric series,
+ * or discrete swatches for categorical series. Empty when not applicable.
+ */
+export declare function buildTreemapLegend(data: Record<string, any>[], treemapData: TreemapDatum[], showLegend: boolean, seriesField: string | undefined, isNumericSeries: boolean, leftYAxisFormat: AxisFormatConfig | undefined): LegendEntry[];
+/** Adjust the outer container height to make room for a legend, if present. */
+export declare function adjustHeightForLegend(height: string | number, hasLegend: boolean): string | number;

package/dist/cjs/client/components/charts/TreeMapContent.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { AxisFormatConfig, ChartAxisConfig, ColorPalette, CubeQuery } from '../../types.js';
+import { ChartDataPointClickEvent } from '../../types/drill.js';
+import { TreemapDatum } from './TreeMapChart.helpers.js';
+interface TreeMapContentOptions {
+    treemapData: TreemapDatum[];
+    colorPalette?: ColorPalette;
+    hoveredIndex: number | null;
+    setHoveredIndex: (index: number | null) => void;
+    leftYAxisFormat?: AxisFormatConfig;
+    drillEnabled?: boolean;
+    onDataPointClick?: (event: ChartDataPointClickEvent) => void;
+    queryObject?: CubeQuery;
+    chartConfig?: ChartAxisConfig;
+}
+/**
+ * Build the Recharts `content` renderer for treemap cells.
+ *
+ * Encapsulates the per-cell rect + foreignObject overlay, hover state and drill
+ * click handler that previously lived inline in TreeMapChart (the highest-
+ * complexity hot spots). Behaviour is identical to the original.
+ */
+export declare function makeTreeMapContent({ treemapData, colorPalette, hoveredIndex, setHoveredIndex, leftYAxisFormat, drillEnabled, onDataPointClick, queryObject, chartConfig, }: TreeMapContentOptions): (props: any) => React.JSX.Element | null;
+export {};

package/dist/cjs/client/components/charts/TreeMapLegend.d.ts

@@ -0,0 +1,13 @@
+import { AxisFormatConfig } from '../../types.js';
+import { LegendEntry } from './TreeMapChart.helpers.js';
+interface TreeMapLegendProps {
+    isNumericSeries: boolean;
+    seriesField?: string;
+    seriesLabel: string;
+    legendPayload: LegendEntry[];
+    data: Record<string, any>[];
+    leftYAxisFormat?: AxisFormatConfig;
+}
+/** Treemap legend wrapper — gradient for numeric series, swatches otherwise. */
+export declare function TreeMapLegend({ isNumericSeries, seriesField, seriesLabel, legendPayload, data, leftYAxisFormat, }: TreeMapLegendProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/charts/WaterfallChart.config.d.ts

@@ -0,0 +1,5 @@
+import { ChartTypeConfig } from '../../charts/chartConfigs.js';
+/**
+ * Configuration for the waterfall chart type
+ */
+export declare const waterfallChartConfig: ChartTypeConfig;

package/dist/cjs/client/components/charts/WaterfallChart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChartProps } from '../../types.js';
+declare const WaterfallChart: React.NamedExoticComponent<ChartProps>;
+export default WaterfallChart;

package/dist/cjs/client/components/charts/cartesianChartHelpers.d.ts

@@ -0,0 +1,126 @@
+import { default as React } from 'react';
+import { ColorPalette } from '../../types.js';
+/**
+ * Co-located helpers shared by the Cartesian time-series charts (Line, Area).
+ *
+ * These extract the heavier inline logic that previously lived inside the chart
+ * components — the clickable/drill dot renderer, the comparison-mode tick and
+ * label formatters, and the series-key → measure-field resolution — so the
+ * component bodies stay focused on chart composition. Pure extraction: no
+ * behaviour change.
+ */
+export interface DataPointClickPayload {
+    dataPoint: any;
+    clickedField: string;
+    xValue: any;
+    position: {
+        x: number;
+        y: number;
+    };
+    nativeEvent: React.MouseEvent;
+}
+interface DrillDotOptions {
+    /** Recharts dot props (cx, cy, payload, key). */
+    props: any;
+    color: string;
+    drillEnabled?: boolean;
+    originalField?: string;
+    seriesKey: string;
+    onDataPointClick?: (payload: DataPointClickPayload) => void;
+}
+/**
+ * Render a single data-point dot. When drill is enabled and a click handler is
+ * present, renders a larger clickable dot with a surface-coloured backing
+ * circle to mask grid lines; otherwise a small plain dot. Returns null when the
+ * point has no coordinates.
+ *
+ * `renderPlain` controls whether a small non-interactive dot is drawn when
+ * drill is disabled (Line draws one; Area returns nothing).
+ */
+export declare function renderDrillDot({ props, color, drillEnabled, originalField, seriesKey, onDataPointClick, renderPlain }: DrillDotOptions & {
+    renderPlain: boolean;
+}): React.ReactElement | null;
+/**
+ * Build the comparison-mode X-axis tick formatter for time-series charts.
+ * Returns undefined when not in comparison mode (no custom formatting).
+ */
+export declare function makeComparisonTickFormatter(hasComparisonData: boolean, chartData: any[], queryObject: any, xAxisField: string): ((value: string | number, index: number) => string) | undefined;
+/**
+ * Build the comparison-mode tooltip label formatter for time-series charts.
+ * Returns undefined when not in comparison mode (no custom formatting).
+ */
+export declare function makeComparisonLabelFormatter(hasComparisonData: boolean, queryObject: any, xAxisField: string): ((label: any, payload: any) => string) | undefined;
+/**
+ * Resolve effective stacking for the Area chart from `stackType` (new) /
+ * `stacked` (legacy), disabling stacking when a right axis is present (areas on
+ * different axes can't be stacked).
+ */
+export declare function resolveAreaStacking(displayConfig: {
+    stackType?: string;
+    stacked?: boolean;
+} | undefined, hasRightAxis: boolean): {
+    effectiveShouldStack: boolean;
+    effectiveIsPercentStack: boolean;
+    stackOffset: 'expand' | undefined;
+};
+/** Build a map from series display label to original measure field name. */
+export declare function buildSeriesKeyToFieldMap(yAxisFields: string[], getFieldLabel: (field: string) => string): Record<string, string>;
+/**
+ * Resolve a series key back to its original measure field, handling comparison
+ * suffixes like "(Current)" / "(Prior)" and dimension prefixes ("Dim - Label").
+ */
+export declare function makeSeriesKeyResolver(seriesKeyToField: Record<string, string>): (seriesKey: string) => string | undefined;
+/** Pick a series colour by index, preferring the palette then the defaults. */
+export declare function getSeriesColor(colorPalette: ColorPalette | undefined, index: number): string;
+interface LineSeriesOptions {
+    seriesKeys: string[];
+    colorPalette?: ColorPalette;
+    resolveField: (seriesKey: string) => string | undefined;
+    yAxisAssignment: Record<string, 'left' | 'right'>;
+    hoveredLegend: string | null;
+    connectNulls: boolean;
+    drillEnabled?: boolean;
+    onDataPointClick?: (payload: DataPointClickPayload) => void;
+    /** Comparison styling (omit/false → standard series). */
+    hasComparisonData?: boolean;
+    periodLabels?: string[];
+    priorPeriodStyle?: 'solid' | 'dashed' | 'dotted';
+    priorPeriodOpacity?: number;
+}
+/** Render all line series for the Line chart. */
+export declare function renderLineSeries(opts: LineSeriesOptions): React.ReactElement[];
+interface AreaSeriesOptions {
+    seriesKeys: string[];
+    colorPalette?: ColorPalette;
+    seriesKeyToField: Record<string, string>;
+    yAxisAssignment: Record<string, 'left' | 'right'>;
+    hoveredLegend: string | null;
+    connectNulls: boolean;
+    shouldStack: boolean;
+    drillEnabled?: boolean;
+    onDataPointClick?: (payload: DataPointClickPayload) => void;
+}
+/** Render all area series for the Area chart. */
+export declare function renderAreaSeries(opts: AreaSeriesOptions): React.ReactElement[];
+export interface TimeSeriesShape {
+    chartData: any[];
+    seriesKeys: string[];
+    effectiveXAxisKey: string;
+    hasComparisonData: boolean;
+    periodLabels: string[];
+}
+/**
+ * Shape raw rows for a Cartesian time-series chart. In comparison mode this
+ * uses the overlay transform (aligned by period day index); otherwise the
+ * standard series transform. Centralises the branch so the chart body stays
+ * flat.
+ */
+export declare function buildTimeSeriesData(args: {
+    data: any[];
+    xAxisField: string;
+    yAxisFields: string[];
+    seriesFields: string[];
+    queryObject: any;
+    getFieldLabel: (field: string) => string;
+}): TimeSeriesShape;
+export {};

package/dist/cjs/client/components/charts/chartAxisResolution.d.ts

@@ -0,0 +1,32 @@
+import { ChartAxisConfig } from '../../types.js';
+/**
+ * Discriminated error code returned by {@link resolveChartAxisFields} when the
+ * chart configuration is invalid. Each chart maps these codes to its own i18n
+ * hint key (e.g. pie charts surface a pie-specific message for `axisInvalid`).
+ */
+export type ChartAxisErrorCode = 'axisInvalid' | 'axisFields';
+/**
+ * Result of resolving X/Y/series fields from a {@link ChartAxisConfig}.
+ * When `errorCode` is non-null the field values are not usable and the chart
+ * should render a configuration-error state instead.
+ */
+export interface ResolvedChartAxisFields {
+    /** Resolved X-axis field (category), or undefined when the config is invalid */
+    xAxisField?: string;
+    /** Resolved Y-axis (value/measure) fields */
+    yAxisFields: string[];
+    /** Optional series/grouping fields (only present in the new config format) */
+    seriesFields: string[];
+    /** Non-null when the configuration cannot produce a renderable axis setup */
+    errorCode: ChartAxisErrorCode | null;
+}
+/**
+ * Pure resolver for the X/Y/series field extraction that Cartesian charts
+ * (bar, line, area, pie) all duplicated inline.
+ *
+ * Supports both the new format (`xAxis` / `yAxis` / `series` arrays) and the
+ * legacy format (`x` / `y`). Returns a discriminated `errorCode` rather than
+ * JSX so each chart can map it to its own i18n hint key and render its own
+ * guard component.
+ */
+export declare function resolveChartAxisFields(chartConfig?: ChartAxisConfig): ResolvedChartAxisFields;

package/dist/cjs/client/components/charts/chartScaffolding.d.ts

@@ -0,0 +1,77 @@
+import { AxisFormatConfig } from '../../types.js';
+/**
+ * Shared scaffolding for the Cartesian recharts charts (bar, line, area).
+ *
+ * These charts duplicated the same dual-Y-axis derivation, chart margins,
+ * target-line overlay, and the left/right `<YAxis>` JSX. The pure helpers and
+ * recharts render-helpers here own that shared setup. Render-helpers return
+ * recharts elements (inside a fragment) and are embedded directly in the chart
+ * children — recharts flattens fragments when discovering axes/series, exactly
+ * as it already does for the inline target-line fragment.
+ */
+export interface DualAxisInfo {
+    /** True when at least one measure is assigned to the right axis */
+    hasRightAxis: boolean;
+    /** Measure fields rendered against the left axis */
+    leftAxisFields: string[];
+    /** Measure fields rendered against the right axis */
+    rightAxisFields: string[];
+}
+/** Derive left/right axis membership from per-measure axis assignments. */
+export declare function getDualAxisInfo(yAxisFields: string[], yAxisAssignment: Record<string, 'left' | 'right'>): DualAxisInfo;
+/** Chart margins with extra room for the Y-axis label(s). */
+export declare function getYAxisChartMargins(hasRightAxis: boolean): {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+/**
+ * Apply target values (single or comma-separated spread) onto chart data,
+ * returning the spread targets plus data enhanced with a `__target` key.
+ */
+export declare function withTargetData<T extends Record<string, any>>(chartData: T[], target: string | undefined): {
+    spreadTargets: number[];
+    enhancedChartData: T[];
+};
+/**
+ * Render the left + optional right `<YAxis>`. Returns recharts elements in a
+ * fragment for embedding directly in the chart children. Positional args keep
+ * the (otherwise identical) call sites in each chart down to a single line.
+ *
+ * @param isPercentStack when true (area/bar percent stacking) the left axis shows 0–100%
+ */
+export declare function renderDualYAxes({ hasRightAxis, leftAxisFields, rightAxisFields }: DualAxisInfo, getFieldLabel: (field: string) => string, leftYAxisFormat?: AxisFormatConfig, rightYAxisFormat?: AxisFormatConfig, isPercentStack?: boolean): import("react").JSX.Element;
+/**
+ * Render the target overlay: a white backing line plus a purple dashed line
+ * on top (shared by bar, line, area). Returns null when there are no targets.
+ */
+export declare function renderChartTargetLines(spreadTargets: number[]): import("react").JSX.Element | null;
+interface CartesianTooltipOptions {
+    leftYAxisFormat?: AxisFormatConfig;
+    rightYAxisFormat?: AxisFormatConfig;
+    yAxisAssignment: Record<string, 'left' | 'right'>;
+    /** Maps a series key (display label) back to its original measure field. */
+    resolveField: (name: string) => string | undefined;
+    /** When true, values render as percentages (area/bar percent stacking). */
+    isPercentStack?: boolean;
+}
+/**
+ * Build the value/name tooltip formatter shared by the Cartesian charts.
+ * Handles null values, the target series, percent stacking, and per-series
+ * left/right axis format selection.
+ */
+export declare function makeCartesianTooltipFormatter({ leftYAxisFormat, rightYAxisFormat, yAxisAssignment, resolveField, isPercentStack }: CartesianTooltipOptions): (value: any, name: any) => [any, any];
+/**
+ * Render the hover-aware bottom legend shared by the Cartesian charts.
+ * Returns null when the legend is hidden. `iconType` / `paddingTop` differ
+ * per chart (rect+10 for area, rect+25 for bar, line+25 for line).
+ */
+export declare function renderHoverLegend({ show, iconType, paddingTop, onHover, onLeave }: {
+    show: boolean;
+    iconType: 'rect' | 'line' | 'circle';
+    paddingTop: number;
+    onHover: (dataKey: string) => void;
+    onLeave: () => void;
+}): import("react").JSX.Element | null;
+export {};

package/dist/cjs/client/components/charts/gaugeChartHelpers.d.ts

@@ -0,0 +1,36 @@
+import { AxisFormatConfig, ThresholdBand } from '../../types.js';
+/**
+ * Co-located helpers for GaugeChart: pure geometry/value math and threshold
+ * parsing extracted from the component so the render body stays flat. Pure
+ * extraction — no behaviour change.
+ */
+export declare const START_ANGLE: number;
+export declare const END_ANGLE: number;
+export declare const TRACK_COLOR = "#e2e8f0";
+export declare const DEFAULT_FILL = "#6366f1";
+export declare function parseNum(v: unknown): number | null;
+export declare function clamp(v: number, lo: number, hi: number): number;
+export declare function valueToAngle(value: number, min: number, max: number): number;
+export declare function resolveColor(fraction: number, thresholds: ThresholdBand[]): string;
+export declare function buildArcPath(innerRadius: number, outerRadius: number, startAngle: number, endAngle: number): string;
+/** Parse the displayConfig.thresholds value (array or JSON string) into bands. */
+export declare function parseThresholds(raw: unknown): ThresholdBand[];
+export interface ThresholdArcBand {
+    color: string;
+    start: number;
+    end: number;
+}
+/** Build the outer-ring threshold arc bands (in fraction space 0..1). */
+export declare function buildThresholdBands(thresholds: ThresholdBand[]): ThresholdArcBand[];
+export interface GaugeGeometry {
+    effectiveMax: number;
+    clampedValue: number;
+    fraction: number;
+    fillColor: string;
+    fillAngle: number;
+    needleAngle: number;
+}
+/** Compute the gauge's clamped value, fraction, fill colour, and angles. */
+export declare function computeGaugeGeometry(rawValue: number, minValue: number, maxValue: number, thresholds: ThresholdBand[]): GaugeGeometry;
+/** Format a gauge value with the optional axis format, else locale string. */
+export declare function formatGaugeValue(value: number, yAxisFormat?: AxisFormatConfig): string;

package/dist/cjs/client/components/charts/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Chart components for drizzle-cube client
+ * Minimal Recharts-based components with Tailwind styling
+ */
+export { default as RechartsBarChart } from './BarChart.js';
+export { default as RechartsLineChart } from './LineChart.js';
+export { default as RechartsAreaChart } from './AreaChart.js';
+export { default as RechartsPieChart } from './PieChart.js';
+export { default as RechartsScatterChart } from './ScatterChart.js';
+export { default as RechartsRadarChart } from './RadarChart.js';
+export { default as RechartsRadialBarChart } from './RadialBarChart.js';
+export { default as RechartsTreeMapChart } from './TreeMapChart.js';
+export { default as BubbleChart } from './BubbleChart.js';
+export { default as DataTable } from './DataTable.js';
+export { default as FunnelChart } from './FunnelChart.js';
+export { default as ActivityGridChart } from './ActivityGridChart.js';
+export { default as KpiNumber } from './KpiNumber.js';
+export { default as KpiDelta } from './KpiDelta.js';
+export { default as KpiText } from './KpiText.js';
+export { default as MarkdownChart } from './MarkdownChart.js';
+export { default as BoxPlotChart } from './BoxPlotChart.js';
+export { default as WaterfallChart } from './WaterfallChart.js';
+export { default as CandlestickChart } from './CandlestickChart.js';
+export { default as MeasureProfileChart } from './MeasureProfileChart.js';
+export { default as GaugeChart } from './GaugeChart.js';

package/dist/cjs/client/components/charts/kpiTextHelpers.d.ts

@@ -0,0 +1,46 @@
+import { ColorPalette } from '../../types.js';
+/**
+ * Co-located pure helpers for KpiText: value extraction, statistics, number
+ * formatting, template processing, and colour resolution. Extracted so the
+ * component body stays focused on dimensioning + render. Pure extraction — no
+ * behaviour change.
+ */
+/** Extract the configured measure fields from a chart config (string or array). */
+export declare function extractValueFields(yAxis: string | string[] | undefined): string[];
+/**
+ * Extract the values for a field from each row, falling back to the first
+ * available field when the configured field is absent. Null/undefined dropped.
+ */
+export declare function extractValues(data: Record<string, any>[], valueField: string): any[];
+export interface KpiStats {
+    mainValue: any;
+    min: number | null;
+    max: number | null;
+    showStats: boolean;
+}
+/**
+ * Reduce extracted values to the displayed main value plus optional min/max
+ * statistics. Numeric multi-value sets average and expose min/max; non-numeric
+ * sets concatenate.
+ */
+export declare function computeKpiStats(values: any[]): KpiStats;
+interface NumberFormatOptions {
+    formatValue?: (value: any) => string;
+    decimals?: number;
+}
+/** Format a number with K/M/B abbreviation, honouring a custom formatter. */
+export declare function formatKpiNumber(value: number | null | undefined, options: NumberFormatOptions): string;
+interface TemplateContext {
+    value: any;
+    valueField: string;
+    fieldLabel: string;
+    min: number | null;
+    max: number | null;
+    count: number;
+    formatNumber: (value: number | null | undefined) => string;
+}
+/** Replace `${var}` tokens in a KPI template, falling back to the raw value. */
+export declare function processKpiTemplate(template: string, ctx: TemplateContext): string;
+/** Resolve the KPI text colour from the palette by index, with a fallback. */
+export declare function resolveValueColor(valueColorIndex: number | undefined, colorPalette: ColorPalette | undefined): string;
+export {};

package/dist/cjs/client/components/charts/radarChartHelpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Co-located data-shaping helpers for RadarChart. The component supports a
+ * config-driven format and a legacy auto-detection format; both branches are
+ * isolated here so the component body stays focused on rendering. Pure
+ * extraction — no behaviour change.
+ */
+export interface RadarShape {
+    radarData: any[];
+    seriesKeys: string[];
+    /** True when no numeric value fields could be found (legacy auto-detect). */
+    noNumericFields?: boolean;
+}
+/** Shape rows for the radar chart via config-driven or legacy auto-detection. */
+export declare function buildRadarData(data: any[], chartConfig: any, queryObject: any): RadarShape;

package/dist/cjs/client/components/charts/radialBarChartHelpers.d.ts

@@ -0,0 +1,22 @@
+import { ColorPalette } from '../../types.js';
+/**
+ * Co-located data-shaping helpers for RadialBarChart. The component supports a
+ * config-driven format and a legacy auto-detection format; both branches are
+ * isolated here so the component body stays focused on rendering. Pure
+ * extraction — no behaviour change.
+ */
+export interface RadialDatum {
+    name: string;
+    value: number;
+    fill?: string;
+}
+export interface RadialShape {
+    radialData: RadialDatum[];
+    /** True when the legacy auto-detect found no usable value field. */
+    noValueField?: boolean;
+}
+/**
+ * Shape rows for the radial bar chart (config-driven or legacy auto-detect),
+ * filtering out null/zero values.
+ */
+export declare function buildRadialData(data: any[], chartConfig: any, queryObject: any, colorPalette: ColorPalette | undefined): RadialShape;