@svgrid/grid 1.0.0

package/dist/core.js

@@ -0,0 +1,568 @@
+/** Apply a group aggregator over a bucket's leaf rows for one column. */
+export function applyGroupAggregate(agg, columnId, rows) {
+    const raw = rows.map((r) => r.getCellValueByColumnId(columnId));
+    if (typeof agg === 'function') {
+        const nums = raw.map((v) => Number(v)).filter((n) => Number.isFinite(n));
+        return agg(nums, rows.map((r) => r.original));
+    }
+    if (agg === 'count')
+        return rows.length;
+    if (agg === 'countDistinct')
+        return new Set(raw.map((v) => String(v ?? ''))).size;
+    if (agg === 'first')
+        return raw[0];
+    const nums = raw.map((v) => Number(v)).filter((n) => Number.isFinite(n));
+    if (!nums.length)
+        return undefined;
+    switch (agg) {
+        case 'sum':
+            return nums.reduce((a, b) => a + b, 0);
+        case 'avg':
+            return nums.reduce((a, b) => a + b, 0) / nums.length;
+        case 'min':
+            return Math.min(...nums);
+        case 'max':
+            return Math.max(...nums);
+        case 'extent':
+            return `${Math.min(...nums)} – ${Math.max(...nums)}`;
+        default:
+            return undefined;
+    }
+}
+function createStore(initial) {
+    let value = initial;
+    const listeners = new Set();
+    return {
+        get state() {
+            return value;
+        },
+        setState(updater) {
+            value = updater(value);
+            listeners.forEach((listener) => listener());
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+export const rowSortingFeature = { key: 'rowSortingFeature' };
+export const columnFilteringFeature = { key: 'columnFilteringFeature' };
+export const rowPaginationFeature = { key: 'rowPaginationFeature' };
+export const columnGroupingFeature = { key: 'columnGroupingFeature' };
+export const rowSelectionFeature = { key: 'rowSelectionFeature' };
+export const rowExpandingFeature = { key: 'rowExpandingFeature' };
+export function tableFeatures(features) {
+    return features;
+}
+export const sortFns = {
+    auto: (a, b) => String(a).localeCompare(String(b)),
+    number: (a, b) => Number(a ?? 0) - Number(b ?? 0),
+    date: (a, b) => {
+        const aa = new Date(a).getTime();
+        const bb = new Date(b).getTime();
+        return aa - bb;
+    },
+};
+export const filterFns = {
+    includesString: (value, query) => String(value).toLowerCase().includes(query.toLowerCase()),
+    equals: (value, query) => value === query,
+};
+export function createCoreRowModel() {
+    return ({ rows }) => rows;
+}
+export function createFilteredRowModel() {
+    return ({ table, rows }) => {
+        const filters = table.getState().columnFilters ?? [];
+        if (!filters.length)
+            return rows;
+        return rows.filter((row) => {
+            return filters.every((filter) => {
+                const cellValue = row
+                    .getAllCells()
+                    .find((cell) => cell.column.id === filter.id)
+                    ?.getValue();
+                const filterFn = filter.fn ? filterFns[filter.fn] : filterFns.includesString;
+                return filterFn(cellValue, filter.value);
+            });
+        });
+    };
+}
+export function createPaginatedRowModel() {
+    return ({ table, rows }) => {
+        const pagination = table.getState().pagination ?? { pageIndex: 0, pageSize: rows.length || 10 };
+        const start = pagination.pageIndex * pagination.pageSize;
+        return rows.slice(start, start + pagination.pageSize);
+    };
+}
+export function createGroupedRowModel() {
+    return ({ table, rows }) => {
+        const grouping = table.getState().grouping ?? [];
+        if (!grouping.length)
+            return rows;
+        const columns = table.getAllColumns();
+        // Recursively bucket rows by each grouping column in turn. At every level a
+        // group row is built that stands in for its children - a non-group column
+        // resolves to the value shared by every leaf row, or to undefined when the
+        // leaves disagree.
+        function buildGroups(input, levelIndex, depth, idPrefix) {
+            if (levelIndex >= grouping.length) {
+                // Leaves: actual data rows, with their nesting depth recorded.
+                return input.map((row) => ({ ...row, depth }));
+            }
+            const groupKey = grouping[levelIndex];
+            if (!groupKey)
+                return input;
+            const buckets = new Map();
+            for (const row of input) {
+                const value = row.getCellValueByColumnId(groupKey);
+                const key = String(value ?? '');
+                const list = buckets.get(key) ?? [];
+                list.push(row);
+                buckets.set(key, list);
+            }
+            const groupRows = [];
+            let index = 0;
+            buckets.forEach((children, key) => {
+                const id = `${idPrefix}_${groupKey}_${key}`;
+                const subRows = buildGroups(children, levelIndex + 1, depth + 1, id);
+                const isDeepest = levelIndex + 1 >= grouping.length;
+                const leafCount = isDeepest
+                    ? subRows.length
+                    : subRows.reduce((sum, sub) => sum + (sub.leafCount ?? 0), 0);
+                const resolveColumnValue = (columnId) => {
+                    if (columnId === groupKey)
+                        return key;
+                    let resolved;
+                    let hasResolved = false;
+                    for (const child of children) {
+                        const childValue = child.getCellValueByColumnId(columnId);
+                        if (!hasResolved) {
+                            resolved = childValue;
+                            hasResolved = true;
+                        }
+                        else if (childValue !== resolved) {
+                            return undefined;
+                        }
+                    }
+                    return resolved;
+                };
+                const groupOriginal = {};
+                columns.forEach((column) => {
+                    const field = column.columnDef.field;
+                    if (!field)
+                        return;
+                    const agg = column.columnDef.aggregate;
+                    groupOriginal[field] = agg
+                        ? applyGroupAggregate(agg, column.id, children)
+                        : resolveColumnValue(column.id);
+                });
+                const groupRow = {
+                    id,
+                    index: index++,
+                    original: groupOriginal,
+                    depth,
+                    subRows,
+                    leafCount,
+                    getCanExpand: () => true,
+                    getIsExpanded: () => Boolean((table.getState().expanded ?? {})[id]),
+                    toggleExpanded: () => {
+                        table.setExpanded((prev) => ({ ...prev, [id]: !prev[id] }));
+                    },
+                    getIsSelected: () => Boolean((table.getState().rowSelection ?? {})[id]),
+                    toggleSelected: () => {
+                        table.setRowSelection((prev) => ({ ...prev, [id]: !prev[id] }));
+                    },
+                    getAllCells: () => [],
+                    // Prefer the precomputed group value (which carries aggregates)
+                    // and fall back to the shared-value resolver for columns without
+                    // a field.
+                    getCellValueByColumnId: (columnId) => {
+                        const col = columns.find((c) => c.id === columnId);
+                        const field = col?.columnDef.field;
+                        if (field && field in groupOriginal)
+                            return groupOriginal[field];
+                        return resolveColumnValue(columnId);
+                    },
+                };
+                groupRows.push(groupRow);
+            });
+            return groupRows;
+        }
+        return buildGroups(rows, 0, 0, 'group');
+    };
+}
+export function createExpandedRowModel() {
+    return ({ table, rows }) => {
+        const expanded = table.getState().expanded ?? {};
+        const flattened = [];
+        const visit = (row) => {
+            flattened.push(row);
+            if (row.subRows?.length && expanded[row.id]) {
+                for (const sub of row.subRows)
+                    visit(sub);
+            }
+        };
+        for (const row of rows)
+            visit(row);
+        return flattened;
+    };
+}
+export function createSortedRowModel(localSortFns = sortFns) {
+    return ({ table, rows }) => {
+        const sorting = table.getState().sorting ?? [];
+        if (!sorting.length)
+            return rows;
+        const sorted = [...rows].sort((a, b) => {
+            for (const clause of sorting) {
+                const column = table.getAllColumns().find((col) => col.id === clause.id);
+                if (!column)
+                    continue;
+                const editorType = column.columnDef.editorType;
+                const comparator = editorType === 'number'
+                    ? localSortFns.number
+                    : editorType === 'date' || editorType === 'datetime'
+                        ? localSortFns.date
+                        : localSortFns.auto;
+                const result = comparator(a.getCellValueByColumnId(column.id), b.getCellValueByColumnId(column.id));
+                if (result !== 0)
+                    return clause.desc ? -result : result;
+            }
+            return 0;
+        });
+        return sorted;
+    };
+}
+export function createSvGridCore(options) {
+    const internalState = {
+        sorting: [],
+        columnFilters: [],
+        pagination: { pageIndex: 0, pageSize: options.data.length || 10 },
+        grouping: [],
+        expanded: {},
+        rowSelection: {},
+        activeCell: { rowIndex: 0, colIndex: 0, cellId: null },
+        ...(options.state ?? {}),
+    };
+    const store = createStore(internalState);
+    const optionsStore = createStore(options);
+    let cachedColumnsInput = null;
+    let cachedColumns = [];
+    let cachedHeaderGroups = [];
+    let cachedBaseRowsInput = null;
+    let cachedBaseRowsColumns = null;
+    let cachedBaseRows = [];
+    let cachedRowModel = null;
+    let cachedRowModelBaseRows = null;
+    let cachedPipeline = options._rowModels;
+    let cachedSlices = null;
+    const grid = {
+        store,
+        optionsStore,
+        get state() {
+            return store.state;
+        },
+        getState() {
+            return store.state;
+        },
+        setOptions(updater) {
+            optionsStore.setState((prev) => typeof updater === 'function' ? updater(prev) : updater);
+        },
+        setColumnFilters(updater) {
+            store.setState((prev) => ({
+                ...prev,
+                columnFilters: typeof updater === 'function' ? updater(prev.columnFilters ?? []) : updater,
+            }));
+            options.onColumnFiltersChange?.(updater);
+        },
+        setPagination(updater) {
+            store.setState((prev) => ({
+                ...prev,
+                pagination: typeof updater === 'function'
+                    ? updater(prev.pagination ?? { pageIndex: 0, pageSize: 10 })
+                    : updater,
+            }));
+            options.onPaginationChange?.(updater);
+        },
+        setGrouping(updater) {
+            store.setState((prev) => ({
+                ...prev,
+                grouping: typeof updater === 'function' ? updater(prev.grouping ?? []) : updater,
+            }));
+            options.onGroupingChange?.(updater);
+        },
+        setExpanded(updater) {
+            store.setState((prev) => ({
+                ...prev,
+                expanded: typeof updater === 'function' ? updater(prev.expanded ?? {}) : updater,
+            }));
+            options.onExpandedChange?.(updater);
+        },
+        setRowSelection(updater) {
+            store.setState((prev) => ({
+                ...prev,
+                rowSelection: typeof updater === 'function' ? updater(prev.rowSelection ?? {}) : updater,
+            }));
+            options.onRowSelectionChange?.(updater);
+        },
+        setActiveCell(updater) {
+            store.setState((prev) => {
+                const previous = prev.activeCell ?? {
+                    rowIndex: 0,
+                    colIndex: 0,
+                    cellId: null,
+                };
+                const nextActive = typeof updater === 'function' ? updater(previous) : updater;
+                return {
+                    ...prev,
+                    activeCell: nextActive,
+                };
+            });
+            options.onActiveCellChange?.(updater);
+        },
+        moveActiveCell(next) {
+            const rows = grid.getRowModel().rows;
+            const columns = grid.getAllColumns();
+            const maxRow = Math.max(rows.length - 1, 0);
+            const maxCol = Math.max(columns.length - 1, 0);
+            const current = grid.getState().activeCell ?? {
+                rowIndex: 0,
+                colIndex: 0,
+                cellId: null,
+            };
+            const rowIndex = Math.min(Math.max(current.rowIndex + (next.rowDelta ?? 0), 0), maxRow);
+            const colIndex = Math.min(Math.max(current.colIndex + (next.colDelta ?? 0), 0), maxCol);
+            const columnId = columns[colIndex]?.id ?? 'col_0';
+            grid.setActiveCell({
+                rowIndex,
+                colIndex,
+                cellId: `${rowIndex}_${columnId}`,
+            });
+        },
+        getAllColumns() {
+            // Cache hit: referentially identical columns array.
+            if (cachedColumnsInput === options.columns && cachedColumns.length) {
+                return cachedColumns;
+            }
+            // Soft cache hit: consumers commonly recreate the columns array
+            // inline on every render (e.g. `columns={[...]}`). If the new
+            // array has the same length AND each entry has the same `field` /
+            // `id` / `header` (the visibility-affecting structure of a
+            // column), trust the previous build. Mutable inner fields like
+            // `cell` and `editorOptions` are still picked up on the next real
+            // render that bumps an actual data dep - they're read at cell-
+            // render time, not at this top-level cache.
+            if (cachedColumnsInput &&
+                options.columns.length === cachedColumnsInput.length &&
+                cachedColumns.length === options.columns.length &&
+                options.columns.every((c, i) => {
+                    const prev = cachedColumnsInput[i];
+                    return (c.field === prev.field &&
+                        c.id === prev.id &&
+                        c.header === prev.header &&
+                        c.editorType === prev.editorType);
+                })) {
+                // Update the stored input reference so the strict check hits
+                // next time, but reuse the built column model.
+                cachedColumnsInput = options.columns;
+                return cachedColumns;
+            }
+            cachedColumnsInput = options.columns;
+            cachedHeaderGroups = [];
+            const build = (defs, depth, parentId) => {
+                const leaves = [];
+                defs.forEach((columnDef, index) => {
+                    const id = columnDef.id ?? columnDef.field ?? `${parentId ?? 'col'}_${depth}_${index}`;
+                    if (columnDef.columns?.length) {
+                        leaves.push(...build(columnDef.columns, depth + 1, id));
+                        return;
+                    }
+                    leaves.push({
+                        id,
+                        depth,
+                        parentId,
+                        columnDef,
+                        getCanSort: () => Boolean(options._features.rowSortingFeature) &&
+                            columnDef.sortable !== false,
+                        getCanFilter: () => Boolean(options._features.columnFilteringFeature) &&
+                            columnDef.filterable !== false,
+                        getIsSorted: () => {
+                            const entry = store.state.sorting?.find((s) => s.id === id);
+                            if (!entry)
+                                return false;
+                            return entry.desc ? 'desc' : 'asc';
+                        },
+                        getToggleSortingHandler: () => () => {
+                            const clauses = store.state.sorting ?? [];
+                            const current = clauses.find((s) => s.id === id);
+                            const nextClause = !current
+                                ? [...clauses, { id, desc: false }]
+                                : current.desc
+                                    ? clauses.filter((s) => s.id !== id)
+                                    : clauses.map((s) => (s.id === id ? { ...s, desc: true } : s));
+                            store.setState((prev) => ({ ...prev, sorting: nextClause }));
+                            options.onSortingChange?.(nextClause);
+                        },
+                    });
+                });
+                return leaves;
+            };
+            cachedColumns = build(options.columns, 0);
+            return cachedColumns;
+        },
+        getHeaderGroups() {
+            if (cachedHeaderGroups.length)
+                return cachedHeaderGroups;
+            const headers = grid.getAllColumns().map((column) => {
+                const header = {
+                    id: column.id,
+                    isPlaceholder: false,
+                    colSpan: 1,
+                    column,
+                    getContext: () => ({ header, column, table: grid }),
+                };
+                return header;
+            });
+            cachedHeaderGroups = [{ id: 'header_group_0', headers }];
+            return cachedHeaderGroups;
+        },
+        getFooterGroups() {
+            return grid.getHeaderGroups();
+        },
+        getRowModel() {
+            const columns = grid.getAllColumns();
+            if (cachedBaseRowsInput !== options.data || cachedBaseRowsColumns !== columns) {
+                cachedBaseRowsInput = options.data;
+                cachedBaseRowsColumns = columns;
+                // O(1) column-id → index lookup so getCellValueByColumnId doesn't do
+                // a linear `findIndex` on every cell read (was O(rows × cells × cols)).
+                const columnIndexById = new Map();
+                for (let i = 0; i < columns.length; i++)
+                    columnIndexById.set(columns[i].id, i);
+                const columnCount = columns.length;
+                cachedBaseRows = new Array(options.data.length);
+                const getRowId = options.getRowId;
+                for (let index = 0; index < options.data.length; index++) {
+                    const original = options.data[index];
+                    const id = getRowId ? getRowId(original, index) : String(index);
+                    // `values` and `cells` are computed lazily - for a 100k-row grid
+                    // with only ~20 visible rows we don't want to materialise every
+                    // row's full value array or cell objects up front.
+                    let cachedValues = null;
+                    let cachedCells = null;
+                    function computeValues() {
+                        const values = new Array(columnCount);
+                        for (let i = 0; i < columnCount; i++) {
+                            const column = columns[i];
+                            if (column.columnDef.accessorFn) {
+                                values[i] = column.columnDef.accessorFn(original);
+                            }
+                            else if (column.columnDef.field) {
+                                values[i] = original[column.columnDef.field];
+                            }
+                            else {
+                                values[i] = undefined;
+                            }
+                        }
+                        return values;
+                    }
+                    const row = {
+                        id,
+                        index,
+                        original,
+                        depth: 0,
+                        getCanExpand: () => false,
+                        getIsExpanded: () => Boolean((store.state.expanded ?? {})[id]),
+                        toggleExpanded: () => {
+                            grid.setExpanded((prev) => ({ ...prev, [id]: !prev[id] }));
+                        },
+                        getIsSelected: () => Boolean((store.state.rowSelection ?? {})[id]),
+                        toggleSelected: () => {
+                            grid.setRowSelection((prev) => ({ ...prev, [id]: !prev[id] }));
+                        },
+                        getAllCells: () => {
+                            if (cachedCells)
+                                return cachedCells;
+                            const built = new Array(columnCount);
+                            for (let i = 0; i < columnCount; i++) {
+                                const column = columns[i];
+                                const colIndex = i;
+                                const cell = {
+                                    id: `${id}_${column.id}`,
+                                    row,
+                                    column,
+                                    getValue: () => {
+                                        if (!cachedValues)
+                                            cachedValues = computeValues();
+                                        return cachedValues[colIndex];
+                                    },
+                                    getContext: () => ({
+                                        cell,
+                                        row,
+                                        column,
+                                        table: grid,
+                                        getValue: () => cell.getValue(),
+                                    }),
+                                };
+                                built[i] = cell;
+                            }
+                            cachedCells = built;
+                            return built;
+                        },
+                        getCellValueByColumnId: (columnId) => {
+                            const idx = columnIndexById.get(columnId);
+                            if (idx === undefined)
+                                return undefined;
+                            if (!cachedValues)
+                                cachedValues = computeValues();
+                            return cachedValues[idx];
+                        },
+                    };
+                    cachedBaseRows[index] = row;
+                }
+            }
+            const currentSlices = {
+                sorting: store.state.sorting,
+                columnFilters: store.state.columnFilters,
+                pagination: store.state.pagination,
+                grouping: store.state.grouping,
+                expanded: store.state.expanded,
+                rowSelection: store.state.rowSelection,
+            };
+            if (cachedRowModel &&
+                cachedRowModelBaseRows === cachedBaseRows &&
+                cachedPipeline === options._rowModels &&
+                cachedSlices?.sorting === currentSlices.sorting &&
+                cachedSlices?.columnFilters === currentSlices.columnFilters &&
+                cachedSlices?.pagination === currentSlices.pagination &&
+                cachedSlices?.grouping === currentSlices.grouping &&
+                cachedSlices?.expanded === currentSlices.expanded &&
+                cachedSlices?.rowSelection === currentSlices.rowSelection) {
+                return cachedRowModel;
+            }
+            let rows = cachedBaseRows;
+            const pipeline = options._rowModels ?? {};
+            const ordered = [
+                pipeline.coreRowModel,
+                pipeline.filteredRowModel,
+                pipeline.sortedRowModel,
+                pipeline.groupedRowModel,
+                pipeline.expandedRowModel,
+                pipeline.paginatedRowModel,
+            ];
+            ordered.forEach((fn) => {
+                if (fn)
+                    rows = fn({ table: grid, rows });
+            });
+            cachedPipeline = options._rowModels;
+            cachedSlices = currentSlices;
+            cachedRowModelBaseRows = cachedBaseRows;
+            cachedRowModel = { rows };
+            return cachedRowModel;
+        },
+    };
+    return grid;
+}
+export function isFunction(value) {
+    return typeof value === 'function';
+}

package/dist/core.performance.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core.performance.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { createCoreRowModel, createSortedRowModel, createSvGrid, sortFns, tableFeatures } from './index';
+describe('core performance smoke', () => {
+    it('handles large synthetic shape with bounded row model call', () => {
+        const columns = Array.from({ length: 50 }, (_, index) => ({
+            field: `c${index}`,
+            editorType: 'number',
+        }));
+        const data = Array.from({ length: 5000 }, (_, rowIndex) => {
+            const row = {};
+            for (let col = 0; col < 50; col += 1)
+                row[`c${col}`] = rowIndex + col;
+            return row;
+        });
+        const grid = createSvGrid({
+            _features: tableFeatures({}),
+            _rowModels: {
+                coreRowModel: createCoreRowModel(),
+                sortedRowModel: createSortedRowModel(sortFns),
+            },
+            columns,
+            data,
+            state: { sorting: [{ id: 'c0', desc: true }, { id: 'c1', desc: false }] },
+        });
+        const rows = grid.getRowModel().rows;
+        expect(rows.length).toBe(5000);
+        expect(rows[0]?.getCellValueByColumnId('c0')).toBe(4999);
+    });
+});

package/dist/createGrid.svelte.d.ts

@@ -0,0 +1,6 @@
+import type { RowData, SvGrid, SvGridOptions, TableFeatures } from './core';
+export type SvelteGrid<TFeatures extends TableFeatures, TData extends RowData, TSelected = {}> = SvGrid<TData> & {
+    readonly state: Readonly<TSelected>;
+};
+export declare function createSvGrid<TFeatures extends TableFeatures, TData extends RowData, TSelected = {}>(gridOptions: SvGridOptions<TFeatures, TData>, selector?: (state: Record<string, any>) => TSelected): SvelteGrid<TFeatures, TData, TSelected>;
+export declare const createGrid: typeof createSvGrid;

package/dist/createGrid.svelte.js

@@ -0,0 +1,17 @@
+import { createSvGridCore } from './core';
+export function createSvGrid(gridOptions, selector = () => ({})) {
+    const grid = createSvGridCore(gridOptions);
+    let selected = $state(selector(grid.store.state));
+    grid.store.subscribe(() => {
+        selected = selector(grid.store.state);
+    });
+    Object.defineProperty(grid, 'state', {
+        get() {
+            return selected;
+        },
+        configurable: true,
+        enumerable: true,
+    });
+    return grid;
+}
+export const createGrid = createSvGrid;

package/dist/createGrid.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/createGrid.test.js

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest';
+import { createGridState } from './index';
+describe('createGrid', () => {
+    it('createGridState updates controlled values', () => {
+        const [sorting, setSorting] = createGridState([{ id: 'age', desc: false }]);
+        setSorting((prev) => prev.map((entry) => ({ ...entry, desc: true })));
+        expect(sorting()[0]?.desc).toBe(true);
+    });
+});

package/dist/createGridState.svelte.d.ts

@@ -0,0 +1,3 @@
+import type { Updater } from './core';
+export declare function createGridState<TState>(initialValue: TState): [() => TState, (updater: Updater<TState>) => void];
+export declare const createSvGridState: typeof createGridState;

package/dist/createGridState.svelte.js

@@ -0,0 +1,13 @@
+export function createGridState(initialValue) {
+    let value = $state(initialValue);
+    return [
+        () => value,
+        (updater) => {
+            if (updater instanceof Function)
+                value = updater(value);
+            else
+                value = updater;
+        },
+    ];
+}
+export const createSvGridState = createGridState;

package/dist/editors/cell-editors.d.ts

@@ -0,0 +1,23 @@
+export type CellEditorType = 'text' | 'number' | 'date' | 'datetime' | 'time' | 'password' | 'checkbox' | 'list' | 'chips' | 'select' | 'rich-select' | 'textarea' | 'color' | 'rating';
+/** Normalized option used by list/chips editors. The optional `color`
+ *  paints the chip - both in the in-cell readonly chips render and in
+ *  the dropdown trigger when `renderChipsInTrigger` is on. Any CSS
+ *  color works (hex, rgb, hsl, oklch, named); the chip uses a soft
+ *  tint built via `color-mix` so it sits well on both themes. */
+export type CellEditorOption = {
+    value: string | number;
+    label: string;
+    color?: string;
+};
+export type ParseEditorValueOptions = {
+    /** When true, list/chips return an array; otherwise a scalar. */
+    multiple?: boolean;
+};
+/** Normalize the loose `editorOptions` ColumnDef prop into a uniform shape.
+ *  Dynamic (function) editorOptions are resolved before reaching here. */
+export declare function normalizeEditorOptions(options: ReadonlyArray<string | number | {
+    value: string | number;
+    label?: string;
+    color?: string;
+}> | undefined): CellEditorOption[];
+export declare function parseEditorValue(type: CellEditorType, value: unknown, opts?: ParseEditorValueOptions): any;