@1771technologies/lytenyte-pro 1.0.12-dev.1 → 1.0.12-dev.2

package/dist/state/api/row-group-apply-expansions.js

@@ -0,0 +1,20 @@
+export const makeRowGroupApplyExpansions = (grid) => {
+    return (expansions) => {
+        const api = grid.api;
+        let prevented = false;
+        const preventNext = () => {
+            prevented = true;
+        };
+        try {
+            api.eventFire("rowExpandBegin", { expansions, grid, preventDefault: preventNext });
+            if (prevented)
+                return;
+            const rds = grid.state.rowDataSource.get();
+            rds.rowExpand(expansions);
+            api.eventFire("rowExpand", { expansions, grid });
+        }
+        catch (error) {
+            api.eventFire("rowExpandError", { expansions, grid, error });
+        }
+    };
+};

package/dist/state/api/row-group-column-index.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, GridApi } from "../../+types";
+export declare const makeRowGroupColumnIndex: (grid: Grid<any>) => GridApi<any>["rowGroupColumnIndex"];

package/dist/state/api/row-group-column-index.js

@@ -0,0 +1,14 @@
+import { GROUP_COLUMN_PREFIX, GROUP_COLUMN_SINGLE_ID, GROUP_COLUMN_TREE_DATA, } from "@1771technologies/lytenyte-shared";
+export const makeRowGroupColumnIndex = (grid) => {
+    return (c) => {
+        if (!grid.state.rowGroupModel.get().length || !c.id.startsWith(GROUP_COLUMN_PREFIX)) {
+            return -1;
+        }
+        if (c.id === GROUP_COLUMN_SINGLE_ID || c.id === GROUP_COLUMN_TREE_DATA)
+            return 0;
+        const n = c.id.split(":").at(-1);
+        if (n == null)
+            return -1;
+        return Number.parseInt(n);
+    };
+};

package/dist/state/api/row-group-is-expanded.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, GridApi } from "../../+types";
+export declare const makeRowGroupIsExpanded: (grid: Grid<any>) => GridApi<any>["rowGroupIsExpanded"];

package/dist/state/api/row-group-is-expanded.js

@@ -0,0 +1,15 @@
+export const makeRowGroupIsExpanded = (grid) => {
+    return (row) => {
+        const mode = grid.state.columnPivotMode.get();
+        const expansions = mode
+            ? grid.state.columnPivotRowGroupExpansions.get()
+            : grid.state.rowGroupExpansions.get();
+        const expanded = expansions[row.id];
+        if (typeof expanded === "boolean")
+            return expanded;
+        const defaultExpansion = grid.state.rowGroupDefaultExpansion.get();
+        if (typeof defaultExpansion === "boolean")
+            return defaultExpansion;
+        return row.depth <= defaultExpansion;
+    };
+};

package/dist/state/api/row-group-toggle.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, GridApi } from "../../+types";
+export declare const makeRowGroupToggle: (grid: Grid<any>) => GridApi<any>["rowGroupToggle"];

package/dist/state/api/row-group-toggle.js

@@ -0,0 +1,7 @@
+export const makeRowGroupToggle = (grid) => {
+    return (row, state) => {
+        const api = grid.api;
+        const next = state == null ? !api.rowGroupIsExpanded(row) : state;
+        api.rowGroupApplyExpansions({ [row.id]: next });
+    };
+};

package/dist/state/api/row-handle-select.d.ts

@@ -0,0 +1,5 @@
+import type { Grid, GridApi } from "../../+types";
+import type { InternalAtoms } from "../+types";
+export declare const makeRowHandleSelect: (grid: Grid<any> & {
+    internal: InternalAtoms;
+}) => GridApi<any>["rowHandleSelect"];

package/dist/state/api/row-handle-select.js

