@svgrid/grid 2.6.20 → 2.6.22

package/dist/createTree.svelte.d.ts

@@ -30,6 +30,7 @@ export type TreeNode = {
      *  even with no children yet; the renderer loads them on first expand). */
     lazy?: boolean;
 };
+/** A node's checkbox state. `'indeterminate'` means some but not all descendants are checked. */
 export type CheckState = 'checked' | 'indeterminate' | 'unchecked';
 /** A single visible (flattened) tree row. */
 export type TreeRow = {
@@ -73,6 +74,7 @@ export type TreeConfig = {
     /** Filter query: show only matching nodes + their ancestors, auto-expanded. */
     filter?: () => string | undefined;
 };
+/** Build the headless tree model: expansion, selection and checkbox cascading, with no markup. */
 export declare function createTree(config: TreeConfig): {
     /** Internally-managed set of expanded node ids. */
     readonly expanded: Set<string>;
@@ -113,4 +115,5 @@ export declare function createTree(config: TreeConfig): {
         onkeydown: (e: KeyboardEvent) => void;
     };
 };
+/** The headless tree instance returned by {@link createTree}. */
 export type Tree = ReturnType<typeof createTree>;

package/dist/createTree.svelte.js

@@ -87,6 +87,7 @@ export function sortTreeNodes(nodes, compare) {
         .sort(compare)
         .map((n) => (n.children ? { ...n, children: sortTreeNodes(n.children, compare) } : n));
 }
+/** Build the headless tree model: expansion, selection and checkbox cascading, with no markup. */
 export function createTree(config) {
     const nodes = () => config.nodes();
     const checkable = () => config.checkable?.() ?? false;

package/dist/datetime/date-core.d.ts

@@ -9,6 +9,7 @@
  * - `firstDayOfWeek` is 0-6 (0 = Sunday), matching `Date.getDay()` and Smart's
  *   `firstDayOfWeek`.
  */
+/** Anything the date helpers accept: a `Date`, epoch milliseconds, or a parseable string. */
 export type DateLike = Date | number | string;
 /** Coerce a Date | epoch-ms | parseable string to a Date, or null if invalid. */
 export declare function toDate(value: DateLike | null | undefined): Date | null;
@@ -63,6 +64,7 @@ export declare function centuryRange(year: number): {
     start: number;
     end: number;
 };
+/** One cell of a month grid, including the leading and trailing days from adjacent months. */
 export type MonthMatrixCell = {
     date: Date;
     /** In the displayed month (vs. leading/trailing days of adjacent months). */

package/dist/datetime/date-restrict.d.ts

@@ -4,6 +4,7 @@
  * still selectable). Mirrors Smart's calendar constraint model. Framework-free.
  */
 import { type DateLike } from './date-core.js';
+/** Which dates a picker allows: bounds, an explicit disabled set, and disabled weekdays. */
 export type RestrictOptions = {
     min?: DateLike | null;
     max?: DateLike | null;

package/dist/datetime/timezone.d.ts

@@ -11,6 +11,7 @@
  * These functions are DST-aware and take no ambient "now" (safe for the model /
  * headless contexts that forbid `Date.now()`).
  */
+/** A wall-clock time broken into fields, as it reads in a specific time zone. */
 export type ZoneParts = {
     year: number;
     month: number;

package/dist/dock-manager-model.d.ts

@@ -16,6 +16,7 @@
  * painting; all the surgery lives here and is unit-tested without a browser.
  */
 import { type DockNode, type DockTabs, type DockPane, type DockZone, type IdGen } from './dock-model.js';
+/** Which edge a pane docks against when dropped. */
 export type DockSide = Exclude<DockZone, 'center'>;
 /** A floating window: one tabs leaf shown in a movable/resizable frame. */
 export type FloatWindow = {
@@ -40,6 +41,7 @@ export type AutoHideEntry = {
     /** Fly-out panel size in px along the reveal axis. */
     size: number;
 };
+/** The whole dock manager: its layout tree plus floating and pinned panes. */
 export type DockManagerState = {
     main: DockNode | null;
     floating: FloatWindow[];
@@ -57,6 +59,7 @@ export type PaneLocation = {
     kind: 'autoHide';
     entryId: string;
 };
+/** Find a pane in the layout tree by id, returning it with its parent for mutation. */
 export declare function locatePane(state: DockManagerState, paneId: string): PaneLocation | null;
 /** Which surface holds a tabs leaf: 'main', a window id, or null. */
 export declare function surfaceOfTabs(state: DockManagerState, tabsId: string): 'main' | string | null;

package/dist/dock-manager-model.js

@@ -16,6 +16,7 @@
  * painting; all the surgery lives here and is unit-tested without a browser.
  */
 import { tabs, dockInto, removePane as removePaneFromTree, removeLeaf, dockLeafToEdge, reorderPane, findTabsWithPane, allPaneIds, } from './dock-model.js';
+/** Find a pane in the layout tree by id, returning it with its parent for mutation. */
 export function locatePane(state, paneId) {
     if (state.main && findTabsWithPane(state.main, paneId))
         return { kind: 'main' };

package/dist/dock-model.d.ts

@@ -12,6 +12,7 @@
  * the drag gestures; all the tree surgery lives here so it is unit-testable
  * without a browser. Modelled on Smart's `smart-layout` group/item structure.
  */
+/** One dockable pane: its id, title, and the state a tab needs to render. */
 export type DockPane = {
     id: string;
     title: string;
@@ -36,14 +37,19 @@ export type DockGroup = {
     /** Size weight per child; parallel to `children`, normalized to sum ~1. */
     sizes: number[];
 };
+/** A node in the layout tree - either a split group or a tabbed leaf. */
 export type DockNode = DockGroup | DockTabs;
 /** Where a dragged pane lands relative to a target leaf. */
 export type DockZone = 'left' | 'right' | 'top' | 'bottom' | 'center';
+/** Supplies ids for newly created nodes, so layouts stay deterministic in tests. */
 export type IdGen = () => string;
+/** Build a {@link DockPane}. */
 export declare function pane(id: string, title: string, closable?: boolean): DockPane;
 /** Largest per-pane `minSize` in a leaf (0 if none). Used by splitter clamping. */
 export declare function leafMinSize(node: DockTabs): number;
+/** Build a tabbed leaf holding the given panes. */
 export declare function tabs(genId: IdGen, panes: DockPane[], active?: number): DockTabs;
+/** Build a split group: panes or nested groups laid out in a row or column. */
 export declare function group(genId: IdGen, direction: 'row' | 'column', children: DockNode[], sizes?: number[]): DockGroup;
 /** Return sizes summing to 1, padded/trimmed to `count`. Even split when absent. */
 export declare function normalizeSizes(sizes: number[] | undefined, count: number): number[];

package/dist/dock-model.js

@@ -13,6 +13,7 @@
  * without a browser. Modelled on Smart's `smart-layout` group/item structure.
  */
 // ---- construction helpers -------------------------------------------------
+/** Build a {@link DockPane}. */
 export function pane(id, title, closable = true) {
     return { id, title, closable };
 }
@@ -20,9 +21,11 @@ export function pane(id, title, closable = true) {
 export function leafMinSize(node) {
     return node.panes.reduce((m, p) => Math.max(m, p.minSize ?? 0), 0);
 }
+/** Build a tabbed leaf holding the given panes. */
 export function tabs(genId, panes, active = 0) {
     return { type: 'tabs', id: genId(), panes, active: clampIndex(active, panes.length) };
 }
+/** Build a split group: panes or nested groups laid out in a row or column. */
 export function group(genId, direction, children, sizes) {
     return { type: 'group', id: genId(), direction, children, sizes: normalizeSizes(sizes, children.length) };
 }

package/dist/editor-contract.d.ts

@@ -9,6 +9,7 @@
  *
  * Framework-free (no Svelte, no DOM) so it can be unit-tested and reused.
  */
+/** How much room a cell editor asks for, so the grid can size its overlay. */
 export type EditorSize = 'sm' | 'md' | 'lg';
 /**
  * A small action button rendered inside a framed field (via `SvField`'s

package/dist/filtering/excel-filters.js

@@ -8,11 +8,39 @@ const DIACRITIC_RE = /[̀-ͯ]/g;
 export function normalizeForFilter(s, locale) {
     if (!s)
         return '';
+    // Fast path for pure-ASCII input, which is the overwhelming majority of what
+    // a grid filters. Both of the expensive steps are provably no-ops there:
+    // ASCII is already NFD-normalised, and the combining-marks block this strips
+    // (U+0300..U+036F) contains no ASCII. So lowercasing alone is the same
+    // answer, and `normalize-fast-path.test.ts` checks that exhaustively over
+    // every ASCII code point rather than taking the argument on trust.
+    //
+    // Worth the branch: this runs once per cell per filter - 100,000 times for a
+    // one-column filter over a 100k grid - and a CPU profile of a browser filter
+    // put more time in this function than in any other.
+    //
+    // Note the locale still routes through toLocaleLowerCase even on the fast
+    // path: 'I'.toLocaleLowerCase('tr') is 'ı', so ASCII does NOT imply the
+    // locale can be ignored.
+    if (isAsciiOnly(s)) {
+        return locale ? s.toLocaleLowerCase(locale) : s.toLowerCase();
+    }
     const stripped = s.normalize('NFD').replace(DIACRITIC_RE, '');
     return locale
         ? stripped.toLocaleLowerCase(locale)
         : stripped.toLowerCase();
 }
+/**
+ * True when every code unit is ASCII. A plain char-code scan, which is far
+ * cheaper than the `normalize()` + regex pass it lets us skip.
+ */
+function isAsciiOnly(s) {
+    for (let i = 0; i < s.length; i++) {
+        if (s.charCodeAt(i) > 127)
+            return false;
+    }
+    return true;
+}
 /**
  * Delimiter used to serialise the `in` / `notIn` value list into the single
  * `value` string that the filter model carries.

package/dist/group-display.d.ts

@@ -13,7 +13,7 @@
  * 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. */
+/** Grouping display variants. */
 export type GroupDisplayType = 'groupRows' | 'singleColumn' | 'multipleColumns';
 export type GroupFooterOptions<R> = {
     /** Depth of a row (group rows and their descendants). */

package/dist/index.d.ts

@@ -194,6 +194,7 @@ export { chartToSvgString, downloadChartSvg, chartToPngBlob, downloadChartPng, c
 export { buildSparkline, toSparklineValues, type SparklineConfig, type SparklineType, type SparklineGeometry, } from './sparkline.js';
 export { spreadsheetLayout, spansToMerges, type SpanColumn, type SpreadsheetActionOptions, type MergeSpec, type CellBorderSpec, type BorderSpec, } from './spreadsheet.js';
 export { rowResize, type RowResizeOptions } from './row-resize.js';
+export { columnResize, type ColumnResizeOptions } from './column-resize.js';
 export { rowDropZone, type RowDragEndEvent, type RowDropZoneOptions } from './row-drag.js';
 export { resolveColumnTypes, inferCellDataType, type CellDataType } from './column-types.js';
 export { computeColumnGroupMeta, hiddenLeavesForCollapse, type ColumnGroupMeta, type ColumnGroupShow, } from './column-groups.js';
@@ -212,7 +213,7 @@ export { createVirtualizer } from './virtualization/virtualizer.js';
 export { createSvelteVirtualizer } from './virtualization/svelte-virtualizer.svelte.js';
 export { createColumnVirtualizer } from './virtualization/column-virtualizer.js';
 export type { VirtualItem, VirtualizerOptions, VirtualizerState } from './virtualization/types.js';
-export type { SvGridApi, SvGridFilterOperator, SvGridWrapperProps } from './svgrid-wrapper.types.js';
+export type { SvGridApi, SvGridFilterOperator, SvGridViewState, SvGridWrapperProps, } from './svgrid-wrapper.types.js';
 export { parseEditorValue, normalizeEditorOptions, type CellEditorType, type CellEditorOption, } from './editors/cell-editors.js';
 export { applyExcelFilter, compileExcelFilter, normalizeForFilter, splitInTokens, joinInTokens, trailingInToken, type CompiledExcelFilter, type ExcelFilter, type ExcelFilterOperator, type ExcelFilterOptions, } from './filtering/excel-filters.js';
 export { ALL_FILTER_OPERATORS, SET_OPERATOR_IDS, VALUELESS_OPERATOR_IDS, RANGE_OPERATOR_IDS, isSetOperator, isValuelessOperator, isRangeOperator, type FilterValueType, } from './filtering/filter-operator-catalogue.js';

package/dist/index.js

@@ -230,7 +230,13 @@ export { buildChart, formatChartValue, rowsToChartSpec, niceScale, niceLogScale,
 export { chartToSvgString, downloadChartSvg, chartToPngBlob, downloadChartPng, chartSpecToCsv, downloadChartCsv, } from './chart-export.js';
 export { buildSparkline, toSparklineValues, } from './sparkline.js';
 export { spreadsheetLayout, spansToMerges, } from './spreadsheet.js';
+// The two resize actions, exported as a matched pair. `<SvGrid>` drives both
+// through the `rowResize` / `columnResize` props - both default OFF, both are
+// turned on by setting them true, and the grid `import()`s the module itself so
+// a grid that leaves them off carries neither. Import them directly only for a
+// headless table, which renders its own rows and headers.
 export { rowResize } from './row-resize.js';
+export { columnResize } from './column-resize.js';
 export { rowDropZone } from './row-drag.js';
 export { resolveColumnTypes, inferCellDataType } from './column-types.js';
 export { computeColumnGroupMeta, hiddenLeavesForCollapse, } from './column-groups.js';

package/dist/list-option.d.ts

@@ -48,6 +48,7 @@ export type VirtualListRow = {
     opt: IndexedOption;
     size: number;
 };
+/** A flattened option list plus its measurements, for virtualizing long dropdowns. */
 export type FlatVirtualModel = {
     /** Group headings + options in render order, each with its px height. */
     entries: VirtualListRow[];

package/dist/menus.js

@@ -118,7 +118,7 @@ export function createMenus(ctx) {
     function openChooseColumns(event) {
         event.stopPropagation();
         // Submenu behavior: keep the parent operations menu open and float the
-        // Choose Columns panel out to the right of it (AG-Grid style). Falls
+        // Choose Columns panel out to the right of it, submenu-style. Falls
         // back to below the item if the popover would clip the viewport.
         const trigger = event.currentTarget;
         const menuEl = trigger.closest(".sv-grid-menu");

package/dist/positioning.d.ts

@@ -37,6 +37,7 @@ export type Viewport = {
     width: number;
     height: number;
 };
+/** Where to put a floating element: its preferred side, offsets, and collision behaviour. */
 export type ComputePositionOptions = {
     /** Preferred placement. Default `'bottom-start'`. */
     placement?: Placement;
@@ -61,6 +62,7 @@ export type ComputePositionOptions = {
     /** Floor for the available main-axis size returned by `size`. Default 0. */
     minMainAxis?: number;
 };
+/** The resolved position, including the side actually used after collision handling. */
 export type ComputePositionResult = {
     /** Floating left, in viewport (fixed-position) coordinates. */
     x: number;

package/dist/row-resize.d.ts

@@ -36,6 +36,17 @@ export type RowResizeOptions = {
     max?: number;
     /** When true, the action removes its strips and ignores events. */
     disabled?: boolean;
+    /**
+     * Where the drag strip is anchored.
+     * - `'gutter'` (default) - only rows that have a row-header gutter cell get
+     *   a strip: the built-in row-number column (`showRowNumbers`) or a column
+     *   tagged `cellClass: 'sv-row-gutter'`. Rows without one are skipped, so on
+     *   a plain grid the action does nothing.
+     * - `'row'` - use the gutter when there is one, otherwise fall back to the
+     *   row's first body cell. This is what `<SvGrid rowResize>` passes, so the
+     *   prop works without also asking for a gutter column.
+     */
+    anchor?: 'gutter' | 'row';
 };
 export declare function rowResize(node: HTMLElement, opts: RowResizeOptions): {
     update(next: RowResizeOptions): void;

package/dist/row-resize.js

@@ -141,7 +141,13 @@ export function rowResize(node, opts) {
             // A row-header gutter cell: either a user column tagged
             // `sv-row-gutter`, or the grid's built-in row-number gutter
             // (`showRowNumbers`), whose cell is `.sv-grid-row-number-cell`.
-            const gutter = tr.querySelector('.sv-grid-cell.sv-row-gutter, .sv-grid-cell.sv-grid-row-number-cell');
+            const gutter = tr.querySelector('.sv-grid-cell.sv-row-gutter, .sv-grid-cell.sv-grid-row-number-cell') ??
+                // `anchor: 'row'` - no gutter on this grid, so hang the strip off the
+                // first body cell instead. Without this a grid with no row-number
+                // column would silently not resize.
+                (current.anchor === 'row'
+                    ? tr.querySelector('.sv-grid-cell')
+                    : null);
             if (!gutter)
                 continue;
             if (gutter.querySelector(`:scope > .${STRIP_CLASS}`))

package/dist/scheduler-ical.d.ts

@@ -6,6 +6,7 @@
  * LOCATION. No `Date.now()` in the core - `toICS` accepts a stamp.
  */
 import type { RecurrenceRule } from './recurrence.js';
+/** One VEVENT: the fields SvGrid reads from and writes to an iCalendar feed. */
 export type ICalEvent = {
     uid?: string;
     title: string;

package/dist/scheduler-model.d.ts

@@ -171,6 +171,7 @@ export type DayLayout<TData = unknown> = {
     events: PositionedEvent<TData>[];
     overflows: OverflowMarker<TData>[];
 };
+/** Tuning for event layout: how overlapping events share horizontal space. */
 export type LayoutOptions = {
     dayStartHour?: number;
     dayEndHour?: number;

package/dist/selection.js

@@ -225,6 +225,15 @@ export function createSelection(ctx) {
      * outline wins on overlap). Returns null when the cell is in no range.
      */
     function getCellRangeEdges(rowIndex, colIndex) {
+        // Bail before `getSelectionRects()`, which allocates an array and resolves
+        // every range. This runs once per rendered CELL on every render - about 250
+        // times per frame on a default grid - and with nothing selected it did all
+        // that work to return null every time. An anchored active range or a
+        // committed one is the only way any rect can exist.
+        const active = ctx.selectionRange;
+        const committed = ctx.selectionRanges;
+        if (!committed?.length && !(active?.anchor && active?.focus))
+            return null;
         for (const rect of getSelectionRects()) {
             if (rowIndex < rect.minRow ||
                 rowIndex > rect.maxRow ||

package/dist/spreadsheet.d.ts

@@ -63,7 +63,7 @@ export type SpanColumn<TData = Record<string, unknown>> = {
 /**
  * Turn declarative per-column `colSpan` / `rowSpan` callbacks into a
  * `MergeSpec[]` you can hand to `spreadsheetLayout` - so value-driven,
- * AG-Grid-style spanning runs on the SAME real colspan/rowspan merge engine
+ * Declarative spanning runs on the SAME real colspan/rowspan merge engine
  * instead of a second code path. Recompute after sort/filter (indexes are
  * display-row indexes). A common pattern is "merge runs of equal values":
  *

package/dist/spreadsheet.js

@@ -22,7 +22,7 @@
 /**
  * Turn declarative per-column `colSpan` / `rowSpan` callbacks into a
  * `MergeSpec[]` you can hand to `spreadsheetLayout` - so value-driven,
- * AG-Grid-style spanning runs on the SAME real colspan/rowspan merge engine
+ * Declarative spanning runs on the SAME real colspan/rowspan merge engine
  * instead of a second code path. Recompute after sort/filter (indexes are
  * display-row indexes). A common pattern is "merge runs of equal values":
  *

package/dist/summaries.js

@@ -1,3 +1,7 @@
+// summaries handlers extracted from the controller. Imperative event handlers
+// reading/writing controller state via the `ctx` handle; the reactive core
+// ($state/$derived/$effect) stays in the controller.
+import { applyGroupAggregate, } from "./index.js";
 import "./sv-grid-scrollbar.js";
 import { getCellKey, } from "./SvGrid.helpers.js";
 import { formatSummaryNumeric, } from "./cell-values.js";
@@ -25,6 +29,24 @@ export function createSummaries(ctx) {
             const fieldFn = def.fieldFn;
             const field = def.field;
             const columnId = column.id;
+            // A column that declares its own `summary` opts out of the default
+            // sum/count below. Only that column pays for the aggregator dispatch, so
+            // a grid that declares none keeps the original hot loop exactly as it was.
+            const declared = def.summary;
+            if (declared !== undefined) {
+                if (declared === false) {
+                    summary[columnId] = "";
+                    continue;
+                }
+                const value = applyGroupAggregate(declared, columnId, rows);
+                summary[columnId] =
+                    typeof value === "number" && Number.isFinite(value)
+                        ? formatSummaryNumeric(column, value)
+                        : value == null
+                            ? ""
+                            : String(value);
+                continue;
+            }
             let numericSum = 0;
             let numericCount = 0;
             for (let i = 0; i < rowCount; i += 1) {

package/dist/svgrid-wrapper.types.d.ts

@@ -3,6 +3,7 @@ import type { FilterOperator, Props } from './SvGrid.types.js';
 import type { GridExportOptions, GridClipboardOptions } from './export-format.js';
 import type { ChartSpec, ChartType } from './chart.js';
 import type { GridPredicateExpr } from './filtering/predicate-expr.js';
+/** The comparisons a column filter can use, as shown in the filter menu. */
 export type SvGridFilterOperator = FilterOperator;
 /**
  * A serializable snapshot of everything that makes up the current "view":
@@ -80,6 +81,7 @@ export type SvGridTransaction<TData> = {
     update?: ReadonlyArray<TData>;
     remove?: ReadonlyArray<TData | string>;
 };
+/** What a batched `applyTransaction` did: how many rows were added, updated and removed. */
 export type SvGridTransactionResult = {
     added: number;
     updated: number;
@@ -458,6 +460,7 @@ export type SvGridApi<TFeatures extends TableFeatures, TData extends RowData> =
     /** Force a recompute of the row pipeline + a re-render. */
     refresh(): void;
 };
+/** The props `<SvGrid>` accepts. See the SvGrid reference for the full list with defaults. */
 export type SvGridWrapperProps<TFeatures extends TableFeatures, TData extends RowData> = {
     data: ReadonlyArray<TData>;
     columns: Array<ColumnDef<TFeatures, TData>>;
@@ -505,6 +508,8 @@ export type SvGridWrapperProps<TFeatures extends TableFeatures, TData extends Ro
     enableCellSelection?: boolean;
     enableInlineEditing?: boolean;
     enableRowSummaries?: boolean;
+    /** Shortcut alias for `enableRowSummaries`; wins when both are set. */
+    summary?: boolean;
     /** Receives the imperative grid API when the component is ready. */
     onApiReady?: (api: SvGridApi<TFeatures, TData>) => void;
 };

package/dist/toast-store.svelte.d.ts

@@ -14,6 +14,7 @@
  * Mount a single <SvToaster /> once near the app root to render the queue.
  */
 import type { Snippet } from 'svelte';
+/** A toast's severity, which selects its colour and icon. */
 export type ToastVariant = 'info' | 'success' | 'warning' | 'error';
 /** A button rendered inside a toast (a primary `action` or a secondary `cancel`). */
 export type ToastAction = {
@@ -23,6 +24,7 @@ export type ToastAction = {
     /** Keep the toast open after the click (default: dismiss it). */
     keepOpen?: boolean;
 };
+/** Options for one toast: its variant, how long it stays, and any action button. */
 export type ToastOptions = {
     variant?: ToastVariant;
     /** Auto-dismiss after N ms. `0` = sticky (dismiss manually). Default 4000. */
@@ -38,6 +40,7 @@ export type ToastOptions = {
     /** Render a fully custom toast body instead of the icon + title + message. */
     render?: Snippet<[Toast]>;
 };
+/** A live toast: its options plus the id needed to dismiss it. */
 export type Toast = {
     id: number;
     message: string;
@@ -58,6 +61,7 @@ export type PromiseMessages<T> = {
     error: string | ((error: unknown) => string);
 };
 type VariantOptions = Omit<ToastOptions, 'variant'>;
+/** The callable toast API - `toast(msg)` plus `.success` / `.error` / friends. */
 export type ToastFn = {
     (message: string, options?: ToastOptions): number;
     info: (message: string, options?: VariantOptions) => number;

package/dist/validate.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Development-time configuration checks.
+ *
+ * The grid used to fail silently on the most common mistakes. A misspelled
+ * `field` rendered a column of empty cells with nothing on the console; a
+ * `pageSize` with no pagination was quietly ignored; a column marked
+ * `sortable` with no sorting enabled just did not sort. Each of those costs
+ * someone an afternoon, and none of them were detectable from the outside.
+ *
+ * This module is the check. It is pure and returns messages rather than
+ * printing them, so it can be unit-tested; the controller runs it in an effect
+ * and prints each message once, in dev builds only.
+ *
+ * Rules for anything added here:
+ *   - Never fire on valid config. A false positive teaches people to ignore
+ *     warnings, which is worse than staying silent.
+ *   - Say what happened, what it means, and how to fix it - the house style set
+ *     by the one pre-existing warning in server-data-source.ts.
+ *   - Stay O(columns), or O(columns x a fixed row sample). This runs on data
+ *     changes, and must not scale with row count.
+ */
+import type { ColumnDef, RowData, TableFeatures } from './core.js';
+export type ValidateInput<TFeatures extends TableFeatures, TData extends RowData> = {
+    data: ReadonlyArray<TData>;
+    columns: ReadonlyArray<ColumnDef<TFeatures, TData>>;
+    /** The resolved feature set, after the boolean shortcuts have injected theirs. */
+    features?: Record<string, unknown>;
+    sortable?: boolean;
+    pageable?: boolean;
+    showPagination?: boolean;
+    pageSize?: number;
+    groupBy?: ReadonlyArray<string>;
+    treeData?: {
+        parentField?: string;
+        idField?: string;
+        column?: string;
+    };
+    initialColumnPinning?: {
+        left?: ReadonlyArray<string>;
+        right?: ReadonlyArray<string>;
+    };
+    columnVirtualization?: boolean;
+    externalPagination?: boolean;
+    rowCount?: number;
+    externalSort?: boolean;
+    onSortingChange?: unknown;
+    externalFilter?: boolean;
+    onFiltersChange?: unknown;
+};
+export declare function validateGridConfig<TFeatures extends TableFeatures, TData extends RowData>(input: ValidateInput<TFeatures, TData>): string[];