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

package/dist/state/api/edit-begin.d.ts

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

package/dist/state/api/edit-begin.js

@@ -0,0 +1,87 @@
+import { focusCell } from "@1771technologies/lytenyte-shared";
+import { runWithBackoff } from "@1771technologies/lytenyte-js-utils";
+import { editOnChange } from "../helpers/edit-on-change.js";
+export const makeEditBegin = (grid) => {
+    return (params) => {
+        if (grid.state.editCellMode.get() === "readonly" || grid.state.columnPivotMode.get())
+            return;
+        // Start by canceling existing edits
+        grid.api.editEnd();
+        // We must be editing a valid cell location
+        const rowCount = grid.state.rowDataStore.rowCount.get();
+        if (params.rowIndex < 0 || params.rowIndex >= rowCount)
+            return;
+        const i = grid.internal;
+        const meta = grid.state.columnMeta.get();
+        // The column must be presently rendered for it to be editable
+        let column;
+        if (typeof params.column === "string")
+            column = meta.columnLookup.get(params.column);
+        else if (typeof params.column === "number")
+            column = meta.columnsVisible.at(params.column);
+        else
+            column = meta.columnsVisible.find((c) => c.id === params.column.id);
+        if (!column)
+            return;
+        const rowNode = grid.state.rowDataSource.get().rowByIndex(params.rowIndex);
+        if (!rowNode)
+            return;
+        // The column must have its editable state set to true
+        const base = grid.state.columnBase.get();
+        const editable = column.editable ?? base.editable;
+        if (!editable)
+            return;
+        if (typeof editable === "function") {
+            if (!editable({ grid, column, row: rowNode, rowIndex: params.rowIndex }))
+                return;
+        }
+        grid.api.scrollIntoView({ column, row: params.rowIndex });
+        // Let's try begin the cell edit.
+        const run = () => {
+            const columnIndex = meta.columnsVisible.indexOf(column);
+            const cell = grid.api.cellRoot(params.rowIndex, columnIndex);
+            if (!cell)
+                return false;
+            if (cell.kind === "full-width")
+                return true;
+            focusCell({
+                getRootCell: grid.api.cellRoot,
+                focusActive: i.focusActive,
+                id: grid.state.gridId.get(),
+                colIndex: columnIndex,
+                rowIndex: params.rowIndex,
+                scrollIntoView: grid.api.scrollIntoView,
+                vp: grid.state.viewport.get(),
+                postFocus: () => {
+                    let prevented = false;
+                    grid.api.eventFire("editBegin", {
+                        column,
+                        rowIndex: params.rowIndex,
+                        preventDefault: () => {
+                            prevented = true;
+                        },
+                    });
+                    if (prevented)
+                        return;
+                    const activeData = structuredClone(rowNode.data);
+                    i.editActivePos.set({ column, rowIndex: params.rowIndex });
+                    i.editData.set(activeData);
+                    if (params.init != null) {
+                        editOnChange({
+                            value: params.init,
+                            activeData,
+                            base,
+                            column,
+                            grid,
+                            row: rowNode,
+                            rowIndex: params.rowIndex,
+                        });
+                    }
+                },
+            });
+            return true;
+        };
+        runWithBackoff(run, [4, 20]);
+        return;
+    };
+};

package/dist/state/api/edit-end.d.ts

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

package/dist/state/api/edit-end.js

@@ -0,0 +1,43 @@
+export const makeEditEnd = (grid) => {
+    return (cancel) => {
+        const active = grid.internal.editActivePos.get();
+        if (!active)
+            return;
+        const data = grid.internal.editData.get();
+        if (cancel) {
+            grid.internal.editActivePos.set(null);
+            grid.internal.editData.set(null);
+            grid.api.eventFire("editCancel", { column: active.column, rowIndex: active.rowIndex, data });
+            return;
+        }
+        const validation = grid.internal.editValidation.get();
+        if (!validation || Object.keys(validation).length >= 1) {
+            grid.api.eventFire("editError", {
+                column: active.column,
+                rowIndex: active.rowIndex,
+                data,
+                validation,
+            });
+            return;
+        }
+        try {
+            const ds = grid.state.rowDataSource.get();
+            ds.rowUpdate(new Map([[active.rowIndex, data]]));
+            grid.api.eventFire("editEnd", { column: active.column, rowIndex: active.rowIndex, data });
+        }
+        catch (e) {
+            grid.api.eventFire("editError", {
+                column: active.column,
+                rowIndex: active.rowIndex,
+                data,
+                validation,
+                error: e,
+            });
+        }
+        finally {
+            grid.internal.editActivePos.set(null);
+            grid.internal.editData.set(null);
+            grid.internal.editValidation.set(true);
+        }
+    };
+};

