drizzle-cube 0.5.8 → 0.6.1

package/dist/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/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/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/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/client/components/charts/index.d.ts

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

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

@@ -0,0 +1,20 @@
+import { RefObject } from 'react';
+interface ChartDimensions {
+    containerRef: RefObject<HTMLDivElement>;
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    dimensionsReady: boolean;
+}
+/**
+ * Shared container-measurement hook for the D3/SVG charts (BubbleChart,
+ * ActivityGridChart).
+ *
+ * Performs an initial measurement with a requestAnimationFrame + setTimeout
+ * retry ladder (handles containers that aren't laid out yet), then keeps the
+ * dimensions in sync via a ResizeObserver and window resize. Mirrors the
+ * original per-component effects exactly.
+ */
+export declare function useChartDimensions(): ChartDimensions;
+export {};

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

@@ -0,0 +1,30 @@
+import { RefObject } from 'react';
+interface KpiDimensionOptions {
+    /** Container divisor for the width-based font size candidate. */
+    widthDivisor: number;
+    /** Container divisor for the height-based font size candidate. */
+    heightDivisor: number;
+    /** Minimum clamped font size. */
+    minFontSize: number;
+    /** Maximum clamped font size. */
+    maxFontSize: number;
+    /** Computes the measured-text width from the value element's box + container width. */
+    measureWidth: (measuredWidth: number, containerWidth: number) => number;
+    /** Re-run measurement whenever any of these change. */
+    deps: unknown[];
+}
+interface KpiDimensions {
+    containerRef: RefObject<HTMLDivElement>;
+    valueRef: RefObject<HTMLDivElement>;
+    fontSize: number;
+    textWidth: number;
+}
+/**
+ * Shared container-measurement hook for KPI cards (KpiNumber / KpiDelta).
+ *
+ * Measures the container to derive a responsive font size, then (after the font
+ * is applied) measures the rendered value element to size the histogram. Mirrors
+ * the original per-component effects exactly — only the tunable constants differ.
+ */
+export declare function useKpiDimensions({ widthDivisor, heightDivisor, minFontSize, maxFontSize, measureWidth, deps }: KpiDimensionOptions): KpiDimensions;
+export {};

package/dist/client/components/dashboard/DashboardContext.d.ts

@@ -1,9 +1,9 @@
 import { ReactNode, HTMLAttributes, DragEvent, MouseEvent, MutableRefObject } from 'react';
 import { LayoutItem, Layout } from 'react-grid-layout';
-import { UseDashboardActions } from '../../hooks/useDashboardHook';
-import { DashboardDisplayMode } from '../../hooks/useResponsiveDashboard';
-import { ColorPalette } from '../../utils/colorPalettes';
-import { DashboardConfig, PortletConfig, DashboardFilter, DashboardFilterMapping, CubeMeta, DashboardLayoutMode, DashboardGridSettings, RowLayout, FeaturesConfig } from '../../types';
+import { UseDashboardActions } from '../../hooks/useDashboardHook.js';
+import { DashboardDisplayMode } from '../../hooks/useResponsiveDashboard.js';
+import { ColorPalette } from '../../utils/colorPalettes.js';
+import { DashboardConfig, PortletConfig, DashboardFilter, DashboardFilterMapping, CubeMeta, DashboardLayoutMode, DashboardGridSettings, RowLayout, FeaturesConfig } from '../../types.js';
 /**
  * Props accepted by DashboardProvider (the public composable entry point).
  * Mirrors the former DashboardGridProps plus `hideToolbar` and `children`.
@@ -92,8 +92,8 @@ export interface DashboardContextValue {
         bustCache?: boolean;
     }) => void;
     handleLayoutChange: (layout: Layout) => void;
-    handleDragStop: (layout: Layout, oldItem: LayoutItem | null, newItem: LayoutItem | null, placeholder: LayoutItem | null, e: Event, element: HTMLElement | undefined) => void;
-    handleResizeStop: (layout: Layout, oldItem: LayoutItem | null, newItem: LayoutItem | null, placeholder: LayoutItem | null, e: Event, element: HTMLElement | undefined) => void;
+    handleDragStop: (layout: Layout, oldItem: LayoutItem | null, newItem: LayoutItem | null, placeholder: LayoutItem | null, e: Event, element: HTMLElement | null) => void;
+    handleResizeStop: (layout: Layout, oldItem: LayoutItem | null, newItem: LayoutItem | null, placeholder: LayoutItem | null, e: Event, element: HTMLElement | null) => void;
     startRowResize: (rowIndex: number, event: MouseEvent<HTMLDivElement>) => void;
     startColumnResize: (rowIndex: number, columnIndex: number, event: MouseEvent<HTMLDivElement>) => void;
     handlePortletDragStart: (rowIndex: number, colIndex: number, portletId: string, event: DragEvent<HTMLDivElement>) => void;

package/dist/client/components/dashboard/DashboardCoordinator.d.ts

@@ -1,2 +1,2 @@
-import { DashboardProviderProps } from './DashboardContext';
+import { DashboardProviderProps } from './DashboardContext.js';
 export default function DashboardCoordinator({ config, editable, dashboardFilters, loadingComponent, onConfigChange, onPortletRefresh, onSave, onSaveThumbnail, colorPalette, schema, onDashboardFiltersChange, dashboardModes, hideToolbar, children }: DashboardProviderProps): import("react").JSX.Element;

package/dist/client/components/dashboard/DashboardEditBar.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Sticky top edit bar for the dashboard toolbar. Reads everything from
+ * DashboardContext; rendered only when the top toolbar variant is active.
+ */
+export default function DashboardEditBar(): import("react").JSX.Element;

