@svgrid/grid 2.2.16 → 2.2.18

package/dist/createTooltip.svelte.d.ts

@@ -5,6 +5,14 @@ export type TooltipConfig = {
     disabled?: () => boolean;
     /** Show delay in ms after hover/focus. Default 300. */
     delay?: () => number;
+    /** Hide delay in ms after leave/blur. Default 0. Give it room for interactive tips. */
+    closeDelay?: () => number;
+    /**
+     * Delay-group id. Tooltips sharing a group open INSTANTLY while any group
+     * member is open or was open within a short grace window - so scanning a
+     * toolbar of icon buttons does not re-wait the show delay each time.
+     */
+    group?: () => string | undefined;
 };
 export type TooltipAnchorProps = {
     'aria-describedby': string | undefined;
@@ -23,6 +31,10 @@ export declare function createTooltip(config?: TooltipConfig): {
     tipId: string;
     show: () => void;
     hide: () => void;
+    /** Keep an interactive tip open while the pointer is over it. */
+    keepOpen: () => void;
+    /** Delayed hide honoring `closeDelay` (pointer/focus leave). */
+    scheduleHide: () => void;
     /** Spread onto the anchor/trigger wrapper. Also mirror `tipId` onto the real
      *  focusable child's `aria-describedby` so AT announces it on focus. */
     anchorProps: () => TooltipAnchorProps;

package/dist/createTooltip.svelte.js

@@ -1,9 +1,10 @@
 /**
  * createTooltip - the HEADLESS core behind <SvTooltip>: the hover/focus open
- * state machine with a show delay, Escape-to-hide, and the `aria-describedby` /
- * `role="tooltip"` wiring - as prop-getters you spread onto your own anchor and
- * tooltip elements. No styles, no positioning (that is a DOM concern the renderer
- * owns), like `createListbox`.
+ * state machine with a show delay, an optional close delay, a shared delay-group
+ * (so moving between grouped tooltips skips the re-delay), Escape-to-hide, and the
+ * `aria-describedby` / `role="tooltip"` wiring - as prop-getters you spread onto
+ * your own anchor and tooltip elements. No styles, no positioning (that is a DOM
+ * concern the renderer owns), like `createListbox`.
  *
  * ```svelte
  * <script lang="ts">
@@ -17,20 +18,78 @@
  * ```
  */
 import { nextEditorId } from './editor-contract';
+/** Grace window (ms) after a group tooltip closes during which the next opens instantly. */
+const GROUP_SKIP_WINDOW = 300;
+const groupRegistry = new Map();
+function groupEntry(id) {
+    let e = groupRegistry.get(id);
+    if (!e) {
+        e = { openCount: 0, lastCloseAt: 0 };
+        groupRegistry.set(id, e);
+    }
+    return e;
+}
+const now = () => (typeof Date !== 'undefined' ? Date.now() : 0);
 export function createTooltip(config = {}) {
     const id = nextEditorId('sv-tip');
     let open = $state(false);
     let showTimer;
+    let hideTimer;
+    let counted = false; // whether this instance is currently counted in its group
+    function groupId() { return config.group?.(); }
+    /** Effective show delay: 0 when the group is warm (a member open / just closed). */
+    function effectiveDelay() {
+        const base = config.delay?.() ?? 300;
+        const g = groupId();
+        if (!g)
+            return base;
+        const e = groupEntry(g);
+        if (e.openCount > 0 || now() - e.lastCloseAt < GROUP_SKIP_WINDOW)
+            return 0;
+        return base;
+    }
+    function markOpen() {
+        open = true;
+        const g = groupId();
+        if (g && !counted) {
+            counted = true;
+            groupEntry(g).openCount++;
+        }
+    }
+    function reallyHide() {
+        open = false;
+        clearTimeout(showTimer);
+        clearTimeout(hideTimer);
+        const g = groupId();
+        if (g && counted) {
+            counted = false;
+            const e = groupEntry(g);
+            e.openCount--;
+            e.lastCloseAt = now();
+        }
+    }
     function show() {
         if ((config.disabled?.() ?? false) || !(config.text?.() ?? ''))
             return;
+        clearTimeout(hideTimer);
+        if (open)
+            return;
         clearTimeout(showTimer);
-        showTimer = setTimeout(() => { open = true; }, config.delay?.() ?? 300);
+        showTimer = setTimeout(markOpen, effectiveDelay());
     }
-    function hide() {
+    /** Delayed hide (honors `closeDelay`) - used by pointer/focus leave. */
+    function scheduleHide() {
         clearTimeout(showTimer);
-        open = false;
+        const cd = config.closeDelay?.() ?? 0;
+        if (cd > 0 && open) {
+            clearTimeout(hideTimer);
+            hideTimer = setTimeout(reallyHide, cd);
+        }
+        else
+            reallyHide();
     }
+    /** Immediate hide - used by Escape and imperative callers. */
+    function hide() { reallyHide(); }
     // Escape hides the tooltip while it is open (WAI-ARIA tooltip pattern).
     $effect(() => {
         if (!open)
@@ -46,14 +105,18 @@ export function createTooltip(config = {}) {
         tipId: id,
         show,
         hide,
+        /** Keep an interactive tip open while the pointer is over it. */
+        keepOpen: show,
+        /** Delayed hide honoring `closeDelay` (pointer/focus leave). */
+        scheduleHide,
         /** Spread onto the anchor/trigger wrapper. Also mirror `tipId` onto the real
          *  focusable child's `aria-describedby` so AT announces it on focus. */
         anchorProps: () => ({
             'aria-describedby': open ? id : undefined,
             onpointerenter: show,
-            onpointerleave: hide,
+            onpointerleave: scheduleHide,
             onfocusin: show,
-            onfocusout: hide,
+            onfocusout: scheduleHide,
         }),
         /** Spread onto the tooltip element. */
         tooltipProps: () => ({ id, role: 'tooltip' }),

package/dist/editor-contract.d.ts

@@ -10,6 +10,21 @@
  * Framework-free (no Svelte, no DOM) so it can be unit-tested and reused.
  */
 export type EditorSize = 'sm' | 'md' | 'lg';
+/**
+ * A small action button rendered inside a framed field (via `SvField`'s
+ * `actions`) - the generalized form of the clear / reveal buttons, for a lookup,
+ * a generate, a copy, etc. `icon` is a Svelte snippet; when absent the `label`
+ * text is shown. (Type-only Svelte import, so this module stays runtime-free.)
+ */
+export type EditorAction = {
+    /** Accessible name + tooltip for the button. */
+    label: string;
+    /** Invoked when the button is pressed. */
+    onClick: () => void;
+    /** Optional icon snippet; falls back to the `label` text. */
+    icon?: import('svelte').Snippet;
+    disabled?: boolean;
+};
 /** Text direction. `'auto'` defers to the surrounding document/CSS. */
 export type EditorDir = 'ltr' | 'rtl' | 'auto';
 /** Props shared by every value-bearing editor in the kit. */

package/dist/export-provider.d.ts

@@ -0,0 +1,27 @@
+/**
+ * export-provider seam. The free grid ships built-in text export (CSV / TSV /
+ * JSON via the api) but the rich Excel / PDF / HTML export engine lives in
+ * `@svgrid/enterprise`. `aiExport` (a free, built-in AI feature) plans an export
+ * and, when it needs to actually WRITE an enterprise format, delegates to the
+ * engine registered here. Enterprise registers `exportGrid` at install time; if
+ * it is absent, `aiExport` returns the plan without running the download.
+ *
+ * ```ts
+ * // in @svgrid/enterprise, at install:
+ * import { registerExportProvider } from '@svgrid/grid'
+ * import { exportGrid } from './export'
+ * registerExportProvider(exportGrid)
+ * ```
+ */
+import type { SvGridApi } from './index';
+export type GridExportRunOptions = {
+    format: string;
+    filename?: string;
+    rows?: ReadonlyArray<Record<string, unknown>>;
+    groupBy?: string[];
+};
+export type GridExportProvider = (api: SvGridApi<any, any>, opts: GridExportRunOptions) => Promise<unknown>;
+/** Register the export engine that runs AI-planned exports. Enterprise calls this. */
+export declare function registerExportProvider(fn: GridExportProvider | null): void;
+/** The registered export engine, or null when @svgrid/enterprise is not installed. */
+export declare function getExportProvider(): GridExportProvider | null;

package/dist/export-provider.js

@@ -0,0 +1,9 @@
+let provider = null;
+/** Register the export engine that runs AI-planned exports. Enterprise calls this. */
+export function registerExportProvider(fn) {
+    provider = fn;
+}
+/** The registered export engine, or null when @svgrid/enterprise is not installed. */
+export function getExportProvider() {
+    return provider;
+}

package/dist/filter-operators.d.ts

@@ -20,3 +20,9 @@ export declare function operatorsForColumn<TData extends RowData>(column: Column
 export declare function defaultOperatorFor<TData extends RowData>(column: Column<TData> | undefined): FilterOperator;
 /** Date columns get friendlier labels for "less / greater than". */
 export declare function operatorLabelFor<TData extends RowData>(option: FilterOption, column: Column<TData> | undefined): string;
+/**
+ * Localized operator label: honors date `Before`/`After` relabels, then the
+ * `localeText` override for the operator, falling back to the English
+ * `option.label`. `messages` is a loose string map to avoid a type cycle.
+ */
+export declare function localizeOperatorLabel<TData extends RowData>(option: FilterOption, column: Column<TData> | undefined, messages?: Record<string, string> | null): string;

package/dist/filter-operators.js

@@ -100,3 +100,36 @@ export function operatorLabelFor(option, column) {
     }
     return option.label;
 }
+/** GridMessages key for each operator's label (see grid-messages.ts). */
+const OPERATOR_MESSAGE_KEY = {
+    contains: "opContains",
+    notContains: "opNotContains",
+    equals: "opEquals",
+    notEquals: "opNotEquals",
+    startsWith: "opStartsWith",
+    endsWith: "opEndsWith",
+    regex: "opRegex",
+    in: "opIn",
+    notIn: "opNotIn",
+    greaterThan: "opGreaterThan",
+    lessThan: "opLessThan",
+    between: "opBetween",
+    isBlank: "opIsBlank",
+    isNotBlank: "opIsNotBlank",
+};
+/**
+ * Localized operator label: honors date `Before`/`After` relabels, then the
+ * `localeText` override for the operator, falling back to the English
+ * `option.label`. `messages` is a loose string map to avoid a type cycle.
+ */
+export function localizeOperatorLabel(option, column, messages) {
+    const editorType = column?.columnDef.editorType;
+    if (editorType === "date" || editorType === "datetime") {
+        if (option.value === "lessThan")
+            return messages?.opBefore || "Before";
+        if (option.value === "greaterThan")
+            return messages?.opAfter || "After";
+    }
+    const key = OPERATOR_MESSAGE_KEY[option.value];
+    return (key && messages?.[key]) || option.label;
+}

package/dist/form-field.d.ts

@@ -5,18 +5,59 @@ import type { Validator } from './validators';
  * `.svelte` component (which would create a `.svelte.ts` -> `.svelte` import
  * cycle Vite's dev import-analysis fails to resolve).
  */
-export type FormFieldType = 'text' | 'email' | 'tel' | 'textarea' | 'number' | 'password' | 'select' | 'checkbox' | 'switch' | 'date' | 'color' | 'rating' | 'array';
+export type FormFieldType = 'text' | 'email' | 'tel' | 'textarea' | 'number' | 'password' | 'select' | 'multiselect' | 'checkbox' | 'switch' | 'date' | 'color' | 'rating' | 'radio' | 'slider' | 'tags' | 'phone' | 'country' | 'mask' | 'datetime' | 'time' | 'daterange' | 'combobox' | 'file' | 'array';
 export type FormField = {
     name: string;
     label: string;
     type?: FormFieldType;
     required?: boolean;
+    /** Show the field but block edits (still submitted, unlike hidden fields). */
+    readonly?: boolean;
+    /** Helper text shown under the control (distinct from a validation error). */
+    help?: string;
     placeholder?: string;
+    /**
+     * Options for select/combobox/radio/multiselect. A function makes them CASCADE:
+     * the list is derived from the current form values (e.g. cities for the picked
+     * country). Pair with `dependsOn` so the child clears when the parent changes.
+     */
     options?: Array<{
         value: string | number;
         label: string;
         color?: string;
-    }>;
+    }> | ((values: Record<string, any>) => Array<{
+        value: string | number;
+        label: string;
+        color?: string;
+    }>);
+    /** Field name(s) this one depends on; when a parent changes, this field's value
+     *  is cleared (cascading selects). */
+    dependsOn?: string | string[];
+    /** Mask pattern for `type: 'mask'` (`#`=digit, `A`=letter, `*`=alnum). */
+    mask?: string;
+    /** Numeric bounds for `type: 'number'` / `'slider'`. */
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    /** Text affixes for `type: 'number'` (e.g. `$` / `%`). */
+    prefix?: string;
+    suffix?: string;
+    /** Remote option loader for `type: 'combobox'` (debounced typeahead). The
+     *  current form `values` are passed so it can depend on other fields. */
+    loadOptions?: (query: string, values: Record<string, any>) => Promise<Array<{
+        value: string | number;
+        label: string;
+    }>>;
+    /** File input hints for `type: 'file'`. */
+    accept?: string;
+    multiple?: boolean;
+    /**
+     * Derive this field's value from the other form values (e.g. a total). A
+     * computed field is read-only, recomputes reactively, is not user-validated,
+     * and its derived value is included in the submitted payload.
+     */
+    computed?: (values: Record<string, any>) => any;
     /** Declarative validation rules (see `rules` - email/pattern/min/compare...). */
     rules?: ReadonlyArray<Validator>;
     /** Return an error message, or null/undefined when valid. */
@@ -32,6 +73,8 @@ export type FormField = {
     asyncDebounce?: number;
     /** Span full width in the grid. */
     full?: boolean;
+    /** Columns to span (generalizes `full`); `2`+ widens the field in a grid. */
+    span?: number;
     /**
      * Show the field only when this is `true` / returns `true` (default: always).
      * A field derived from other values, e.g. `visible: (v) => v.hasAddress`.

package/dist/grid-messages.d.ts

@@ -0,0 +1,61 @@
+/** Every localizable chrome string, grouped by area in the comments. */
+export type GridMessages = {
+    noRows: string;
+    loading: string;
+    columns: string;
+    filters: string;
+    clearFilter: string;
+    pageSize: string;
+    page: string;
+    of: string;
+    firstPage: string;
+    prevPage: string;
+    nextPage: string;
+    lastPage: string;
+    statCount: string;
+    statSum: string;
+    statAvg: string;
+    statMin: string;
+    statMax: string;
+    group: string;
+    grandTotal: string;
+    total: string;
+    rowsSuffix: string;
+    rowSuffix: string;
+    opContains: string;
+    opNotContains: string;
+    opEquals: string;
+    opNotEquals: string;
+    opStartsWith: string;
+    opEndsWith: string;
+    opRegex: string;
+    opIn: string;
+    opNotIn: string;
+    opGreaterThan: string;
+    opLessThan: string;
+    opBetween: string;
+    opIsBlank: string;
+    opIsNotBlank: string;
+    opBefore: string;
+    opAfter: string;
+    menuCopy: string;
+    menuCut: string;
+    menuPaste: string;
+    menuClear: string;
+    menuInsertRowAbove: string;
+    menuInsertRowBelow: string;
+    menuRemoveRow: string;
+    menuRemoveColumn: string;
+    menuEditComment: string;
+    chartRange: string;
+    pivotUpsellTitle: string;
+    pivotUpsellBody: string;
+};
+/** English defaults - the literal strings the grid shipped before localization. */
+export declare const defaultGridMessages: GridMessages;
+/**
+ * Merge a consumer's `localeText` over the English defaults. Undefined/empty
+ * values fall back to the default (via `resolveMessages`), so a partial map only
+ * replaces the keys it sets.
+ */
+export declare function resolveGridMessages(overrides?: Partial<GridMessages> | null): GridMessages;

package/dist/grid-messages.js

@@ -0,0 +1,72 @@
+/**
+ * Grid chrome localization. Every user-visible UI string the grid renders itself
+ * (empty state, tool panel, pager, status bar, group labels, filter operators,
+ * context-menu items, upsell notes) lives here as a flat message map with English
+ * defaults. Pass `localeText` on `<SvGrid>` to override any subset; unset keys
+ * fall back to English, so omitting `localeText` is a no-op.
+ *
+ * This mirrors the editor kit's `resolveMessages` pattern (editor-contract.ts) so
+ * chrome and editors share one localization idiom.
+ */
+import { resolveMessages } from './editor-contract';
+/** English defaults - the literal strings the grid shipped before localization. */
+export const defaultGridMessages = {
+    noRows: 'No rows to display.',
+    loading: 'Loading grid data...',
+    columns: 'Columns',
+    filters: 'Filters',
+    clearFilter: 'Clear filter',
+    pageSize: 'Page Size:',
+    page: 'Page',
+    of: 'of',
+    firstPage: 'First page',
+    prevPage: 'Previous page',
+    nextPage: 'Next page',
+    lastPage: 'Last page',
+    statCount: 'Count',
+    statSum: 'Sum',
+    statAvg: 'Avg',
+    statMin: 'Min',
+    statMax: 'Max',
+    group: 'Group',
+    grandTotal: 'Grand total',
+    total: 'Total',
+    rowsSuffix: 'rows',
+    rowSuffix: 'row',
+    menuCopy: 'Copy',
+    menuCut: 'Cut',
+    menuPaste: 'Paste',
+    menuClear: 'Clear',
+    menuInsertRowAbove: 'Insert row above',
+    menuInsertRowBelow: 'Insert row below',
+    menuRemoveRow: 'Remove row',
+    menuRemoveColumn: 'Remove column',
+    menuEditComment: 'Edit comment',
+    opContains: 'Contains',
+    opNotContains: 'Not contains',
+    opEquals: 'Equals',
+    opNotEquals: 'Not equals',
+    opStartsWith: 'Starts with',
+    opEndsWith: 'Ends with',
+    opRegex: 'Regex',
+    opIn: 'In',
+    opNotIn: 'Not in',
+    opGreaterThan: 'Greater than',
+    opLessThan: 'Less than',
+    opBetween: 'Between',
+    opIsBlank: 'Blank',
+    opIsNotBlank: 'Not blank',
+    opBefore: 'Before',
+    opAfter: 'After',
+    chartRange: 'Chart selected range',
+    pivotUpsellTitle: 'Pivot mode',
+    pivotUpsellBody: 'Pivot mode is an Enterprise feature. Install @svgrid/enterprise and call enablePivot() to use it.',
+};
+/**
+ * Merge a consumer's `localeText` over the English defaults. Undefined/empty
+ * values fall back to the default (via `resolveMessages`), so a partial map only
+ * replaces the keys it sets.
+ */
+export function resolveGridMessages(overrides) {
+    return resolveMessages(defaultGridMessages, overrides);
+}

package/dist/group-display.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Row-grouping display helpers. Two pure, framework-free transforms:
+ *
+ * - `insertGroupFooters` inserts a footer/total row after each group's children
+ *   (and optionally a grand-total row at the end), carrying the group's already
+ *   computed aggregate values. Mirrors the server model's footer shape
+ *   (`server-group-model.ts`) client-side.
+ * - `buildAutoGroupColumns` decides, for a grouping display mode, which synthetic
+ *   "auto group" columns to show and which grouped source columns to hide - the
+ *   groundwork for `singleColumn` / `multipleColumns` display types (the current
+ *   default `groupRows` renders a full-width banner and needs neither).
+ *
+ * Both are generic over the row / column shape (via small accessor callbacks) so
+ * they are trivially unit-testable and carry no dependency on the grid runtime.
+ */
+/** AG-Grid-style grouping display variants. */
+export type GroupDisplayType = 'groupRows' | 'singleColumn' | 'multipleColumns';
+export type GroupFooterOptions<R> = {
+    /** Depth of a row (group rows and their descendants). */
+    getDepth: (row: R) => number;
+    /** True when a row is a group (banner) row. */
+    isGroup: (row: R) => boolean;
+    /** Build a footer row from the group row it closes (carries its aggregates). */
+    makeFooter: (groupRow: R) => R;
+    /** Insert a footer after each group's children. */
+    includeGroupFooter?: boolean;
+    /** Append a grand-total footer at the very end. */
+    includeGrandTotalFooter?: boolean;
+    /** Build the grand-total footer (over the whole set). Return null to skip. */
+    makeGrandTotal?: () => R | null;
+};
+/**
+ * Insert group footer rows after each group's descendants. A group opened at
+ * depth d closes when a later row appears at depth <= d (a sibling group or an
+ * ancestor-level row); its footer is emitted at that point. Order is otherwise
+ * preserved. No-op when neither footer flag is set.
+ */
+export declare function insertGroupFooters<R>(rows: ReadonlyArray<R>, opts: GroupFooterOptions<R>): R[];
+export type AutoGroupColumnSpec = {
+    /** Synthetic column id (e.g. `__autoGroup` or `__group_<field>`). */
+    id: string;
+    /** The grouped field this auto column stands in for (null for the single
+     *  combined auto-group column). */
+    field: string | null;
+    /** Nesting level this column represents (0-based), for indentation. */
+    level: number;
+};
+export type AutoGroupResult = {
+    /** Synthetic auto-group column specs to prepend to the visible columns. */
+    autoColumns: AutoGroupColumnSpec[];
+    /** Ids of the grouped SOURCE columns to hide (rolled into the auto columns). */
+    hiddenSourceIds: Set<string>;
+};
+/**
+ * Decide the synthetic auto-group columns for a grouping display mode:
+ * - `groupRows`: none (the banner path handles display) - `{ [], {} }`.
+ * - `singleColumn`: one combined auto-group column; every grouped source column
+ *   is hidden.
+ * - `multipleColumns`: one auto column per grouped field; the grouped source
+ *   columns are hidden.
+ */
+export declare function buildAutoGroupColumns(grouping: ReadonlyArray<string>, displayType: GroupDisplayType): AutoGroupResult;

package/dist/group-display.js

@@ -0,0 +1,78 @@
+/**
+ * Row-grouping display helpers. Two pure, framework-free transforms:
+ *
+ * - `insertGroupFooters` inserts a footer/total row after each group's children
+ *   (and optionally a grand-total row at the end), carrying the group's already
+ *   computed aggregate values. Mirrors the server model's footer shape
+ *   (`server-group-model.ts`) client-side.
+ * - `buildAutoGroupColumns` decides, for a grouping display mode, which synthetic
+ *   "auto group" columns to show and which grouped source columns to hide - the
+ *   groundwork for `singleColumn` / `multipleColumns` display types (the current
+ *   default `groupRows` renders a full-width banner and needs neither).
+ *
+ * Both are generic over the row / column shape (via small accessor callbacks) so
+ * they are trivially unit-testable and carry no dependency on the grid runtime.
+ */
+/**
+ * Insert group footer rows after each group's descendants. A group opened at
+ * depth d closes when a later row appears at depth <= d (a sibling group or an
+ * ancestor-level row); its footer is emitted at that point. Order is otherwise
+ * preserved. No-op when neither footer flag is set.
+ */
+export function insertGroupFooters(rows, opts) {
+    const { getDepth, isGroup, makeFooter, includeGroupFooter, includeGrandTotalFooter, makeGrandTotal } = opts;
+    if (!includeGroupFooter && !includeGrandTotalFooter)
+        return [...rows];
+    const out = [];
+    const openGroups = [];
+    const closeTo = (depth) => {
+        while (openGroups.length > 0) {
+            const top = openGroups[openGroups.length - 1];
+            if (getDepth(top) < depth)
+                break;
+            openGroups.pop();
+            if (includeGroupFooter)
+                out.push(makeFooter(top));
+        }
+    };
+    for (const row of rows) {
+        // Before adding this row, close any groups it ends (same-or-shallower depth).
+        closeTo(getDepth(row));
+        out.push(row);
+        if (isGroup(row))
+            openGroups.push(row);
+    }
+    // Close everything still open at the end.
+    closeTo(Number.NEGATIVE_INFINITY);
+    if (includeGrandTotalFooter && makeGrandTotal) {
+        const gt = makeGrandTotal();
+        if (gt != null)
+            out.push(gt);
+    }
+    return out;
+}
+/**
+ * Decide the synthetic auto-group columns for a grouping display mode:
+ * - `groupRows`: none (the banner path handles display) - `{ [], {} }`.
+ * - `singleColumn`: one combined auto-group column; every grouped source column
+ *   is hidden.
+ * - `multipleColumns`: one auto column per grouped field; the grouped source
+ *   columns are hidden.
+ */
+export function buildAutoGroupColumns(grouping, displayType) {
+    if (displayType === 'groupRows' || grouping.length === 0) {
+        return { autoColumns: [], hiddenSourceIds: new Set() };
+    }
+    const hiddenSourceIds = new Set(grouping);
+    if (displayType === 'singleColumn') {
+        return {
+            autoColumns: [{ id: '__autoGroup', field: null, level: 0 }],
+            hiddenSourceIds,
+        };
+    }
+    // multipleColumns
+    return {
+        autoColumns: grouping.map((field, level) => ({ id: `__group_${field}`, field, level })),
+        hiddenSourceIds,
+    };
+}