package/dist/state/api/edit-is-cell-active.d.ts

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

package/dist/state/api/edit-is-cell-active.js

@@ -0,0 +1,22 @@
+export const makeEditIsCellActive = (grid) => {
+    return (params) => {
+        const active = grid.internal.editActivePos.get();
+        if (!active)
+            return false;
+        const meta = grid.state.columnMeta.get();
+        let column;
+        if (typeof params.column === "string")
+            column = meta.columnLookup.get(params.column);
+        else if (typeof params.column === "number")
+            column = meta.columnsVisible.at(params.column);
+        else
+            column = meta.columnsVisible.find((c) => c.id === params.column.id);
+        if (!column)
+            return false;
+        const colIndex = meta.columnsVisible.indexOf(column);
+        const cell = grid.api.cellRoot(params.rowIndex, colIndex);
+        if (!cell || cell.kind === "full-width")
+            return false;
+        return active.column.id === column.id && active.rowIndex === params.rowIndex;
+    };
+};

package/dist/state/api/edit-update.d.ts

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

package/dist/state/api/edit-update.js

@@ -0,0 +1,88 @@
+import { editOnChange } from "../helpers/edit-on-change.js";
+export const makeEditUpdate = (grid) => {
+    return (params) => {
+        if (grid.state.editCellMode.get() === "readonly" || grid.state.columnPivotMode.get())
+            return;
+        // We must be editing a valid cell location
+        const rowCount = grid.state.rowDataStore.rowCount.get();
+        if (params.rowIndex < 0 || params.rowIndex >= rowCount)
+            return;
+        const i = grid.internal;
+        const meta = grid.state.columnMeta.get();
+        // The column must be presently rendered for it to be editable
+        let column;
+        if (typeof params.column === "string")
+            column = meta.columnLookup.get(params.column);
+        else if (typeof params.column === "number")
+            column = meta.columnsVisible.at(params.column);
+        else
+            column = meta.columnsVisible.find((c) => c.id === params.column.id);
+        if (!column)
+            return;
+        const rowNode = grid.state.rowDataSource.get().rowByIndex(params.rowIndex);
+        if (!rowNode)
+            return;
+        // The column must have its editable state set to true
+        const base = grid.state.columnBase.get();
+        const editable = column.editable ?? base.editable;
+        if (!editable)
+            return;
+        if (typeof editable === "function") {
+            if (!editable({ grid, column, row: rowNode, rowIndex: params.rowIndex }))
+                return;
+        }
+        const activeData = structuredClone(rowNode.data);
+        const currentValidation = i.editValidation.get();
+        const currentData = i.editData.get();
+        editOnChange({
+            value: params.value,
+            activeData,
+            base,
+            column,
+            grid,
+            row: rowNode,
+            rowIndex: params.rowIndex,
+        });
+        const updatedData = i.editData.get();
+        const updatedValidation = i.editValidation.get();
+        i.editValidation.set(currentValidation);
+        i.editData.set(currentData);
+        let prevent = false;
+        grid.api.eventFire("editBegin", {
+            column,
+            rowIndex: params.rowIndex,
+            preventDefault: () => {
+                prevent = true;
+            },
+        });
+        if (prevent)
+            return;
+        if (!updatedValidation || Object.keys(updatedValidation).length > 1) {
+            grid.api.eventFire("editError", {
+                column: column,
+                rowIndex: params.rowIndex,
+                data: updatedData,
+                validation: updatedValidation,
+            });
+            return;
+        }
+        try {
+            const ds = grid.state.rowDataSource.get();
+            ds.rowUpdate(new Map([[params.rowIndex, updatedData]]));
+            grid.api.eventFire("editEnd", {
+                column: column,
+                rowIndex: params.rowIndex,
+                data: updatedData,
+            });
+        }
+        catch (e) {
+            grid.api.eventFire("editError", {
+                column: column,
+                rowIndex: params.rowIndex,
+                data: updatedData,
+                validation: updatedValidation,
+                error: e,
+            });
+        }
+    };
+};

package/dist/state/api/event-listeners.d.ts