@@ -0,0 +1,43 @@
+import { getNearestRow, getRowIndexFromEl } from "@1771technologies/lytenyte-shared";
+export const makeRowHandleSelect = (grid) => {
+    return (e) => {
+        const mode = grid.state.rowSelectionMode.get();
+        if (mode === "none")
+            return;
+        const rowEl = getNearestRow(e.target);
+        if (!rowEl)
+            return;
+        const row = grid.api.rowByIndex(getRowIndexFromEl(rowEl));
+        if (!row)
+            return;
+        if (mode === "single") {
+            grid.api.rowSelect({
+                selected: row.id,
+                deselect: grid.state.rowSelectedIds.get().has(row.id),
+            });
+            return;
+        }
+        if (mode === "multiple") {
+            // We are doing an additive select
+            if (e.shiftKey) {
+                const isDeselect = grid.internal.rowSelectionLastWasDeselect.get();
+                grid.api.rowSelect({
+                    selected: row.id,
+                    deselect: isDeselect,
+                    selectBetweenPivot: true,
+                    selectChildren: grid.state.rowSelectChildren.get(),
+                });
+            }
+            else {
+                const isDeselect = grid.state.rowSelectedIds.get().has(row.id);
+                grid.api.rowSelect({
+                    selected: row.id,
+                    deselect: isDeselect,
+                    pivot: row.id,
+                    selectBetweenPivot: false,
+                    selectChildren: grid.state.rowSelectChildren.get(),
+                });
+            }
+        }
+    };
+};

package/dist/state/api/row-select-all.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, GridApi } from "../../+types";
+export declare const makeRowSelectAll: (grid: Grid<any>) => GridApi<any>["rowSelectAll"];

package/dist/state/api/row-select-all.js

@@ -0,0 +1,17 @@
+export const makeRowSelectAll = (grid) => {
+    return (p) => {
+        let stop = false;
+        grid.api.eventFire("rowSelectAllBegin", {
+            deselect: p?.deselect ?? false,
+            grid,
+            preventDefault: () => {
+                stop = true;
+            },
+        });
+        if (stop)
+            return;
+        const rds = grid.state.rowDataSource.get();
+        rds.rowSelectAll(p ?? {});
+        grid.api.eventFire("rowSelectAllEnd", { deselect: !!p?.deselect, grid });
+    };
+};

package/dist/state/api/row-select.d.ts

@@ -0,0 +1,5 @@
+import type { InternalAtoms } from "../+types";
+import type { Grid, GridApi } from "../../+types";
+export declare const makeRowSelect: (grid: Grid<any> & {
+    internal: InternalAtoms;
+}) => GridApi<any>["rowSelect"];

package/dist/state/api/row-select.js

@@ -0,0 +1,35 @@
+export const makeRowSelect = (grid) => {
+    return (params) => {
+        let stop = false;
+        grid.api.eventFire("rowSelectBegin", {
+            grid,
+            preventDefault: () => {
+                stop = true;
+            },
+            selected: params.selected,
+            deselect: !!params.deselect,
+        });
+        if (stop)
+            return;
+        const rds = grid.state.rowDataSource.get();
+        if (params.pivot)
+            grid.internal.rowSelectionPivot.set(params.selected);
+        else if (!params.selectBetweenPivot)
+            grid.internal.rowSelectionPivot.set(null);
+        const pivot = grid.internal.rowSelectionPivot.get() ?? params.selected;
+        rds.rowSelect({
+            deselect: !!params.deselect,
+            startId: params.selected,
+            endId: params.selectBetweenPivot ? pivot : params.selected,
+            selectChildren: !!params.selectChildren,
+            mode: grid.state.rowSelectionMode.get(),
+        });
+        if (!params.selectBetweenPivot)
+            grid.internal.rowSelectionLastWasDeselect.set(!!params.deselect);
+        grid.api.eventFire("rowSelectEnd", {
+            grid,
+            selected: params.selected,
+            deselect: !!params.deselect,
+        });
+    };
+};

package/dist/state/api/row-selected.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, GridApi } from "../../+types";
+export declare const makeRowSelected: (grid: Grid<any>) => GridApi<any>["rowSelected"];

package/dist/state/api/row-selected.js

@@ -0,0 +1,13 @@
+export const makeRowSelected = (grid) => {
+    return () => {
+        const selected = grid.state.rowSelectedIds.get();
+        const rds = grid.state.rowDataSource.get();
+        const rows = [];
+        for (const id of selected) {
+            const row = rds.rowById(id);
+            if (row)
+                rows.push(row);
+        }
+        return rows;
+    };
+};