package/dist/client/components/dashboard/DashboardProvider.d.ts

@@ -1,2 +1,2 @@
-import { DashboardProviderProps } from './DashboardContext';
+import { DashboardProviderProps } from './DashboardContext.js';
 export default function DashboardProvider({ children, ...props }: DashboardProviderProps): import("react").JSX.Element;

package/dist/client/components/dashboard/LayoutModeToggle.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Grid / Rows layout-mode toggle used inside the dashboard edit bar.
+ */
+interface LayoutModeToggleProps {
+    layoutMode: string;
+    canChangeLayoutMode: boolean;
+    onLayoutModeChange: (mode: 'grid' | 'rows') => void;
+}
+export default function LayoutModeToggle({ layoutMode, canChangeLayoutMode, onLayoutModeChange }: LayoutModeToggleProps): import("react").JSX.Element;
+export {};

package/dist/client/components/dashboard/dashboardGridUtils.d.ts

@@ -1,5 +1,5 @@
 import { CSSProperties } from 'react';
-import { DashboardConfig, DashboardGridSettings, RowLayoutColumn } from '../../types';
+import { DashboardConfig, DashboardGridSettings, RowLayoutColumn } from '../../types.js';
 export declare const DEFAULT_GRID_SETTINGS: DashboardGridSettings;
 export declare const createRowId: () => string;
 export declare const getGridSettings: (config: DashboardConfig) => DashboardGridSettings;

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

@@ -4,10 +4,10 @@
  * Compose these under a DashboardProvider, or use the back-compat DashboardGrid
  * which wires them together for you.
  */
-export { default as DashboardProvider } from './DashboardProvider';
-export { default as DashboardToolbar } from './DashboardToolbar';
-export { default as DashboardFilterBar } from './DashboardFilterBar';
-export { default as DashboardGridSurface } from './DashboardGridSurface';
-export { default as DashboardModals } from './DashboardModals';
-export { useDashboardContext } from './DashboardContext';
-export type { DashboardContextValue, DashboardProviderProps } from './DashboardContext';
+export { default as DashboardProvider } from './DashboardProvider.js';
+export { default as DashboardToolbar } from './DashboardToolbar.js';
+export { default as DashboardFilterBar } from './DashboardFilterBar.js';
+export { default as DashboardGridSurface } from './DashboardGridSurface.js';
+export { default as DashboardModals } from './DashboardModals.js';
+export { useDashboardContext } from './DashboardContext.js';
+export type { DashboardContextValue, DashboardProviderProps } from './DashboardContext.js';

