drizzle-cube 0.5.7 → 0.6.0

package/dist/client/components/PortletContainer.d.ts

@@ -6,5 +6,5 @@ interface PortletContainerProps {
     onDelete?: (portletId: string) => void;
     onRefresh?: (portletId: string) => void;
 }
-export default function PortletContainer({ portlet, editable, onEdit, onDelete, onRefresh }: PortletContainerProps): import("react/jsx-runtime").JSX.Element;
+export default function PortletContainer({ portlet, editable, onEdit, onDelete, onRefresh }: PortletContainerProps): import("react").JSX.Element;
 export {};

package/dist/client/components/PortletFilterConfigModal.d.ts

@@ -1,11 +1,13 @@
-import { DashboardFilter } from '../types';
+import { DashboardFilter, DashboardFilterMapping, CubeMeta, PortletConfig } from '../types';
 interface PortletFilterConfigModalProps {
     isOpen: boolean;
     onClose: () => void;
     dashboardFilters: DashboardFilter[];
-    currentMapping: string[];
-    onSave: (mapping: string[]) => void;
+    currentMapping: DashboardFilterMapping;
+    onSave: (mapping: DashboardFilterMapping) => void;
     portletTitle: string;
+    schema?: CubeMeta | null;
+    portlet?: PortletConfig | null;
 }
-export default function PortletFilterConfigModal({ isOpen, onClose, dashboardFilters, currentMapping, onSave, portletTitle }: PortletFilterConfigModalProps): import("react/jsx-runtime").JSX.Element | null;
+export default function PortletFilterConfigModal({ isOpen, onClose, dashboardFilters, currentMapping, onSave, portletTitle, schema, portlet }: PortletFilterConfigModalProps): import("react").JSX.Element | null;
 export {};

package/dist/client/components/RowManagedLayout.d.ts

@@ -15,5 +15,5 @@ interface RowManagedLayoutProps {
     onNewRowDrop: (insertIndex: number) => void;
     renderPortlet: (portlet: PortletConfig, containerProps?: HTMLAttributes<HTMLDivElement>, headerProps?: HTMLAttributes<HTMLDivElement>) => ReactNode;
 }
-export default function RowManagedLayout({ rows, portlets, gridSettings, gridWidth, canEdit, isDragging, onRowResize, onColumnResize, onPortletDragStart, onPortletDragEnd, onRowDrop, onNewRowDrop, renderPortlet }: RowManagedLayoutProps): import("react/jsx-runtime").JSX.Element;
+export default function RowManagedLayout({ rows, portlets, gridSettings, gridWidth, canEdit, isDragging, onRowResize, onColumnResize, onPortletDragStart, onPortletDragEnd, onRowDrop, onNewRowDrop, renderPortlet }: RowManagedLayoutProps): import("react").JSX.Element;
 export {};

package/dist/client/components/ScaledGridWrapper.d.ts