package/dist/state/api/scroll-into-view.d.ts

@@ -0,0 +1,5 @@
+import type { Grid, GridApi } from "../../+types";
+import type { InternalAtoms } from "../+types";
+export declare const makeScrollIntoView: (grid: Grid<any> & {
+    internal: InternalAtoms;
+}) => GridApi<any>["scrollIntoView"];

package/dist/state/api/scroll-into-view.js

@@ -0,0 +1,50 @@
+import { columnScrollIntoViewValue, rowScrollIntoViewValue, } from "@1771technologies/lytenyte-shared";
+export const makeScrollIntoView = (grid) => {
+    return (opts) => {
+        const vp = grid.state.viewport.get();
+        if (!vp)
+            return;
+        let x = undefined;
+        let y = undefined;
+        const col = opts.column;
+        if (col != null) {
+            const meta = grid.state.columnMeta.get();
+            let colIndex;
+            if (typeof col === "number")
+                colIndex = col;
+            else if (typeof col === "string")
+                colIndex = meta.columnsVisible.findIndex((c) => c.id === col);
+            else
+                colIndex = meta.columnsVisible.findIndex((c) => c.id === col.id);
+            if (colIndex !== -1) {
+                x = columnScrollIntoViewValue({
+                    centerCount: meta.columnsVisible.filter((c) => c.pin !== "start" && c.pin !== "end")
+                        .length,
+                    startCount: meta.columnsVisible.filter((c) => c.pin === "start").length,
+                    endCount: meta.columnsVisible.filter((c) => c.pin === "end").length,
+                    columnIndex: colIndex,
+                    columnPositions: grid.state.xPositions.get(),
+                    viewport: vp,
+                });
+            }
+        }
+        const row = opts.row;
+        if (row != null) {
+            y = rowScrollIntoViewValue({
+                bottomCount: grid.state.rowDataStore.rowBottomCount.get(),
+                topCount: grid.state.rowDataStore.rowTopCount.get(),
+                rowCount: grid.state.rowDataStore.rowCount.get(),
+                headerHeight: grid.internal.headerHeightTotal.get(),
+                rowIndex: row,
+                rowPositions: grid.state.yPositions.get(),
+                viewport: vp,
+            });
+        }
+        const rtl = grid.state.rtl.get();
+        vp.scrollTo({
+            left: x != null ? x * (rtl ? -1 : 1) : undefined,
+            top: y,
+            behavior: opts.behavior ?? "auto",
+        });
+    };
+};

package/dist/state/api/sort-for-column.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, GridApi } from "../../+types";
+export declare const makeSortForColumn: (grid: Grid<any>) => GridApi<any>["sortForColumn"];

package/dist/state/api/sort-for-column.js

@@ -0,0 +1,9 @@
+export const makeSortForColumn = (grid) => {
+    return (id) => {
+        const model = grid.state.sortModel.get();
+        const index = model.findIndex((c) => c.columnId === id);
+        if (index === -1)
+            return null;
+        return { index, sort: model[index] };
+    };
+};

package/dist/state/api/use-row-drag.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, GridApi } from "../../+types";
+export declare const makeUseRowDrag: (grid: Grid<any>) => GridApi<any>["useRowDrag"];

package/dist/state/api/use-row-drag.js

@@ -0,0 +1,27 @@
+import { getNearestRow, getRowIndexFromEl, useDraggable } from "@1771technologies/lytenyte-shared";
+export const makeUseRowDrag = (grid) => {
+    return (params) => {
+        const c = useDraggable({
+            ...params,
+            placeholder: params.placeholder
+                ? (d) => {
+                    return params.placeholder({
+                        grid,
+                        dragData: d,
+                    });
+                }
+                : undefined,
+            getItems: (el) => {
+                const nearestRow = getNearestRow(el);
+                if (!nearestRow)
+                    return {};
+                const rowIndex = getRowIndexFromEl(nearestRow);
+                const row = grid.api.rowByIndex(rowIndex);
+                if (!row)
+                    return {};
+                return params.getDragData({ grid, row });
+            },
+        });
+        return c;
+    };
+};