@@ -0,0 +1,5 @@
+export declare const makeEventListeners: <T>() => {
+    eventAddListener: <K extends keyof import("../../+types").GridEvents<T_1>>(name: K, cb: (event: Parameters<Required<import("../../+types").GridEvents<T>>[K]>[0]) => void) => () => boolean;
+    eventFire: <K extends keyof import("../../+types").GridEvents<T_1>>(name: K, event: Parameters<Required<import("../../+types").GridEvents<T>>[K]>[0]) => void;
+    eventRemoveListener: <K extends keyof import("../../+types").GridEvents<T_1>>(name: K, cb: (event: Parameters<Required<import("../../+types").GridEvents<T>>[K]>[0]) => void) => void;
+};

package/dist/state/api/event-listeners.js

@@ -0,0 +1,19 @@
+export const makeEventListeners = () => {
+    const events = {};
+    return {
+        eventAddListener: (name, cb) => {
+            events[name] ??= new Set();
+            events[name].add(cb);
+            return () => events[name].delete(cb);
+        },
+        eventFire: (name, ...args) => {
+            const listeners = events[name];
+            if (!listeners)
+                return;
+            listeners.forEach((c) => c(...args));
+        },
+        eventRemoveListener: (name, cb) => {
+            events[name]?.delete(cb);
+        },
+    };
+};

package/dist/state/api/export-csv.d.ts

@@ -0,0 +1,3 @@
+import type { Grid, GridApi } from "../../+types";
+export declare const makeExportCsv: (grid: Grid<any>) => GridApi<any>["exportCsv"];
+export declare const makeExportCsvFile: (grid: Grid<any>) => GridApi<any>["exportCsvFile"];

package/dist/state/api/export-csv.js

@@ -0,0 +1,40 @@
+import { getDataRect } from "../helpers/get-data-rect.js";
+export const makeExportCsv = (grid) => {
+    return async (p) => {
+        const visible = grid.state.columnMeta.get().columnsVisible;
+        const rowCount = grid.state.rowDataStore.rowCount.get();
+        const rowStart = p?.dataRect?.rowStart ?? 0;
+        const rowEnd = p?.dataRect?.rowEnd ?? rowCount;
+        const columnStart = p?.dataRect?.columnStart ?? 0;
+        const columnEnd = p?.dataRect?.columnEnd ?? visible.length;
+        const rows = [];
+        for (let i = rowStart; i < rowEnd; i++) {
+            rows.push(grid.api.rowByIndex(i) ?? null);
+        }
+        const { data, groupHeaders, headers } = getDataRect({
+            rows,
+            columnField: grid.api.columnField,
+            visible,
+            columnStart,
+            columnEnd,
+            uniformGroupHeaders: p?.uniformGroupHeaders,
+        });
+        const final = [...data];
+        if (p?.includeHeader)
+            final.unshift(headers);
+        if (p?.includeGroupHeaders)
+            final.unshift(...groupHeaders);
+        return final
+            .map((c) => {
+            return c.map((x) => `"${x}"`).join(p?.delimiter ?? ",");
+        })
+            .join("\n");
+    };
+};
+export const makeExportCsvFile = (grid) => {
+    return async (p) => {
+        const csv = await grid.api.exportCsv(p);
+        const blob = new Blob([csv], { type: "text/csv" });
+        return blob;
+    };
+};

package/dist/state/api/export-data-rect.d.ts

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

package/dist/state/api/export-data-rect.js

@@ -0,0 +1,24 @@
+import { getDataRect } from "../helpers/get-data-rect.js";
+export const makeExportDataRect = (grid) => {
+    return async (p) => {
+        const s = grid.state;
+        const rowCount = s.rowDataStore.rowCount.get();
+        const visible = s.columnMeta.get().columnsVisible;
+        const rowStart = p?.dataRect?.rowStart ?? 0;
+        const rowEnd = p?.dataRect?.rowEnd ?? rowCount;
+        const columnStart = p?.dataRect?.columnStart ?? 0;
+        const columnEnd = p?.dataRect?.columnEnd ?? visible.length;
+        const rows = [];
+        for (let i = rowStart; i < rowEnd; i++) {
+            rows.push(grid.api.rowByIndex(i) ?? null);
+        }
+        return getDataRect({
+            rows,
+            visible,
+            columnField: grid.api.columnField,
+            uniformGroupHeaders: p?.uniformGroupHeaders,
+            columnEnd,
+            columnStart,
+        });
+    };
+};

package/dist/state/api/focus-cell.d.ts

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

package/dist/state/api/focus-cell.js

