drizzle-cube 0.6.7 → 0.7.1

package/dist/adapters/{utils-G52pPkce.js → utils-DboNUT3A.js}

@@ -542,7 +542,7 @@ var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescr
 	"chart.configText.add_2_or_more_measures_they_become_the_x_axis_categories_in_the_order_li": "Add 2 or more measures — they become the X-axis categories in the order listed",
 	"chart.configText.add_an_accent_colored_border_on_one_side_of_the_content": "Add an accent-colored border on one side of the content",
 	"chart.configText.all_fields_to_display_as_columns": "All fields to display as columns",
-	"chart.configText.array_of_value_0_1_fraction_color_bands_shown_as_outer_arc_markers": "Array of {value (0–1 fraction), color} bands shown as outer arc markers",
+	"chart.gauge.thresholds.description": "Each band runs from its value up to the next one. Values are on the gauge’s own scale.",
 	"chart.configText.axes_categories": "Axes (Categories)",
 	"chart.configText.bubble_colour": "Bubble Colour",
 	"chart.configText.bubble_labels": "Bubble Labels",
@@ -1439,11 +1439,29 @@ var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescr
 	"dashboard.deletePortletConfirm": "Are you sure you want to delete",
 	"dashboard.deletePortletSuffix": "? This action cannot be undone.",
 	"dashboard.thisPortlet": "this portlet",
+	"dashboard.portlet.action.edit": "Edit portlet",
+	"dashboard.portlet.action.duplicate": "Duplicate portlet",
+	"dashboard.portlet.action.delete": "Delete portlet",
+	"dashboard.portlet.action.refresh": "Refresh portlet",
+	"dashboard.portlet.action.drag": "Drag portlet",
+	"dashboard.portlet.action.filterConfig": "Configure dashboard filters",
+	"dashboard.portlet.action.filterConfigActive": "Configure dashboard filters ({count} active)",
+	"dashboard.group.rename": "Rename group",
+	"dashboard.group.drag": "Drag group",
+	"dashboard.group.titlePlaceholder": "Group title",
+	"dashboard.group.ungroup": "Ungroup",
+	"dashboard.group.delete": "Delete group",
+	"dashboard.group.deleteTitle": "Delete Group",
+	"dashboard.group.deleteConfirm": "Are you sure you want to delete this group and all {count} portlets inside it? This action cannot be undone.",
 	"dashboard.editModal.dashboardName": "Dashboard Name",
 	"dashboard.editModal.enterDashboardName": "Enter dashboard name...",
 	"dashboard.editModal.descriptionOptional": "Description (optional)",
 	"dashboard.editModal.enterDescription": "Enter description...",
 	"portlet.configRequired": "Configuration Required",
+	"portlet.copyToClipboard": "Copy chart to clipboard",
+	"portlet.copied": "Copied!",
+	"portlet.downloadXlsx": "Download data as XLSX",
+	"portlet.exporting": "Exporting...",
 	"portlet.configRequiredHint": "Please configure this chart",
 	"portlet.queryError": "Query Error",
 	"portlet.queryWithFilters": "Query (with filters applied)",
@@ -1567,7 +1585,11 @@ var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescr
 	"chart.option.proportionBarLabels.label": "Show labels",
 	"chart.runtime.summarySince": "since {period}",
 	"chart.option.showPoints.label": "Show data points",
-	"chart.option.showPoints.description": "Draw a marker at every data point. Turn off for dense series, where the markers obscure the line"
+	"chart.option.showPoints.description": "Draw a marker at every data point. Turn off for dense series, where the markers obscure the line",
+	"chart.gauge.thresholds.from": "Band starts at",
+	"chart.gauge.thresholds.colour": "Band colour",
+	"chart.gauge.thresholds.add": "Add band",
+	"chart.gauge.thresholds.remove": "Remove band"
 };
 function f(e, t) {
 	let n = d[e];

package/dist/adapters/utils.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utils-DJ0_72_G.cjs");exports.buildTransformedQuery=e.t,exports.calculateQueryComplexity=e.n,exports.formatCubeResponse=e.r,exports.formatErrorResponse=e.i,exports.formatMetaResponse=e.a,exports.formatSqlResponse=e.o,exports.formatSqlString=e.S,exports.generateRequestId=e.s,exports.getDatabaseType=e.c,exports.handleBatchRequest=e.l,exports.handleDiscover=e.p,exports.handleDryRun=e.u,exports.handleLoad=e.m,exports.handleSuggest=e.d,exports.handleValidate=e.f,exports.normalizeQueryFields=e.h;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utils-BoOeig94.cjs");exports.buildTransformedQuery=e.t,exports.calculateQueryComplexity=e.n,exports.formatCubeResponse=e.r,exports.formatErrorResponse=e.i,exports.formatMetaResponse=e.a,exports.formatSqlResponse=e.o,exports.formatSqlString=e.S,exports.generateRequestId=e.s,exports.getDatabaseType=e.c,exports.handleBatchRequest=e.l,exports.handleDiscover=e.p,exports.handleDryRun=e.u,exports.handleLoad=e.m,exports.handleSuggest=e.d,exports.handleValidate=e.f,exports.normalizeQueryFields=e.h;