package/dist/state/helpers/cell-row-group.d.ts

@@ -0,0 +1,2 @@
+import type { CellRendererParams } from "../../+types";
+export declare function CellRowGroup<T>({ column, row, grid }: CellRendererParams<T>): import("react/jsx-runtime").JSX.Element;

package/dist/state/helpers/cell-row-group.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export function CellRowGroup({ column, row, grid }) {
+    if (grid.api.rowIsLeaf(row))
+        return _jsx("div", {});
+    const multi = grid.state.rowGroupDisplayMode.get() === "multi-column";
+    if (multi) {
+        const index = grid.api.rowGroupColumnIndex(column);
+        if (index !== row.depth)
+            return _jsx("div", {});
+    }
+    return (_jsx("div", { onClick: () => grid.api.rowGroupToggle(row), style: {
+            display: "flex",
+            alignItems: "center",
+            width: "100%",
+            height: "100%",
+            paddingInline: "8px",
+            boxSizing: "border-box",
+        }, children: row.key }));
+}

package/dist/state/helpers/column-add-row-group.d.ts

@@ -0,0 +1,10 @@
+import type { Column, RowGroupColumn, RowGroupDisplayMode, RowGroupModelItem } from "../../+types.js";
+interface ColumnHandleGroupColumnArgs<T> {
+    readonly columns: Column<T>[];
+    readonly rowGroupTemplate: RowGroupColumn<T>;
+    readonly rowGroupModel: RowGroupModelItem<T>[];
+    readonly rowGroupDisplayMode: RowGroupDisplayMode;
+    readonly rowGroupColumnState: Record<string, Partial<Column<T>>>;
+}
+export declare function columnAddRowGroup<T>({ columns, rowGroupModel, rowGroupDisplayMode, rowGroupTemplate, rowGroupColumnState, }: ColumnHandleGroupColumnArgs<T>): Column<T>[];
+export {};

package/dist/state/helpers/column-add-row-group.js

@@ -0,0 +1,74 @@
+import { GROUP_COLUMN_MULTI_PREFIX, GROUP_COLUMN_PREFIX, GROUP_COLUMN_SINGLE_ID, } from "@1771technologies/lytenyte-shared";
+import { itemsWithIdToMap } from "@1771technologies/lytenyte-js-utils";
+import { CellRowGroup } from "./cell-row-group.js";
+const baseGroup = {
+    name: "Group",
+    cellRenderer: CellRowGroup,
+    field: (d) => {
+        if (d.data.kind === "leaf")
+            return null;
+        return d.data.key;
+    },
+};
+export function columnAddRowGroup({ columns, rowGroupModel, rowGroupDisplayMode, rowGroupTemplate, rowGroupColumnState, }) {
+    const lookup = itemsWithIdToMap(columns);
+    rowGroupModel.forEach((c) => {
+        if (typeof c === "string")
+            return;
+        lookup.set(c.id, c);
+    });
+    const isSingleGroupDisplay = rowGroupDisplayMode === "single-column";
+    const isMultiGroupDisplay = rowGroupDisplayMode === "multi-column";
+    const hasGroupColumn = rowGroupModel.length > 0 && (isSingleGroupDisplay || isMultiGroupDisplay);
+    if (hasGroupColumn && isSingleGroupDisplay) {
+        columns = columns.filter((c) => !c.id.startsWith(GROUP_COLUMN_MULTI_PREFIX));
+        if (!lookup.has(GROUP_COLUMN_SINGLE_ID)) {
+            const groupColumn = { ...baseGroup, ...rowGroupTemplate, id: GROUP_COLUMN_SINGLE_ID };
+            columns.unshift(groupColumn);
+        }
+    }
+    if (hasGroupColumn && isMultiGroupDisplay) {
+        const weNeedXColumns = rowGroupModel.length;
+        columns = columns.filter((c) => {
+            const posCnt = c.id.startsWith(GROUP_COLUMN_MULTI_PREFIX)
+                ? Number.parseInt(c.id.split(":").at(-1))
+                : null;
+            if (c.id === GROUP_COLUMN_SINGLE_ID || (posCnt != null && posCnt >= weNeedXColumns))
+                return false;
+            return true;
+        });
+        let reorder = false;
+        for (let i = weNeedXColumns - 1; i >= 0; i--) {
+            const columnId = `${GROUP_COLUMN_MULTI_PREFIX}${i}`;
+            if (!lookup.has(columnId)) {
+                const column = { ...baseGroup, ...rowGroupTemplate, id: columnId };
+                columns.unshift(column);
+                reorder = true;
+                lookup.set(columnId, column);
+            }
+            const groupColumn = lookup.get(columnId);
+            const modelItem = rowGroupModel[i];
+            const referenceColumn = lookup.get(typeof modelItem === "string" ? modelItem : modelItem.id);
+            groupColumn.headerName =
+                referenceColumn?.name ?? referenceColumn?.id ?? `Group ${i}`;
+        }
+        if (reorder) {
+            const group = columns
+                .filter((c) => c.id.startsWith(GROUP_COLUMN_MULTI_PREFIX))
+                .sort((l, r) => l.id.localeCompare(r.id));
+            const nonGroup = columns.filter((c) => !c.id.startsWith(GROUP_COLUMN_MULTI_PREFIX));
+            columns = [...group, ...nonGroup];
+        }
+    }
+    if (!hasGroupColumn)
+        columns = columns.filter((c) => !c.id.startsWith(GROUP_COLUMN_PREFIX));
+    // TODO: this can be improved - what if the columns are really large?
+    const keys = Object.keys(rowGroupColumnState);
+    for (let i = 0; i < keys.length; i++) {
+        const column = columns.find((c) => c.id === keys[i]);
+        if (!column)
+            continue;
+        Object.assign(column, rowGroupColumnState[keys[i]]);
+    }
+    return columns;
+}