package/dist/client/components/dashboardPortletCard/FilterFieldChip.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties, ComponentType } from 'react';
+import { EffectiveFilterField } from './filterField.js';
+interface FilterFieldChipProps {
+    field: EffectiveFilterField;
+    FilterIcon: ComponentType<{
+        className?: string;
+        style?: CSSProperties;
+    }>;
+    onOpenFilterConfig: () => void;
+}
+export default function FilterFieldChip({ field, FilterIcon, onOpenFilterConfig }: FilterFieldChipProps): import("react").JSX.Element;
+export {};

package/dist/client/components/dashboardPortletCard/PortletCardHeader.d.ts

@@ -0,0 +1,43 @@
+import { default as React, CSSProperties, ComponentType } from 'react';
+import { PortletConfig } from '../../types.js';
+import { PortletDebugDataEntry } from '../../stores/dashboardStore.js';
+type IconComponent = ComponentType<{
+    className?: string;
+    style?: CSSProperties;
+}>;
+interface CardIcons {
+    RefreshIcon: IconComponent;
+    EditIcon: IconComponent;
+    DeleteIcon: IconComponent;
+    CopyIcon: IconComponent;
+    FilterIcon: IconComponent;
+}
+interface PortletCardHeaderProps {
+    portlet: PortletConfig;
+    className: string;
+    headerStyle?: CSSProperties;
+    restHeaderProps: Record<string, unknown>;
+    headerOnClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    editable: boolean;
+    isEditMode: boolean;
+    isInSelectionMode: boolean;
+    debugData?: PortletDebugDataEntry;
+    copyAvailable: boolean;
+    copySuccess: boolean;
+    xlsExportAvailable: boolean;
+    exportInProgress: boolean;
+    showCacheBustIndicator: boolean;
+    icons: CardIcons;
+    onRefresh: (options?: {
+        bustCache?: boolean;
+    }) => void;
+    onHoverRefreshChange: (hovering: boolean) => void;
+    onCopyToClipboard: (event: React.MouseEvent | React.TouchEvent) => void;
+    onExportXlsx: (event: React.MouseEvent | React.TouchEvent) => void;
+    onOpenFilterConfig: () => void;
+    onDuplicate: () => void;
+    onEdit: () => void;
+    onDelete: () => void;
+}
+export default function PortletCardHeader(props: PortletCardHeaderProps): React.JSX.Element;
+export {};

package/dist/client/components/dashboardPortletCard/cardStyles.d.ts

@@ -0,0 +1,33 @@
+import { CSSProperties } from 'react';
+import { ChartType, ChartDisplayConfig } from '../../types.js';
+export interface PortletDisplayModes {
+    isMarkdownAutoHeight: boolean;
+    isTransparentContent: boolean;
+    isTransparent: boolean;
+    shouldHideHeader: boolean;
+}
+/**
+ * Resolve the markdown / transparency / header-visibility display modes for a
+ * portlet from its chart type and display config. Extracted to keep the card
+ * component flat.
+ */
+export declare function resolveDisplayModes(params: {
+    renderChartType: ChartType;
+    renderDisplayConfig?: ChartDisplayConfig;
+    layoutMode: string;
+    isEditMode: boolean;
+    portletTitle?: string;
+}): PortletDisplayModes;
+export declare function buildContainerClassName(params: {
+    isTransparent: boolean;
+    isMarkdownAutoHeight: boolean;
+    isInSelectionMode: boolean;
+    extraClassName?: string;
+}): string;
+export declare function buildHeaderClassName(isEditMode: boolean, extraClassName?: string): string;
+export declare function buildContainerStyle(params: {
+    isTransparent: boolean;
+    isInSelectionMode: boolean;
+    hasSelectedFilter: boolean;
+    containerStyle?: CSSProperties;
+}): CSSProperties;

package/dist/client/components/dashboardPortletCard/filterField.d.ts

@@ -0,0 +1,12 @@
+import { DashboardFilter, PortletConfig } from '../../types.js';
+export interface EffectiveFilterField {
+    field: string;
+    isOverride: boolean;
+}
+export declare function resolveEffectiveFilterField(params: {
+    isInSelectionMode: boolean;
+    hasSelectedFilter: boolean;
+    selectedFilterId: string | null | undefined;
+    dashboardFilters?: DashboardFilter[];
+    dashboardFilterMapping: PortletConfig['dashboardFilterMapping'];
+}): EffectiveFilterField | null;