@@ -0,0 +1,117 @@
+import { focusCell, getHeaderRows, handleNavigationKeys, isColumnFloatingHeader, } from "@1771technologies/lytenyte-shared";
+import { clamp } from "@1771technologies/lytenyte-js-utils";
+export const makeFocusCell = (grid) => {
+    return (position) => {
+        const vp = grid.state.viewport.get();
+        if (!vp)
+            return false;
+        if (typeof position === "string") {
+            let key = "";
+            if (position === "up")
+                key = "ArrowUp";
+            else if (position === "down")
+                key = "ArrowDown";
+            else if (position === "next")
+                key = grid.state.rtl.get() ? "ArrowLeft" : "ArrowRight";
+            else if (position === "prev")
+                key = grid.state.rtl.get() ? "ArrowRight" : "ArrowLeft";
+            if (!key)
+                return false;
+            const ds = grid.state.rowDataStore;
+            handleNavigationKeys({
+                key,
+                ctrlKey: false,
+                metaKey: false,
+                preventDefault: () => { },
+                stopPropagation: () => { },
+            }, {
+                vp,
+                rowCount: ds.rowCount.get(),
+                topCount: ds.rowTopCount.get(),
+                centerCount: ds.rowCenterCount.get(),
+                columnCount: grid.state.columnMeta.get().columnsVisible.length,
+                focusActive: grid.internal.focusActive,
+                id: grid.state.gridId.get(),
+                getRootCell: grid.api.cellRoot,
+                rtl: grid.state.rtl.get(),
+                scrollIntoView: grid.api.scrollIntoView,
+            });
+            return true;
+        }
+        if ("kind" in position) {
+            if (position.kind === "header-cell") {
+                grid.api.scrollIntoView({ column: position.colIndex });
+                const run = () => {
+                    const header = getHeaderRows(vp);
+                    if (!header)
+                        return false;
+                    for (const row of header) {
+                        const cell = row.querySelector(`[data-ln-header-cell][data-ln-colindex="${position.colIndex}"]`);
+                        if (!cell)
+                            continue;
+                        if (isColumnFloatingHeader(cell))
+                            continue;
+                        cell.focus();
+                        return true;
+                    }
+                    return false;
+                };
+                if (!run()) {
+                    setTimeout(() => {
+                        if (!run()) {
+                            setTimeout(() => run(), 20);
+                        }
+                    }, 8);
+                }
+                return true;
+            }
+            else if (position.kind === "header-group-cell") {
+                grid.api.scrollIntoView({ column: position.colIndex });
+                const run = () => {
+                    const header = getHeaderRows(vp);
+                    if (!header)
+                        return false;
+                    const row = header[position.hierarchyRowIndex];
+                    if (!row)
+                        return false;
+                    const headers = Array.from(row.querySelectorAll("[data-ln-header-range]"));
+                    const match = headers.find((c) => {
+                        const [colStartStr, colEndStr] = c.getAttribute("data-ln-header-range").split(",");
+                        const colStart = Number.parseInt(colStartStr);
+                        const colEnd = Number.parseInt(colEndStr);
+                        return colStart <= position.colIndex && position.colIndex < colEnd;
+                    });
+                    if (match) {
+                        match.focus();
+                        grid.internal.focusActive.set((prev) => ({ ...prev, colIndex }));
+                        return true;
+                    }
+                    return false;
+                };
+                if (!run()) {
+                    setTimeout(() => {
+                        if (!run()) {
+                            setTimeout(() => run(), 20);
+                        }
+                    }, 8);
+                }
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        const columnCount = grid.state.columnMeta.get().columnsVisible.length - 1;
+        const colIndex = clamp(0, typeof position.column === "number" ? position.column : grid.api.columnIndex(position.column), columnCount);
+        focusCell({
+            colIndex,
+            rowIndex: position.row,
+            focusActive: grid.internal.focusActive,
+            id: grid.state.gridId.get(),
+            getRootCell: grid.api.cellRoot,
+            scrollIntoView: grid.api.scrollIntoView,
+            vp,
+        });
+        return false;
+    };
+};

package/dist/state/api/popover-frame.d.ts

@@ -0,0 +1,8 @@
+import type { InternalAtoms } from "../+types.js";
+import type { Grid, GridApi } from "../../+types.js";
+export declare const makePopoverFrameOpen: (grid: Grid<any> & {
+    internal: InternalAtoms;
+}) => GridApi<any>["popoverFrameOpen"];
+export declare const makePopoverFrameClose: (grid: Grid<any> & {
+    internal: InternalAtoms;
+}) => GridApi<any>["popoverFrameClose"];

package/dist/state/api/popover-frame.js

@@ -0,0 +1,16 @@
+export const makePopoverFrameOpen = (grid) => {
+    return (id, target, context) => {
+        grid.internal.popoverFrames.set((prev) => ({ ...prev, [id]: { target, context } }));
+    };
+};
+export const makePopoverFrameClose = (grid) => {
+    return (id) => {
+        grid.internal.popoverFrames.set((prev) => {
+            if (!id)
+                return {};
+            const next = { ...prev };
+            delete next[id];
+            return next;
+        });
+    };
+};

package/dist/state/api/position-from-element.d.ts

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

package/dist/state/api/position-from-element.js

@@ -0,0 +1,9 @@
+import { getNearestFocusable, getPositionFromFocusable } from "@1771technologies/lytenyte-shared";
+export const makePositionFromElement = () => {
+    return (el) => {
+        const focusable = getNearestFocusable(el);
+        if (!focusable)
+            return null;
+        return getPositionFromFocusable(focusable);
+    };
+};

package/dist/state/api/row-by-id.d.ts

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

package/dist/state/api/row-by-id.js

@@ -0,0 +1,5 @@
+export const makeRowById = (grid) => {
+    return (id) => {
+        return grid.state.rowDataSource.get().rowById(id);
+    };
+};

package/dist/state/api/row-by-index.d.ts

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

package/dist/state/api/row-by-index.js

@@ -0,0 +1,9 @@
+import { rowIndexForSection } from "@1771technologies/lytenyte-shared";
+export const makeRowByIndex = (grid) => {
+    return (index, section = "flat") => {
+        const rowIndex = rowIndexForSection(index, section, grid.state.rowDataStore.rowTopCount.get(), grid.state.rowDataStore.rowBottomCount.get(), grid.state.rowDataStore.rowCount.get());
+        if (rowIndex == null)
+            return null;
+        return grid.state.rowDataSource.get().rowByIndex(rowIndex);
+    };
+};

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

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

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

@@ -0,0 +1,6 @@
+export const makeRowDetailIsExpanded = (grid) => {
+    return (rowOrId) => {
+        const id = typeof rowOrId === "string" ? rowOrId : rowOrId.id;
+        return grid.state.rowDetailExpansions.get().has(id);
+    };
+};

package/dist/state/api/row-detail-rendered-height.d.ts

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

package/dist/state/api/row-detail-rendered-height.js

@@ -0,0 +1,14 @@
+export const makeRowDetailRenderedHeight = (grid) => {
+    return (rowOrId) => {
+        const index = grid.state.rowDataSource
+            .get()
+            .rowToIndex(typeof rowOrId === "string" ? rowOrId : rowOrId.id);
+        if (index == null || !grid.api.rowDetailIsExpanded(rowOrId))
+            return 0;
+        const rowDetailHeight = grid.state.rowDetailHeight.get();
+        if (typeof rowDetailHeight === "number")
+            return rowDetailHeight;
+        const cache = grid.internal.rowDetailAutoHeightCache.get();
+        return cache[index] ?? grid.state.rowDetailAutoHeightGuess.get();
+    };
+};

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

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

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

@@ -0,0 +1,32 @@
+export const makeRowDetailToggle = (grid) => {
+    return (rowOrId, state) => {
+        const row = typeof rowOrId === "string" ? grid.api.rowById(rowOrId) : grid.api.rowById(rowOrId.id);
+        if (!row)
+            return;
+        const isExpanded = grid.api.rowDetailIsExpanded(rowOrId);
+        const v = state != null ? state : !isExpanded;
+        if (v === isExpanded)
+            return;
+        const s = grid.state.rowDetailExpansions.get();
+        const next = new Set(s);
+        if (v)
+            next.add(row.id);
+        else
+            next.delete(row.id);
+        let prevented = false;
+        grid.api.eventFire("rowDetailExpansionBegin", {
+            expansions: next,
+            grid: grid,
+            preventDefault: () => {
+                prevented = true;
+            },
+        });
+        if (prevented)
+            return;
+        grid.state.rowDetailExpansions.set(next);
+        grid.api.eventFire("rowDetailExpansionEnd", {
+            expansions: next,
+            grid: grid,
+        });
+    };
+};

package/dist/state/api/row-group-apply-expansions.d.ts

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