package/dist/state/helpers/column-layout.d.ts

@@ -0,0 +1,3 @@
+import type { HeaderLayoutCell } from "../../+types";
+import type { MakeColumnViewReturn } from "./column-view";
+export declare function makeColumnLayout<T>(view: MakeColumnViewReturn<T>, floatingRowEnabled: boolean): HeaderLayoutCell<T>[][];

package/dist/state/helpers/column-layout.js

@@ -0,0 +1,59 @@
+export function makeColumnLayout(view, floatingRowEnabled) {
+    const combinedView = view.combinedView;
+    const groupMeta = view.meta;
+    const centerEnd = view.startCount + view.centerCount;
+    const layout = [];
+    const floatingRow = [];
+    for (let r = 0; r < combinedView.length; r++) {
+        const row = combinedView[r];
+        const rowLayout = [];
+        for (let i = 0; i < row.length; i++) {
+            const c = row[i];
+            const colS = c.colStart;
+            const colPin = colS < view.startCount ? "start" : colS >= centerEnd ? "end" : null;
+            if (c.kind === "leaf") {
+                const vals = {
+                    id: c.data.id,
+                    colPin,
+                    column: c.data,
+                    rowStart: c.rowStart,
+                    rowEnd: c.rowStart + c.rowSpan,
+                    rowSpan: c.rowSpan,
+                    colStart: c.colStart,
+                    colEnd: c.colStart + c.colSpan,
+                    colSpan: c.colSpan,
+                    colFirstEndPin: c.colStart === centerEnd ? true : undefined,
+                    colLastStartPin: c.colStart + c.colSpan === view.startCount ? true : undefined,
+                };
+                rowLayout.push({ kind: "cell", ...vals });
+                if (floatingRowEnabled) {
+                    floatingRow.push({ kind: "floating", ...vals });
+                }
+                continue;
+            }
+            rowLayout.push({
+                kind: "group",
+                colPin,
+                id: c.data.id,
+                isCollapsible: groupMeta.groupIsCollapsible.get(c.data.id),
+                idOccurrence: c.data.idOccurrence,
+                rowStart: c.rowStart,
+                rowEnd: c.rowStart + c.rowSpan,
+                rowSpan: c.rowSpan,
+                colStart: c.colStart,
+                colEnd: c.colStart + c.colSpan,
+                colSpan: c.colSpan,
+                columnIds: [...c.data.idsInNode],
+                groupPath: c.data.groupPath,
+                start: c.data.start,
+                end: c.data.end,
+                colFirstEndPin: c.colStart === centerEnd ? true : undefined,
+                colLastStartPin: c.colStart + c.colSpan === view.startCount ? true : undefined,
+            });
+        }
+        layout.push(rowLayout);
+    }
+    if (floatingRowEnabled)
+        layout.push(floatingRow);
+    return layout;
+}