package/dist/adapters/utils.js

@@ -1,2 +1,2 @@
-import { S as e, a as t, c as n, d as r, f as i, h as a, i as o, l as s, m as c, n as l, o as u, p as d, r as f, s as p, t as m, u as h } from "./utils-G52pPkce.js";
+import { S as e, a as t, c as n, d as r, f as i, h as a, i as o, l as s, m as c, n as l, o as u, p as d, r as f, s as p, t as m, u as h } from "./utils-DboNUT3A.js";
 export { m as buildTransformedQuery, l as calculateQueryComplexity, f as formatCubeResponse, o as formatErrorResponse, t as formatMetaResponse, u as formatSqlResponse, e as formatSqlString, p as generateRequestId, n as getDatabaseType, s as handleBatchRequest, d as handleDiscover, h as handleDryRun, c as handleLoad, r as handleSuggest, i as handleValidate, a as normalizeQueryFields };

package/dist/cjs/client/charts/chartConfigs.d.ts

@@ -28,7 +28,7 @@ export interface DisplayOptionConfig {
     /** Display label for the option */
     label: string;
     /** Type of input control to render */
-    type: 'boolean' | 'string' | 'number' | 'select' | 'color' | 'paletteColor' | 'axisFormat' | 'stringArray' | 'buttonGroup';
+    type: 'boolean' | 'string' | 'number' | 'select' | 'color' | 'paletteColor' | 'axisFormat' | 'stringArray' | 'buttonGroup' | 'thresholdBands';
     /** Default value for the option */
     defaultValue?: any;
     /** Placeholder text for string/number inputs */

package/dist/cjs/client/components/DashboardPortletCard.d.ts

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 import { DashboardPortletCardProps } from './dashboardPortletCard/propsEqual.js';
-declare const DashboardPortletCard: React.MemoExoticComponent<({ portlet, editable, layoutMode, dashboardFilters, configEagerLoad, loadingComponent, colorPalette, containerProps, headerProps, setPortletRef, setPortletComponentRef, callbacks, icons }: DashboardPortletCardProps) => React.JSX.Element>;
+declare const DashboardPortletCard: React.MemoExoticComponent<({ portlet, editable, layoutMode, dashboardFilters, configEagerLoad, loadingComponent, colorPalette, containerProps, headerProps, variant, setPortletRef, setPortletComponentRef, callbacks, icons }: DashboardPortletCardProps) => React.JSX.Element>;
 export default DashboardPortletCard;

package/dist/cjs/client/components/PortletGroupCard.d.ts

@@ -0,0 +1,18 @@
+import { DragEvent, HTMLAttributes, ReactNode } from 'react';
+import { PortletConfig, PortletGroup } from '../types.js';
+export interface PortletGroupCardProps {
+    group: PortletGroup;
+    portlets: Map<string, PortletConfig>;
+    canEdit: boolean;
+    /** Renders one child portlet with group chrome (no border, no header). */
+    renderChild: (portlet: PortletConfig, wrapperProps: HTMLAttributes<HTMLDivElement>) => ReactNode;
+    onRename: (groupId: string, title: string) => void;
+    onUngroup: (groupId: string) => void;
+    onDelete: (groupId: string) => void;
+    /** Fired when a child starts being dragged out of, or around within, the group. */
+    onChildDragStart: (groupId: string, portletId: string, event: DragEvent<HTMLDivElement>) => void;
+    onChildDragEnd: () => void;
+    /** Snap bands rendered inside each child; supplied by the row layout. */
+    renderSnapBands?: (portletId: string) => ReactNode;
+}
+export default function PortletGroupCard({ group, portlets, canEdit, renderChild, onRename, onUngroup, onDelete, onChildDragStart, onChildDragEnd, renderSnapBands }: PortletGroupCardProps): import("react").JSX.Element;

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

@@ -1,19 +1,31 @@
 import { HTMLAttributes, ReactNode, MouseEvent, DragEvent } from 'react';
-import { DashboardGridSettings, PortletConfig, RowLayout } from '../types.js';
+import { DashboardGridSettings, PortletConfig, PortletGroup, RowLayout } from '../types.js';
+import { SnapEdge } from '../hooks/dashboard/groupUtils.js';
 interface RowManagedLayoutProps {
     rows: RowLayout[];
     portlets: PortletConfig[];
+    groups?: PortletGroup[];
     gridSettings: DashboardGridSettings;
     gridWidth: number;
     canEdit: boolean;
     isDragging: boolean;
     onRowResize: (rowIndex: number, event: MouseEvent<HTMLDivElement>) => void;
     onColumnResize: (rowIndex: number, columnIndex: number, event: MouseEvent<HTMLDivElement>) => void;
-    onPortletDragStart: (rowIndex: number, columnIndex: number, portletId: string, event: DragEvent<HTMLDivElement>) => void;
+    onPortletDragStart: (rowIndex: number, columnIndex: number, portletId: string, event: DragEvent<HTMLDivElement>, 
+    /** Set when the whole column is a group being moved, not a single portlet. */
+    groupId?: string) => void;
     onPortletDragEnd: () => void;
     onRowDrop: (rowIndex: number, insertIndex: number | null) => void;
     onNewRowDrop: (insertIndex: number) => void;
+    /** Snap the dragged portlet against `edge` of `targetPortletId`. */
+    onSnapDrop?: (targetPortletId: string, edge: SnapEdge) => void;
+    /** Id of the portlet currently being dragged, so it can ignore its own bands. */
+    draggingPortletId?: string | null;
+    /** Id of the group currently being dragged, so its members ignore their bands. */
+    draggingGroupId?: string | null;
     renderPortlet: (portlet: PortletConfig, containerProps?: HTMLAttributes<HTMLDivElement>, headerProps?: HTMLAttributes<HTMLDivElement>) => ReactNode;
+    /** Renders a group column. Omitted in contexts that have no groups. */
+    renderGroup?: (group: PortletGroup, renderSnapBands: (portletId: string) => ReactNode) => ReactNode;
 }
-export default function RowManagedLayout({ rows, portlets, gridSettings, gridWidth, canEdit, isDragging, onRowResize, onColumnResize, onPortletDragStart, onPortletDragEnd, onRowDrop, onNewRowDrop, renderPortlet }: RowManagedLayoutProps): import("react").JSX.Element;
+export default function RowManagedLayout({ rows, portlets, groups, gridSettings, gridWidth, canEdit, isDragging, onRowResize, onColumnResize, onPortletDragStart, onPortletDragEnd, onRowDrop, onNewRowDrop, onSnapDrop, draggingPortletId, draggingGroupId, renderPortlet, renderGroup }: RowManagedLayoutProps): import("react").JSX.Element;
 export {};

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

@@ -1,4 +1,12 @@
 import { default as React } from 'react';
 import { ChartProps } from '../../types.js';
+/**
+ * Gauge chart: a 270° dial whose arc *is* the threshold banding — one thick,
+ * rounded segment per threshold with a small gap between them — read by a
+ * tapered needle, with numeric scale labels at the band boundaries and the
+ * measure label + value stacked below the centre.
+ *
+ * All geometry lives in `gaugeChartHelpers.ts`; this component only renders it.
+ */
 declare const GaugeChart: React.MemoExoticComponent<({ data, chartConfig, displayConfig, height, }: ChartProps) => React.JSX.Element>;
 export default GaugeChart;

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

@@ -1,36 +1,141 @@
 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.
+ * Co-located geometry/value maths for {@link GaugeChart}.
+ *
+ * Everything here is pure so the component stays declarative: it reads a
+ * layout, a list of band segments, a list of scale ticks and a needle path,
+ * then renders them.
+ *
+ * ## Angle convention
+ * d3-shape's: `0` points at 12 o'clock and positive angles run clockwise. The
+ * dial sweeps 270°, from `START_ANGLE` (-135°, lower-left) to `END_ANGLE`
+ * (+135°, lower-right).
+ *
+ * ## Threshold semantics
+ * A {@link ThresholdBand}'s `value` is the **lower bound** of its band, as a
+ * 0–1 fraction of the min→max range. So `[{0, red}, {0.5, amber}, {0.7, green}]`
+ * paints 0–50% red, 50–70% amber and 70–100% green. This matches
+ * {@link resolveColor}, and the invariant
+ * `bandContaining(f).color === resolveColor(f)` holds for every `f` in [0, 1).
  */
+/** Dial start: -135°, lower-left. */
 export declare const START_ANGLE: number;
+/** Dial end: +135°, lower-right. */
 export declare const END_ANGLE: number;
-export declare const TRACK_COLOR = "#e2e8f0";
-export declare const DEFAULT_FILL = "#6366f1";
+/** Total dial sweep in radians (270°). */
+export declare const ANGLE_SPAN: number;
+/** Neutral band colour for the region below every configured threshold. */
+export declare const DEFAULT_FILL = "var(--dc-accent)";
+/** Angular gap rendered between adjacent band segments (radians, ~2.3°). */
+export declare const BAND_GAP_RADIANS = 0.04;
+/**
+ * Height of the 270° arc's bounding box as a multiple of its radius.
+ * The arc spans y from `-r` (top) to `+r·cos45°` (the two lower tips).
+ */
+export declare const ARC_BBOX_HEIGHT_RATIO: number;
+/** Width of the 270° arc's bounding box as a multiple of its radius. */
+export declare const ARC_BBOX_WIDTH_RATIO = 2;
 export declare function parseNum(v: unknown): number | null;
 export declare function clamp(v: number, lo: number, hi: number): number;
+/** A finite `value`, or `fallback` when it is undefined / NaN / infinite. */
+export declare function finiteOr(value: number | undefined | null, fallback: number): number;
+/** Map a 0–1 fraction of the range onto its dial angle. */
+export declare function fractionToAngle(fraction: number): number;
 export declare function valueToAngle(value: number, min: number, max: number): number;
+/** Cartesian point at `angle`/`radius` in the d3 angle convention. */
+export declare function polarPoint(angle: number, radius: number): {
+    x: number;
+    y: number;
+};
 export declare function resolveColor(fraction: number, thresholds: ThresholdBand[]): string;
-export declare function buildArcPath(innerRadius: number, outerRadius: number, startAngle: number, endAngle: number): string;
+export declare function buildArcPath(innerRadius: number, outerRadius: number, startAngle: number, endAngle: number, cornerRadius?: number): string;
 /** Parse the displayConfig.thresholds value (array or JSON string) into bands. */
 export declare function parseThresholds(raw: unknown): ThresholdBand[];
+/** Clamp threshold fractions into [0, 1] and sort them ascending. */
+export declare function normalizeThresholds(thresholds: ThresholdBand[]): ThresholdBand[];
 export interface ThresholdArcBand {
     color: string;
-    start: number;
-    end: number;
+    /** Lower bound of the band, as a 0–1 fraction of the min→max range. */
+    startFraction: number;
+    /** Upper bound of the band, as a 0–1 fraction of the min→max range. */
+    endFraction: number;
+    /** Dial angle of {@link startFraction}. */
+    startAngle: number;
+    /** Dial angle of {@link endFraction}. */
+    endAngle: number;
 }
-/** Build the outer-ring threshold arc bands (in fraction space 0..1). */
+/**
+ * Split the dial into coloured bands. The bands tile the whole 0–1 range with
+ * no holes: a leading neutral band covers anything below the first threshold,
+ * and the last threshold's band runs to 1. Zero-width bands (duplicate
+ * thresholds, or one pinned at 1) are dropped.
+ *
+ * With no thresholds configured the dial is a single neutral band, so the
+ * gauge still renders a full arc.
+ */
 export declare function buildThresholdBands(thresholds: ThresholdBand[]): ThresholdArcBand[];
+export interface GaugeBandSegment {
+    color: string;
+    startAngle: number;
+    endAngle: number;
+}
+/**
+ * Turn logical bands into drawable segments by inserting a gap at every
+ * *internal* boundary (the dial's outer ends keep the full 270° sweep).
+ * Segments too narrow to render cleanly with rounded caps are dropped.
+ */
+export declare function buildBandSegments(bands: ThresholdArcBand[], gap?: number): GaugeBandSegment[];
+export interface GaugeScaleTick {
+    fraction: number;
+    value: number;
+    angle: number;
+}
+/**
+ * Numeric scale ticks at the band boundaries (plus the dial's start and end).
+ * Ticks are thinned back-to-front so the max is always kept and no two labels
+ * collide.
+ */
+export declare function buildScaleTicks(bands: ThresholdArcBand[], minValue: number, maxValue: number): GaugeScaleTick[];
+/** Triangular needle: wide at the hub, tapering to a point at `length`. */
+export declare function buildNeedlePath(angle: number, length: number, halfWidth: number): string;
+export interface GaugeLayout {
+    /** Dial centre in SVG coordinates. */
+    cx: number;
+    cy: number;
+    radius: number;
+    outerRadius: number;
+    innerRadius: number;
+    /** Corner radius that fully rounds a band segment's ends. */
+    bandCornerRadius: number;
+    /** Radius at which scale tick labels are centred (just inside the band). */
+    tickRadius: number;
+    needleLength: number;
+    needleHalfWidth: number;
+    hubRadius: number;
+    tickFontSize: number;
+    labelFontSize: number;
+    labelY: number;
+    valueFontSize: number;
+    valueY: number;
+}
+/**
+ * Size and position the dial so its 270° bounding box is centred in, and fits
+ * inside, a `width` x `height` box. Everything else is expressed as a ratio of
+ * the resulting radius so the gauge scales smoothly.
+ */
+export declare function computeGaugeLayout(width: number, height: number): GaugeLayout;
 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. */
+/** Compute the gauge's clamped value, fraction, indicated colour and angle. */
 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. */
+/**
+ * Format a gauge value. With a configured axis format this honours its unit,
+ * decimals and abbreviation (so a percent format renders `66.9%`); without one
+ * it falls back to the shared default numeric formatting (`66.94`).
+ */
 export declare function formatGaugeValue(value: number, yAxisFormat?: AxisFormatConfig): string;

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

@@ -3,7 +3,7 @@ import { LayoutItem, Layout } from 'react-grid-layout';
 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';
+import { DashboardConfig, PortletConfig, DashboardFilter, DashboardFilterMapping, CubeMeta, DashboardLayoutMode, DashboardGridSettings, RowLayout, PortletGroup, FeaturesConfig } from '../../types.js';
 /**
  * Props accepted by DashboardProvider (the public composable entry point).
  * Mirrors the former DashboardGridProps plus `hideToolbar` and `children`.
@@ -55,6 +55,7 @@ export interface DashboardContextValue {
     isFilterConfigModalOpen: boolean;
     filterConfigPortlet: PortletConfig | null;
     deleteConfirmPortletId: string | null;
+    deleteConfirmGroupId: string | null;
     draftRows: RowLayout[] | null;
     isDraggingPortlet: boolean;
     isInitialized: boolean;
@@ -62,8 +63,11 @@ export interface DashboardContextValue {
     canChangeLayoutMode: boolean;
     selectedFilter: DashboardFilter | null;
     resolvedRows: RowLayout[];
+    resolvedGroups: PortletGroup[];
     layoutMode: DashboardLayoutMode;
     allowedModes: DashboardLayoutMode[];
+    /** Modes the toggle should offer; a subset of allowedModes. */
+    selectableModes: DashboardLayoutMode[];
     actions: UseDashboardActions;
     displayMode: DashboardDisplayMode;
     scaleFactor: number;

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

@@ -1,10 +1,8 @@
 import { CSSProperties } from 'react';
-import { DashboardConfig, DashboardGridSettings, RowLayoutColumn } from '../../types.js';
+import { DashboardConfig, DashboardGridSettings } from '../../types.js';
 export declare const DEFAULT_GRID_SETTINGS: DashboardGridSettings;
-export declare const createRowId: () => string;
+export { createRowId, equalizeRowColumns, equalizeColumns, adjustRowWidths, adjustInsertIndexForRemovedRow } from '../../hooks/dashboard/layoutUtils.js';
 export declare const getGridSettings: (config: DashboardConfig) => DashboardGridSettings;
-export declare const equalizeRowColumns: (portletIds: string[], gridSettings: DashboardGridSettings) => RowLayoutColumn[];
-export declare const adjustRowWidths: (columns: RowLayoutColumn[], gridSettings: DashboardGridSettings) => RowLayoutColumn[];
 /**
  * Finds the nearest scrollable ancestor of an element.
  * Used to detect scroll container for lazy loading IntersectionObserver.

package/dist/cjs/client/components/dashboardPortletCard/EditActionButtons.d.ts

@@ -0,0 +1,34 @@
+import { default as React, CSSProperties, ComponentType } from 'react';
+import { PortletConfig } from '../../types.js';
+export declare const ICON_STYLE: CSSProperties;
+export interface CardIcons {
+    RefreshIcon: ComponentType<{
+        className?: string;
+        style?: CSSProperties;
+    }>;
+    EditIcon: ComponentType<{
+        className?: string;
+        style?: CSSProperties;
+    }>;
+    DeleteIcon: ComponentType<{
+        className?: string;
+        style?: CSSProperties;
+    }>;
+    CopyIcon: ComponentType<{
+        className?: string;
+        style?: CSSProperties;
+    }>;
+    FilterIcon: ComponentType<{
+        className?: string;
+        style?: CSSProperties;
+    }>;
+}
+export interface EditActionButtonsProps {
+    portlet: PortletConfig;
+    icons: CardIcons;
+    onOpenFilterConfig: () => void;
+    onDuplicate: () => void;
+    onEdit: () => void;
+    onDelete: () => void;
+}
+export default function EditActionButtons({ portlet, icons, onOpenFilterConfig, onDuplicate, onEdit, onDelete }: EditActionButtonsProps): React.JSX.Element;

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

@@ -1,17 +1,7 @@
-import { default as React, CSSProperties, ComponentType } from 'react';
+import { default as React, CSSProperties } 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;
-}
+import { CardIcons } from './EditActionButtons.js';
 interface PortletCardHeaderProps {
     portlet: PortletConfig;
     className: string;

package/dist/cjs/client/components/dashboardPortletCard/PortletFloatingActions.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { PortletConfig } from '../../types.js';
+import { CardIcons } from './EditActionButtons.js';
+interface PortletFloatingActionsProps {
+    portlet: PortletConfig;
+    icons: CardIcons;
+    /** Show the edit-only actions (drag, filter config, duplicate, edit, delete). */
+    showEditActions: boolean;
+    copyAvailable: boolean;
+    copySuccess: boolean;
+    xlsExportAvailable: boolean;
+    exportInProgress: boolean;
+    onRefresh: (options?: {
+        bustCache?: 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 PortletFloatingActions({ portlet, icons, showEditActions, copyAvailable, copySuccess, xlsExportAvailable, exportInProgress, onRefresh, onCopyToClipboard, onExportXlsx, onOpenFilterConfig, onDuplicate, onEdit, onDelete }: PortletFloatingActionsProps): React.JSX.Element;
+export {};

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

@@ -1,5 +1,7 @@
 import { CSSProperties } from 'react';
 import { ChartType, ChartDisplayConfig } from '../../types.js';
+/** How much chrome a card draws. Group children are frameless and headerless. */
+export type PortletCardVariant = 'standalone' | 'groupChild';
 export interface PortletDisplayModes {
     isMarkdownAutoHeight: boolean;
     isTransparentContent: boolean;
@@ -17,12 +19,14 @@ export declare function resolveDisplayModes(params: {
     layoutMode: string;
     isEditMode: boolean;
     portletTitle?: string;
+    variant?: PortletCardVariant;
 }): PortletDisplayModes;
 export declare function buildContainerClassName(params: {
     isTransparent: boolean;
     isMarkdownAutoHeight: boolean;
     isInSelectionMode: boolean;
     extraClassName?: string;
+    variant?: PortletCardVariant;
 }): string;
 export declare function buildHeaderClassName(isEditMode: boolean, extraClassName?: string): string;
 export declare function buildContainerStyle(params: {
@@ -30,4 +34,5 @@ export declare function buildContainerStyle(params: {
     isInSelectionMode: boolean;
     hasSelectedFilter: boolean;
     containerStyle?: CSSProperties;
+    variant?: PortletCardVariant;
 }): CSSProperties;

package/dist/cjs/client/components/dashboardPortletCard/propsEqual.d.ts

@@ -1,10 +1,12 @@
 import { HTMLAttributes, ReactNode, ComponentType, CSSProperties } from 'react';
 import { ChartType, DashboardFilter, DashboardLayoutMode, PortletConfig } from '../../types.js';
+import { PortletCardVariant } from './cardStyles.js';
 import { ColorPalette } from '../../utils/colorPalettes.js';
 export interface DashboardPortletCardProps {
     portlet: PortletConfig;
     editable: boolean;
     layoutMode?: DashboardLayoutMode;
+    variant?: PortletCardVariant;
     dashboardFilters?: DashboardFilter[];
     configEagerLoad?: boolean;
     loadingComponent?: ReactNode;

package/dist/cjs/client/components/mobileStackedLayout/memberDisplay.d.ts

@@ -0,0 +1,21 @@
+import { ChartAxisConfig, ChartDisplayConfig, ChartType, PortletConfig } from '../../types.js';
+export interface MobilePortletDisplay {
+    query: string;
+    chartType: ChartType;
+    chartConfig?: ChartAxisConfig;
+    displayConfig?: ChartDisplayConfig;
+    isTransparent: boolean;
+    isAutoHeight: boolean;
+    shouldHideHeader: boolean;
+    /** Outer height in px; `isAutoHeight` callers ignore it. */
+    height: number;
+    /** Height available to the chart once header and padding are removed. */
+    contentHeight: number;
+}
+export declare function resolveMobilePortletDisplay(params: {
+    portlet: PortletConfig;
+    /** False for a portlet inside a group card, which supplies its own frame. */
+    framed: boolean;
+    /** How many portlets share the group card, so its height can be shared out. */
+    memberCount: number;
+}): MobilePortletDisplay;

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

@@ -14,4 +14,4 @@ export { default as DashboardEditModal } from './components/DashboardEditModal.j
 export { default as Modal } from './components/Modal.js';
 export { default as AnalysisDisplayConfigPanel } from './components/AnalysisBuilder/AnalysisDisplayConfigPanel.js';
 export { createDashboardLayout, generateResponsiveLayouts, generatePortletId, findNextPosition, validateCubeQuery, createSamplePortlet } from './utils/index.js';
-export type { PortletConfig, DashboardConfig } from './types.js';
+export type { PortletConfig, DashboardConfig, PortletGroup, PortletGroupCell } from './types.js';

package/dist/cjs/client/hooks/dashboard/groupGeometry.d.ts

@@ -0,0 +1,23 @@
+import { PortletGroup } from '../../types.js';
+/** Edge of a card a drag can be dropped against. Lives here, not in
+ *  `groupUtils`, so `layoutUtils` can name it without importing back. */
+export type SnapEdge = 'top' | 'right' | 'bottom' | 'left';
+/**
+ * Split `total` integer units across `weights` using largest-remainder, never
+ * handing out less than 1. When `total < weights.length` every entry still gets
+ * 1 and the result overflows - callers accept that rather than dropping a
+ * portlet to zero size.
+ */
+export declare function partitionUnits(total: number, weights: number[]): number[];
+/**
+ * Grid-unit rectangle for every portlet in a group, given the rectangle the
+ * group itself occupies. Written back onto the portlets so grid mode, the
+ * mobile stack and thumbnails keep working without knowing groups exist.
+ */
+export declare function deriveGroupGeometry(group: PortletGroup, x: number, y: number, w: number, h: number): Array<{
+    portletId: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}>;

package/dist/cjs/client/hooks/dashboard/groupUtils.d.ts

@@ -0,0 +1,57 @@
+import { DashboardGridSettings, PortletConfig, PortletGroup, RowLayout } from '../../types.js';
+import { SnapEdge } from './groupGeometry.js';
+export { deriveGroupGeometry, partitionUnits } from './groupGeometry.js';
+export type { SnapEdge } from './groupGeometry.js';
+export interface GroupLayoutState {
+    rows: RowLayout[];
+    groups: PortletGroup[];
+}
+/** Where a portlet currently lives within the rows/groups structure. */
+export interface PortletLocation {
+    rowIndex: number;
+    colIndex: number;
+    /** Set when the portlet lives inside a group rather than owning its column. */
+    groupId?: string;
+    cellIndex?: number;
+    stackIndex?: number;
+}
+export declare const createGroupId: () => string;
+/** Portlet ids in visual order: cells along the main axis, stacks within each. */
+export declare const groupPortletIds: (group: PortletGroup) => string[];
+/** Locate a portlet across rows and groups. Returns null when it is unplaced. */
+export declare function findPortletLocation(rows: RowLayout[], groups: PortletGroup[], portletId: string): PortletLocation | null;
+/** Remove a portlet from whichever group holds it. Empty cells/groups are pruned. */
+export declare function removeFromGroup(groups: PortletGroup[], portletId: string): {
+    groups: PortletGroup[];
+    groupId: string | null;
+};
+/**
+ * Reconcile groups against the portlets that exist and the rows that host them.
+ *
+ * Returns rows as well as groups, because the two are coupled: collapsing a
+ * one-portlet group has to rewrite its column back to a plain `portletId`, and
+ * pruning a group has to remove its column. **Always run this before
+ * `normalizeRows`** - otherwise `normalizeRows` sees a `groupId` column whose
+ * group has just been emptied and renders a blank card.
+ */
+export declare function normalizeGroups(groups: PortletGroup[] | undefined, portlets: PortletConfig[], rows: RowLayout[], gridSettings: DashboardGridSettings): GroupLayoutState;
+/**
+ * Snap `movedPortletId` against an edge of `targetPortletId`.
+ *
+ * Left/right build a `row` group, top/bottom a `column` group. When the target
+ * is already grouped, a snap along the group's main axis adds a cell, and a
+ * perpendicular snap joins the target's stack (the depth-2 clamp).
+ *
+ * Returns null when the move is a no-op.
+ */
+export declare function snapIntoGroup(state: GroupLayoutState, movedPortletId: string, targetPortletId: string, edge: SnapEdge, gridSettings: DashboardGridSettings): GroupLayoutState | null;
+/**
+ * Dissolve a group, replacing its column with one column per member portlet in
+ * visual order. The row is re-equalised afterwards.
+ */
+export declare function ungroup(state: GroupLayoutState, groupId: string, gridSettings: DashboardGridSettings): GroupLayoutState;
+/** Remove a group and every portlet id it holds. Callers delete the portlets. */
+export declare function deleteGroup(state: GroupLayoutState, groupId: string, gridSettings: DashboardGridSettings): {
+    state: GroupLayoutState;
+    removedPortletIds: string[];
+};

package/dist/cjs/client/hooks/dashboard/layoutUtils.d.ts

@@ -1,7 +1,38 @@
-import { DashboardGridSettings, PortletConfig, RowLayout, RowLayoutColumn } from '../../types.js';
+import { DashboardGridSettings, PortletConfig, PortletGroup, RowLayout, RowLayoutColumn } from '../../types.js';
 export declare const createRowId: () => string;
+/**
+ * Correct a row insertion index for a source row that the move emptied.
+ *
+ * Splicing the source row out shifts every later index up by one, so an
+ * unadjusted index lands the row one position too low. `handleRowDrop` has
+ * always done this for column moves; new-row drops need it too, and hit it more
+ * often, because a group is usually the only column in its row.
+ */
+export declare const adjustInsertIndexForRemovedRow: (insertIndex: number, sourceRowIndex: number, sourceRowRemoved: boolean) => number;
+/**
+ * Distribute `cols` evenly across the given columns, preserving each column's
+ * identity (`portletId` **or** `groupId`) so re-equalisation never drops a group
+ * reference. This is the function to use; `equalizeRowColumns` below is the
+ * legacy id-only wrapper.
+ */
+export declare const equalizeColumns: (columns: RowLayoutColumn[], gridSettings: DashboardGridSettings) => RowLayoutColumn[];
+/**
+ * @deprecated Loses `groupId`. Use {@link equalizeColumns} with the real columns.
+ */
 export declare const equalizeRowColumns: (portletIds: string[], gridSettings: DashboardGridSettings) => RowLayoutColumn[];
 export declare const adjustRowWidths: (columns: RowLayoutColumn[], gridSettings: DashboardGridSettings) => RowLayoutColumn[];
 export declare const convertPortletsToRows: (portlets: PortletConfig[], gridSettings: DashboardGridSettings) => RowLayout[];
-export declare const normalizeRows: (rows: RowLayout[], portlets: PortletConfig[], gridSettings: DashboardGridSettings) => RowLayout[];
-export declare const convertRowsToPortlets: (rows: RowLayout[], portlets: PortletConfig[]) => PortletConfig[];
+/**
+ * Drop columns whose target no longer exists, clamp row height, re-balance
+ * widths. `groups` must be the already-normalized group list - a column
+ * referencing a group is kept only when that group survives, so run
+ * `normalizeGroups` first.
+ */
+export declare const normalizeRows: (rows: RowLayout[], portlets: PortletConfig[], gridSettings: DashboardGridSettings, groups?: PortletGroup[]) => RowLayout[];
+/**
+ * Re-derive every portlet's x/y/w/h from the row layout. Group columns are
+ * subdivided via `deriveGroupGeometry`, so grouped children get real grid
+ * coordinates too - that is what keeps grid mode, the mobile stack and
+ * thumbnails working without any knowledge of groups.
+ */
+export declare const convertRowsToPortlets: (rows: RowLayout[], portlets: PortletConfig[], groups?: PortletGroup[]) => PortletConfig[];