@@ -8,5 +8,5 @@ interface ScaledGridWrapperProps {
  * Wrapper component that scales the grid using CSS transform
  * Handles height compensation to prevent overflow/whitespace issues
  */
-export default function ScaledGridWrapper({ scaleFactor, designWidth, children }: ScaledGridWrapperProps): import("react/jsx-runtime").JSX.Element;
+export default function ScaledGridWrapper({ scaleFactor, designWidth, children }: ScaledGridWrapperProps): React.JSX.Element;
 export {};

package/dist/client/components/SchemaVisualization/CubeNode.d.ts

@@ -21,5 +21,5 @@ interface CubeNodeData {
 interface CubeNodeProps {
     data: CubeNodeData;
 }
-export declare function CubeNode({ data }: CubeNodeProps): import("react/jsx-runtime").JSX.Element;
+export declare function CubeNode({ data }: CubeNodeProps): import("react").JSX.Element;
 export {};

package/dist/client/components/SchemaVisualization/FieldDetailPanel.d.ts

@@ -11,5 +11,5 @@ interface FieldDetailPanelProps {
     };
     onClose: () => void;
 }
-export declare function FieldDetailPanel({ selection, meta, onClose }: FieldDetailPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function FieldDetailPanel({ selection, meta, onClose }: FieldDetailPanelProps): import("react").JSX.Element | null;
 export {};

package/dist/client/components/SchemaVisualization/RelationshipEdge.d.ts

@@ -9,5 +9,5 @@ interface RelationshipEdgeData {
     [key: string]: unknown;
 }
 export type RelationshipEdgeType = Edge<RelationshipEdgeData, 'relationshipEdge'>;
-export declare function RelationshipEdge({ sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, data, markerEnd, }: EdgeProps<RelationshipEdgeType>): import("react/jsx-runtime").JSX.Element | null;
+export declare function RelationshipEdge({ sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, data, markerEnd, }: EdgeProps<RelationshipEdgeType>): import("react").JSX.Element | null;
 export {};

package/dist/client/components/SchemaVisualization/SchemaVisualizationLazy.d.ts

@@ -1,3 +1,3 @@
 import { SchemaVisualizationProps } from './index';
-export declare function SchemaVisualizationLazy(props: SchemaVisualizationProps): import("react/jsx-runtime").JSX.Element;
+export declare function SchemaVisualizationLazy(props: SchemaVisualizationProps): import("react").JSX.Element;
 export declare function isSchemaVisualizationAvailable(): boolean;

package/dist/client/components/SchemaVisualization/index.d.ts

@@ -6,5 +6,5 @@ export interface SchemaVisualizationProps {
     searchTerm?: string;
     height?: string | number;
 }
-export declare function SchemaVisualization({ className, onFieldClick, highlightedCubes, highlightedFields, searchTerm, height, }: SchemaVisualizationProps): import("react/jsx-runtime").JSX.Element;
+export declare function SchemaVisualization({ className, onFieldClick, highlightedCubes, highlightedFields, searchTerm, height, }: SchemaVisualizationProps): import("react").JSX.Element;
 export default SchemaVisualization;

package/dist/client/components/TextPortletModal.d.ts

@@ -8,5 +8,5 @@ interface TextPortletModalProps {
     colorPalette?: ColorPalette;
     existingTitles?: string[];
 }
-export default function TextPortletModal({ isOpen, onClose, onSave, portlet, colorPalette, existingTitles, }: TextPortletModalProps): import("react/jsx-runtime").JSX.Element | null;
+export default function TextPortletModal({ isOpen, onClose, onSave, portlet, colorPalette, existingTitles, }: TextPortletModalProps): import("react").JSX.Element | null;
 export {};

package/dist/client/components/analyticsPortlet/PortletChart.d.ts

@@ -0,0 +1,31 @@
+import { ChartAxisConfig, ChartDisplayConfig, ChartType, CubeQuery } from '../../types';
+import { FlowChartData } from '../../types/flow';
+import { RetentionChartData } from '../../types/retention';
+import { ColorPalette } from '../../utils/colorPalettes';
+type Height = string | number;
+interface ResultSetLike {
+    tablePivot: () => unknown;
+    rawData: () => unknown;
+}
+export interface PortletChartProps {
+    chartType: ChartType;
+    height: Height;
+    shouldSkipQuery: boolean;
+    isMultiQuery: boolean;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    resultSet: ResultSetLike | null;
+    multiQueryData: unknown[] | null;
+    flowChartData: FlowChartData | null;
+    retentionChartData: RetentionChartData | null;
+    chartConfig?: ChartAxisConfig;
+    displayConfig?: ChartDisplayConfig;
+    activeQuery: CubeQuery | null;
+    colorPalette?: ColorPalette;
+    drillEnabled: boolean;
+    currentChartConfig?: ChartAxisConfig | null;
+    onDataPointClick?: (...args: any[]) => void;
+}
+export declare function PortletChart(props: PortletChartProps): import("react").JSX.Element;
+export {};

package/dist/client/components/analyticsPortlet/PortletChartView.d.ts

@@ -0,0 +1,35 @@
+import { ChartAxisConfig, ChartDisplayConfig, ChartType, CubeQuery } from '../../types';
+import { FlowChartData } from '../../types/flow';
+import { RetentionChartData } from '../../types/retention';
+import { ColorPalette } from '../../utils/colorPalettes';
+import { DrillInteraction } from '../../types/drill';
+type Height = string | number;
+interface ResultSetLike {
+    tablePivot: () => unknown;
+    rawData: () => unknown;
+}
+export interface PortletChartViewProps {
+    title?: string;
+    query: string;
+    chartType: ChartType;
+    height: Height;
+    chartConfig?: ChartAxisConfig;
+    displayConfig?: ChartDisplayConfig;
+    colorPalette?: ColorPalette;
+    shouldSkipQuery: boolean;
+    isMultiQuery: boolean;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    resultSet: ResultSetLike | null;
+    multiQueryData: unknown[] | null;
+    flowChartData: FlowChartData | null;
+    retentionChartData: RetentionChartData | null;
+    activeQuery: CubeQuery | null;
+    drill: DrillInteraction;
+    isDrillEnabled: boolean;
+    onNavigateBack: () => void;
+    onNavigateToLevel: (index: number) => void;
+}
+export declare function PortletChartView(props: PortletChartViewProps): import("react").JSX.Element;
+export {};

package/dist/client/components/analyticsPortlet/PortletStates.d.ts

@@ -0,0 +1,65 @@
+import { ReactNode, Ref } from 'react';
+import { ChartType } from '../../types';
+import { DrillPathEntry } from '../../types/drill';
+type Height = string | number;
+export declare function PortletConfigRequired({ inViewRef, height }: {
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+}): import("react").JSX.Element;
+export declare function PortletLazyPlaceholder({ inViewRef, height }: {
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+}): import("react").JSX.Element;
+export declare function PortletLoading({ inViewRef, height, loadingComponent }: {
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+    loadingComponent?: ReactNode;
+}): import("react").JSX.Element;
+interface PortletErrorProps {
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+    error: {
+        message?: string;
+        toString: () => string;
+    };
+    onRetry: () => void;
+    activeQuery: unknown;
+    query: string;
+    chartType: ChartType;
+    chartConfig: unknown;
+    displayConfig: unknown;
+}
+export declare function PortletError({ inViewRef, height, error, onRetry, activeQuery, query, chartType, chartConfig, displayConfig }: PortletErrorProps): import("react").JSX.Element;
+interface PortletNoDataProps {
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+    drillPath: DrillPathEntry[];
+    onNavigateBack: () => void;
+    onNavigateToLevel: (index: number) => void;
+}
+export declare function PortletNoData({ inViewRef, height, drillPath, onNavigateBack, onNavigateToLevel }: PortletNoDataProps): import("react").JSX.Element;
+export type PortletStateKind = 'config-required' | 'lazy-placeholder' | 'loading' | 'error';
+interface PortletStateViewProps {
+    kind: PortletStateKind | 'no-data';
+    inViewRef: Ref<HTMLDivElement>;
+    height: Height;
+    loadingComponent?: ReactNode;
+    error: {
+        message?: string;
+        toString: () => string;
+    } | null;
+    onRetry: () => void;
+    activeQuery: unknown;
+    query: string;
+    chartType: ChartType;
+    chartConfig: unknown;
+    displayConfig: unknown;
+    drillPath: DrillPathEntry[];
+    onNavigateBack: () => void;
+    onNavigateToLevel: (index: number) => void;
+}
+/**
+ * Renders the appropriate non-chart state view for the given render kind.
+ */
+export declare function PortletStateView(props: PortletStateViewProps): import("react").JSX.Element;
+export {};

package/dist/client/components/analyticsPortlet/parsePortletQuery.d.ts

@@ -0,0 +1,22 @@
+import { CubeQuery, DashboardFilter, DashboardFilterMapping, MultiQueryConfig, ServerFunnelQuery } from '../../types';
+import { ServerFlowQuery } from '../../types/flow';
+import { ServerRetentionQuery } from '../../types/retention';
+export interface ParsedPortletQuery {
+    queryObject: CubeQuery | null;
+    multiQueryConfig: MultiQueryConfig | null;
+    serverFunnelQuery: ServerFunnelQuery | null;
+    serverFlowQuery: ServerFlowQuery | null;
+    serverRetentionQuery: ServerRetentionQuery | null;
+}
+export interface ParsePortletQueryParams {
+    query: string;
+    shouldSkipQuery: boolean;
+    regularFilters?: DashboardFilter[];
+    dashboardFilters?: DashboardFilter[];
+    dashboardFilterMapping?: DashboardFilterMapping;
+}
+/**
+ * Parse the portlet query string and merge applicable dashboard filters.
+ * Returns a discriminated set of possible query shapes (only one non-null).
+ */
+export declare function parsePortletQuery(params: ParsePortletQueryParams): ParsedPortletQuery;

package/dist/client/components/analyticsPortlet/portletRenderState.d.ts

@@ -0,0 +1,31 @@
+import { FlowChartData, ServerFlowQuery } from '../../types/flow';
+import { RetentionChartData, ServerRetentionQuery } from '../../types/retention';
+import { CubeQuery, MultiQueryConfig, ServerFunnelQuery } from '../../types';
+export type PortletRenderKind = 'config-required' | 'lazy-placeholder' | 'loading' | 'error' | 'no-data' | 'chart';
+export interface PortletRenderStateParams {
+    hasChartConfig: boolean;
+    hasMandatoryFields: boolean;
+    shouldSkipQuery: boolean;
+    eagerLoad: boolean;
+    isVisible: boolean;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: unknown;
+    isMultiQuery: boolean;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    queryObject: CubeQuery | null;
+    multiQueryConfig: MultiQueryConfig | null;
+    serverFunnelQuery: ServerFunnelQuery | null;
+    serverFlowQuery: ServerFlowQuery | null;
+    serverRetentionQuery: ServerRetentionQuery | null;
+    resultSet: unknown;
+    multiQueryData: unknown[] | null;
+    flowChartData: FlowChartData | null;
+    retentionChartData: RetentionChartData | null;
+}
+/**
+ * Resolve which view the portlet should render.
+ */
+export declare function resolvePortletRenderKind(p: PortletRenderStateParams): PortletRenderKind;

package/dist/client/components/analyticsPortlet/usePortletDebugData.d.ts

@@ -0,0 +1,37 @@
+import { AnalyticsPortletProps, ChartAxisConfig, ChartDisplayConfig, ChartType, CubeQuery, ServerFunnelQuery } from '../../types';
+import { FlowChartData, ServerFlowQuery } from '../../types/flow';
+import { RetentionChartData, ServerRetentionQuery } from '../../types/retention';
+import { DrillPathEntry } from '../../types/drill';
+type DebugEntry = Parameters<NonNullable<AnalyticsPortletProps['onDebugDataReady']>>[0];
+type CacheInfo = DebugEntry['cacheInfo'];
+interface ResultSetLike {
+    tablePivot: () => unknown;
+    rawData: () => unknown;
+    cacheInfo?: () => CacheInfo;
+}
+export interface UsePortletDebugDataParams {
+    onDebugDataReady?: AnalyticsPortletProps['onDebugDataReady'];
+    error: unknown;
+    chartType: ChartType;
+    chartConfig?: ChartAxisConfig;
+    displayConfig?: ChartDisplayConfig;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    queryObject: CubeQuery | null;
+    activeQuery: CubeQuery | null;
+    serverFunnelQuery: ServerFunnelQuery | null;
+    serverFlowQuery: ServerFlowQuery | null;
+    serverRetentionQuery: ServerRetentionQuery | null;
+    resultSet: ResultSetLike | null;
+    multiQueryData: unknown[] | null;
+    flowChartData: FlowChartData | null;
+    retentionChartData: RetentionChartData | null;
+    funnelCacheInfo?: CacheInfo;
+    flowCacheInfo?: CacheInfo;
+    retentionCacheInfo?: CacheInfo;
+    drillPath: DrillPathEntry[];
+    currentChartConfig?: ChartAxisConfig | null;
+}
+export declare function usePortletDebugData(params: UsePortletDebugDataParams): void;
+export {};

package/dist/client/components/analyticsPortlet/usePortletDrillState.d.ts

@@ -0,0 +1,17 @@
+import { ChartAxisConfig, CubeQuery, DashboardFilter, DashboardFilterMapping } from '../../types';
+export interface UsePortletDrillStateParams {
+    queryObject: CubeQuery | null;
+    chartConfig?: ChartAxisConfig;
+    dashboardFilters?: DashboardFilter[];
+    dashboardFilterMapping?: DashboardFilterMapping;
+    isMultiQuery: boolean;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+}
+export declare function usePortletDrillState(params: UsePortletDrillStateParams): {
+    drill: import('../../types').DrillInteraction;
+    activeQuery: CubeQuery | null;
+    handleNavigateBack: () => void;
+    handleNavigateToLevel: (index: number) => void;
+};

package/dist/client/components/analyticsPortlet/usePortletQueryResults.d.ts

@@ -0,0 +1,37 @@
+import { useCubeLoadQuery, useFunnelQuery, useFlowQuery, useRetentionQuery } from '../../hooks/queries';
+import { CubeQuery, MultiQueryConfig, ServerFunnelQuery } from '../../types';
+import { FlowChartData, ServerFlowQuery } from '../../types/flow';
+import { RetentionChartData, ServerRetentionQuery } from '../../types/retention';
+interface RefreshOptions {
+    bustCache?: boolean;
+}
+export interface UsePortletQueryResultsParams {
+    activeQuery: CubeQuery | null;
+    multiQueryConfig: MultiQueryConfig | null;
+    serverFunnelQuery: ServerFunnelQuery | null;
+    serverFlowQuery: ServerFlowQuery | null;
+    serverRetentionQuery: ServerRetentionQuery | null;
+    isMultiQuery: boolean;
+    isFunnelMode: boolean;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    shouldSkipQuery: boolean;
+    eagerLoad: boolean;
+    isVisible: boolean;
+}
+export interface PortletQueryResults {
+    resultSet: ReturnType<typeof useCubeLoadQuery>['resultSet'];
+    isLoading: boolean;
+    isFetching: boolean;
+    error: unknown;
+    multiQueryData: unknown[] | null;
+    flowChartData: FlowChartData | null;
+    retentionChartData: RetentionChartData | null;
+    funnelCacheInfo: ReturnType<typeof useFunnelQuery>['cacheInfo'];
+    flowCacheInfo: ReturnType<typeof useFlowQuery>['cacheInfo'];
+    retentionCacheInfo: ReturnType<typeof useRetentionQuery>['cacheInfo'];
+    refresh: (options?: RefreshOptions) => void;
+    retry: () => void;
+}
+export declare function usePortletQueryResults(params: UsePortletQueryResultsParams): PortletQueryResults;
+export {};

package/dist/client/components/charts/ActivityGridChart.helpers.d.ts

@@ -0,0 +1,33 @@
+import { CubeQuery } from '../../types';
+export interface GridCell {
+    x: number;
+    y: number;
+    value: number;
+    date: Date;
+    label: string;
+}
+export interface GridMapping {
+    extractX: (date: Date) => number;
+    extractY: (date: Date) => number;
+    xLabels: string[];
+    yLabels: string[];
+    xFormat: (value: number) => string;
+    yFormat: (value: number) => string;
+    cellWidth: number;
+    cellHeight: number;
+    hasHierarchicalLabels?: boolean;
+    getYearFromX?: (value: number) => number;
+}
+/** Week-of-year (1-53) with the ISO-aligned year for the given date. */
+export declare function getWeekOfYear(date: Date): {
+    year: number;
+    week: number;
+};
+/** Get the grid coordinate mapping for a granularity (null when unsupported). */
+export declare function getGridMapping(granularity: string): GridMapping | null;
+/** Resolve the first matching field (string | array) for a date config value. */
+export declare function firstDateField(value: string | string[] | undefined): string | undefined;
+/** Get the query granularity for the date field, falling back to 'day'. */
+export declare function getQueryGranularity(queryObject: CubeQuery | undefined, dateField: string): string;
+/** Transform query rows into grid cells, skipping invalid dates. */
+export declare function buildGridData(data: Record<string, any>[], dateField: string, valueField: string, gridMapping: GridMapping, granularity: string): GridCell[];

package/dist/client/components/charts/ActivityGridChart.render.d.ts

@@ -0,0 +1,31 @@
+import { GridCell, GridMapping } from './ActivityGridChart.helpers';
+import { ColorPalette } from '../../types';
+import { ChartDataPointClickEvent } from '../../types/drill';
+export interface ActivityGridSafeConfig {
+    showTooltip: boolean;
+    showLabels: boolean;
+    fitToWidth: boolean;
+}
+export interface ActivityGridRenderContext {
+    svgEl: SVGSVGElement;
+    gridData: GridCell[];
+    gridMapping: GridMapping;
+    granularity: string;
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    safeDisplayConfig: ActivityGridSafeConfig;
+    colorPalette?: ColorPalette;
+    isDark: boolean;
+    valueField: string;
+    dateField: string;
+    getFieldLabel: (field: string) => string;
+    drillEnabled?: boolean;
+    onDataPointClick?: (event: ChartDataPointClickEvent) => void;
+}
+/**
+ * Render the activity grid into the given SVG element. Returns a cleanup
+ * function removing the tooltip, or undefined when there is nothing to draw.
+ */
+export declare function renderActivityGrid(ctx: ActivityGridRenderContext): (() => void) | undefined;

package/dist/client/components/charts/AxisFormatControls.d.ts

@@ -9,7 +9,7 @@ interface AxisFormatControlsProps {
 /**
  * Single axis format control section
  */
-export declare function AxisFormatControls({ value, onChange, axisLabel, previewValue }: AxisFormatControlsProps): import("react/jsx-runtime").JSX.Element;
+export declare function AxisFormatControls({ value, onChange, axisLabel, previewValue }: AxisFormatControlsProps): import("react").JSX.Element;
 interface MultiAxisFormatControlsProps {
     displayConfig: {
         xAxisFormat?: AxisFormatConfig;
@@ -29,7 +29,9 @@ interface MultiAxisFormatControlsProps {
     };
 }
 /**
- * Container component for multiple axis format controls
+ * Container component for multiple axis format controls. Each configured axis
+ * renders an `AxisFormatControls`; the per-axis entries are data-driven so the
+ * three branches collapse into a single map.
  */
-export declare function MultiAxisFormatControls({ displayConfig, onChange, showAxes }: MultiAxisFormatControlsProps): import("react/jsx-runtime").JSX.Element;
+export declare function MultiAxisFormatControls({ displayConfig, onChange, showAxes }: MultiAxisFormatControlsProps): import("react").JSX.Element;
 export default AxisFormatControls;

package/dist/client/components/charts/BarChart.helpers.d.ts

@@ -0,0 +1,23 @@
+import { ChartDisplayConfig } from '../../types';
+export interface StackMode {
+    shouldStack: boolean;
+    isPercentStack: boolean;
+}
+/** Derive stacking flags from `stackType` (new) or `stacked` (legacy). */
+export declare function resolveStackMode(displayConfig: ChartDisplayConfig | undefined): StackMode;
+/**
+ * Filter out rows where every series value is null, returning the kept rows and
+ * the number skipped (used to render the "N hidden" footer note).
+ */
+export declare function filterEmptyRows(transformedData: Record<string, any>[], seriesKeys: string[]): {
+    chartData: Record<string, any>[];
+    skippedCount: number;
+};
+export interface BarColoringMode {
+    /** Single series with mixed positive/negative values → green/red bars. */
+    usePositiveNegativeColoring: boolean;
+    /** Single measure, no series dimension, multiple categories → colour per category. */
+    useColorByCategory: boolean;
+}
+/** Decide which special per-bar colouring mode (if any) applies. */
+export declare function resolveBarColoringMode(seriesKeys: string[], chartData: Record<string, any>[], seriesFieldsLength: number): BarColoringMode;

package/dist/client/components/charts/BarSeries.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+import { ColorPalette } from '../../types';
+import { ChartDataPointClickEvent } from '../../types/drill';
+interface BarSeriesProps {
+    seriesKey: string;
+    index: number;
+    /** Original field name backing this series key (for axis assignment + drill). */
+    originalField: string | undefined;
+    axisId: 'left' | 'right';
+    stackId: string | undefined;
+    chartData: Record<string, any>[];
+    enhancedChartData: Record<string, any>[];
+    colorPalette?: ColorPalette;
+    hoveredLegend: string | null;
+    usePositiveNegativeColoring: boolean;
+    useColorByCategory: boolean;
+    drillEnabled?: boolean;
+    onDataPointClick?: (event: ChartDataPointClickEvent) => void;
+}
+/**
+ * Single `<Bar>` for a series key.
+ *
+ * Encapsulates the per-bar colouring modes (positive/negative, colour-by-category)
+ * and the drill click handler that were previously inlined in BarChart's render.
+ * Returned as a fragment-bearing component so it can be used directly inside the
+ * Recharts `<ComposedChart>` children list. Behaviour is identical to the original.
+ */
+export declare function BarSeries({ seriesKey, index, originalField, axisId, stackId, chartData, enhancedChartData, colorPalette, hoveredLegend, usePositiveNegativeColoring, useColorByCategory, drillEnabled, onDataPointClick }: BarSeriesProps): React.JSX.Element;
+export {};

package/dist/client/components/charts/BubbleChart.helpers.d.ts

@@ -0,0 +1,43 @@
+import { AxisFormatConfig, ChartAxisConfig, ChartDisplayConfig, CubeQuery } from '../../types';
+export interface BubbleData {
+    x: number;
+    xLabel?: string;
+    y: number;
+    size: number;
+    color?: string | number;
+    label: string;
+    series?: string;
+}
+export interface BubbleDisplayOptions {
+    showLegend: boolean;
+    showGrid: boolean;
+    showTooltip: boolean;
+    minBubbleSize: number;
+    maxBubbleSize: number;
+    bubbleOpacity: number;
+    xAxisFormat?: AxisFormatConfig;
+    leftYAxisFormat?: AxisFormatConfig;
+}
+/** Resolve bubble display options with defaults from the display config. */
+export declare function resolveBubbleDisplayOptions(displayConfig: ChartDisplayConfig | undefined): BubbleDisplayOptions;
+export interface BubbleFields {
+    xAxisField: string;
+    yAxisField: string;
+    seriesField: string;
+    sizeFieldName: string;
+    colorFieldName?: string;
+}
+/** Resolve the bubble chart field names; returns null when required fields missing. */
+export declare function resolveBubbleFields(chartConfig: ChartAxisConfig | undefined): BubbleFields | null;
+/**
+ * Transform query rows into bubble data, filtering out points with invalid
+ * x/y coordinates or non-positive size. Mirrors the original inline map+filter.
+ */
+export declare function transformBubbleData(data: Record<string, any>[], fields: BubbleFields, queryObject: CubeQuery | undefined): BubbleData[];
+/** Read a CSS custom property from the document root with a fallback. */
+export declare function getThemeColor(varName: string, fallback: string): string;
+/** Resolve text + grid colours for the current theme. */
+export declare function resolveThemeColors(isDark: boolean): {
+    textColor: string;
+    gridColor: string;
+};

package/dist/client/components/charts/BubbleChart.render.d.ts

@@ -0,0 +1,21 @@
+import { BubbleData, BubbleDisplayOptions, BubbleFields } from './BubbleChart.helpers';
+import { ColorPalette, CubeQuery } from '../../types';
+export interface BubbleRenderContext {
+    svgEl: SVGSVGElement;
+    bubbleData: BubbleData[];
+    fields: BubbleFields;
+    options: BubbleDisplayOptions;
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    queryObject: CubeQuery | undefined;
+    colorPalette?: ColorPalette;
+    isDark: boolean;
+    getFieldLabel: (field: string) => string;
+}
+/**
+ * Render the bubble chart into the given SVG element. Returns a cleanup function
+ * that removes the floating tooltip. Returns undefined when there is nothing to draw.
+ */
+export declare function renderBubbleChart(ctx: BubbleRenderContext): (() => void) | undefined;

package/dist/client/components/charts/ChartContainer.d.ts

@@ -3,5 +3,5 @@ interface ChartContainerProps {
     children: ReactElement;
     height?: string | number;
 }
-export default function ChartContainer({ children, height }: ChartContainerProps): import("react/jsx-runtime").JSX.Element;
+export default function ChartContainer({ children, height }: ChartContainerProps): import("react").JSX.Element;
 export {};

package/dist/client/components/charts/ChartLegend.d.ts

@@ -3,5 +3,5 @@ interface ChartLegendProps {
     onMouseLeave?: () => void;
     showLegend?: boolean;
 }
-export default function ChartLegend({ onMouseEnter, onMouseLeave, showLegend }: ChartLegendProps): import("react/jsx-runtime").JSX.Element | null;
+export default function ChartLegend({ onMouseEnter, onMouseLeave, showLegend }: ChartLegendProps): import("react").JSX.Element | null;
 export {};

package/dist/client/components/charts/ChartStates.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+/**
+ * Shared guard/state components for chart rendering.
+ *
+ * Cartesian charts (bar, line, area, pie, …) all duplicated the same
+ * centred flex blocks for their empty / config-error / render-error states,
+ * differing only in the hint text. These components own the duplicated wrapper
+ * JSX; each chart supplies its own already-resolved `hint` (a translation key
+ * resolved via `t()`, or a literal string) so per-chart messaging is preserved.
+ */
+interface ChartStateProps {
+    height?: string | number;
+    /** Already-resolved hint text (caller resolves its own i18n key) */
+    hint?: React.ReactNode;
+}
+/**
+ * Empty / no-data state (muted styling). `titleKey` defaults to the generic
+ * "No data available" heading but can be overridden (e.g. for the post-transform
+ * "No valid data" state).
+ */
+export declare function ChartEmptyState({ height, hint, titleKey }: ChartStateProps & {
+    titleKey?: string;
+}): React.JSX.Element;
+/**
+ * Invalid-configuration state (warning styling). Title is always
+ * "Configuration Error"; the chart supplies a hint describing what is missing.
+ */
+export declare function ChartConfigError({ height, hint }: ChartStateProps): React.JSX.Element;
+/**
+ * Render-error state (error styling), used in chart `catch` blocks.
+ */
+export declare function ChartRenderError({ height, chartType, error }: {
+    height?: string | number;
+    /** Display name used in the "{chartType} Error" heading */
+    chartType: string;
+    error: unknown;
+}): React.JSX.Element;
+export {};

package/dist/client/components/charts/ChartTooltip.d.ts

@@ -3,5 +3,5 @@ interface ChartTooltipProps {
     formatter?: (value: any, name: any, props: any) => [React.ReactText, React.ReactText];
     labelFormatter?: (label: any, payload?: readonly any[]) => React.ReactText;
 }
-export default function ChartTooltip({ formatter, labelFormatter }: ChartTooltipProps): import("react/jsx-runtime").JSX.Element;
+export default function ChartTooltip({ formatter, labelFormatter }: ChartTooltipProps): React.JSX.Element;
 export {};