package/dist/state/helpers/column-marker.d.ts

@@ -0,0 +1,8 @@
+import type { Column, ColumnMarker } from "../../+types";
+interface ColumnHandleMarkerArgs<T> {
+    readonly columns: Column<T>[];
+    readonly marker: ColumnMarker<T>;
+    readonly markerEnabled: boolean;
+}
+export declare function columnHandleMarker<T>({ columns, marker, markerEnabled, }: ColumnHandleMarkerArgs<T>): Column<T>[];
+export {};

package/dist/state/helpers/column-marker.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { COLUMN_MARKER_ID } from "@1771technologies/lytenyte-shared";
+import { itemsWithIdToMap } from "@1771technologies/lytenyte-js-utils";
+export function columnHandleMarker({ columns, marker, markerEnabled, }) {
+    const lookup = itemsWithIdToMap(columns);
+    if (markerEnabled && !lookup.has(COLUMN_MARKER_ID)) {
+        columns = [
+            {
+                id: COLUMN_MARKER_ID,
+                name: "",
+                pin: "start",
+                width: marker.width ?? 30,
+                widthMin: 24,
+                cellRenderer: marker.cellRenderer,
+                headerRenderer: marker.headerRenderer ?? HeaderRenderer,
+                floatingCellRenderer: marker.floatingCellRenderer ?? FloatingRenderer,
+                uiHints: marker.uiHints,
+            },
+            ...columns,
+        ];
+        lookup.set(COLUMN_MARKER_ID, columns[0]);
+    }
+    else if (!markerEnabled && lookup.has(COLUMN_MARKER_ID)) {
+        const index = columns.findIndex((c) => c.id === COLUMN_MARKER_ID);
+        columns.splice(index, 1);
+    }
+    if (markerEnabled) {
+        const column = lookup.get(COLUMN_MARKER_ID);
+        // The marker column must always be the first column displayed in the grid.
+        const index = columns.findIndex((c) => c.id === COLUMN_MARKER_ID);
+        if (index !== 0) {
+            columns.splice(index, 1);
+            columns.unshift(column);
+        }
+    }
+    return columns;
+}
+function HeaderRenderer() {
+    return (_jsx(_Fragment, { children: _jsx("div", { style: { overflow: "hidden", opacity: 0, width: "100%", height: "100%" }, children: "Marker column default" }) }));
+}
+function FloatingRenderer() {
+    return _jsx(_Fragment, {});
+}

package/dist/state/helpers/column-view.d.ts

@@ -0,0 +1,21 @@
+import { type PathTableItem } from "@1771technologies/lytenyte-shared";
+import type { Column, ColumnBase, ColumnGroupMeta } from "../../+types";
+export interface MakeColumnViewArgs<T> {
+    readonly columns: Column<T>[];
+    readonly base: ColumnBase<T>;
+    readonly groupExpansions: Record<string, boolean>;
+    readonly groupJoinDelimiter: string;
+    readonly groupExpansionDefault: boolean;
+}
+export interface MakeColumnViewReturn<T> {
+    meta: ColumnGroupMeta;
+    maxRow: number;
+    maxCol: number;
+    combinedView: PathTableItem<Column<T>>[][];
+    visibleColumns: Column<T>[];
+    lookup: Map<string, Column<T>>;
+    startCount: number;
+    endCount: number;
+    centerCount: number;
+}
+export declare function makeColumnView<T>({ columns, base, groupExpansions, groupJoinDelimiter, groupExpansionDefault, }: MakeColumnViewArgs<T>): MakeColumnViewReturn<T>;

package/dist/state/helpers/column-view.js

@@ -0,0 +1,33 @@
+import { computePathTable, getMaxHeaderDepth, getVisibleColumns, getVisibleColumnsWithGroups, makeColumnGroupMetadata, partitionColumnsByPinState, } from "@1771technologies/lytenyte-shared";
+export function makeColumnView({ columns, base, groupExpansions, groupJoinDelimiter, groupExpansionDefault, }) {
+    const lookup = new Map(columns.map((c) => [c.id, c]));
+    const columnsNotHidden = getVisibleColumns(columns, base);
+    const groupMetadata = makeColumnGroupMetadata(columnsNotHidden, groupJoinDelimiter);
+    const visible = getVisibleColumnsWithGroups(columnsNotHidden, groupMetadata, groupExpansions, groupExpansionDefault);
+    const { start, center, end } = partitionColumnsByPinState(visible);
+    const seenMap = {};
+    const maxDepth = getMaxHeaderDepth(visible);
+    const endOffset = start.length + center.length;
+    const startTable = computePathTable(start, maxDepth, seenMap, groupJoinDelimiter, 0).table;
+    const centerTable = computePathTable(center, maxDepth, seenMap, groupJoinDelimiter, start.length).table;
+    const endTable = computePathTable(end, maxDepth, seenMap, groupJoinDelimiter, endOffset).table;
+    const combinedView = [];
+    for (let i = 0; i <= maxDepth; i++) {
+        const row = [];
+        row.push(...(startTable[i] ?? []));
+        row.push(...(centerTable[i] ?? []));
+        row.push(...(endTable[i] ?? []));
+        combinedView.push(row);
+    }
+    return {
+        meta: groupMetadata,
+        maxRow: maxDepth + 1,
+        maxCol: visible.length,
+        combinedView,
+        visibleColumns: [...start, ...center, ...end],
+        lookup,
+        startCount: start.length,
+        endCount: end.length,
+        centerCount: center.length,
+    };
+}

package/dist/state/helpers/edit-on-change.d.ts

@@ -0,0 +1,15 @@
+import type { InternalAtoms } from "../+types";
+import type { Column, ColumnBase, Grid, RowNode } from "../../+types";
+interface EditOnChangeArgs<T> {
+    readonly column: Column<T>;
+    readonly base: ColumnBase<T>;
+    readonly activeData: any;
+    readonly row: RowNode<T>;
+    readonly value: any;
+    readonly grid: Grid<T> & {
+        internal: InternalAtoms;
+    };
+    readonly rowIndex: number;
+}
+export declare function editOnChange<T>({ value: c, grid, rowIndex, column, base, row, activeData, }: EditOnChangeArgs<T>): void;
+export {};

package/dist/state/helpers/edit-on-change.js

@@ -0,0 +1,27 @@
+export function editOnChange({ value: c, grid, rowIndex, column, base, row, activeData, }) {
+    const field = column.field ?? column.id;
+    let next = structuredClone(activeData);
+    if (row.kind !== "branch" && typeof field === "number")
+        next[field] = c;
+    else if (row.kind !== "branch" && typeof field === "string")
+        next[field] = c;
+    else {
+        const setter = column.editSetter ?? base.editSetter;
+        if (!setter) {
+            console.error("A column with a non-trivial field must provide a corresponding editSetter to be editable.");
+            return;
+        }
+        next = setter({
+            column,
+            data: next,
+            grid: grid,
+            value: c,
+            row,
+            rowIndex,
+        });
+    }
+    const validator = grid.state.editRowValidatorFn.get();
+    const result = validator.fn({ grid: grid, rowIndex: rowIndex, data: next, row });
+    grid.internal.editData.set(next);
+    grid.internal.editValidation.set(result);
+}

package/dist/state/helpers/empty-row-data-source.d.ts

@@ -0,0 +1,2 @@
+import type { RowDataSource } from "../../+types";
+export declare const emptyRowDataSource: RowDataSource<any>;