@svgrid/grid 1.0.2 → 1.1.1

package/dist/keyboard-handlers.js

@@ -0,0 +1,202 @@
+import "./sv-grid-scrollbar";
+import { getKeyboardIntent, getNextActiveCell } from "./keyboard";
+export function createKeyboard(ctx) {
+    function onGridKeyDown(event) {
+        // Only the grid root drives navigation - keys on header buttons, menus,
+        // or the cell editor are handled by those controls themselves.
+        if (event.target !== event.currentTarget)
+            return;
+        if (ctx.editingCell)
+            return;
+        if ((event.ctrlKey || event.metaKey) && !event.altKey) {
+            const lower = event.key.toLowerCase();
+            if (lower === "c") {
+                event.preventDefault();
+                ctx.copySelectionToClipboard();
+                return;
+            }
+            if (lower === "v") {
+                // Secure context: read via the async Clipboard API and swallow the
+                // key. Insecure context (no navigator.clipboard): DON'T preventDefault
+                // so the browser delivers a native `paste` event to `onGridPaste`.
+                if (typeof navigator.clipboard?.readText === "function") {
+                    event.preventDefault();
+                    void ctx.pasteFromClipboard();
+                }
+                return;
+            }
+            if (lower === "x") {
+                event.preventDefault();
+                void ctx.cutSelectionToClipboard();
+                return;
+            }
+            // Ctrl+Z (Cmd+Z) undoes the most recent cell edit. Ctrl+Shift+Z
+            // and Ctrl+Y both redo. Mirrors VSCode / Sheets / Excel.
+            if (lower === "z" && !event.shiftKey) {
+                event.preventDefault();
+                if (ctx.historyPtr >= 0) {
+                    const step = ctx.history[ctx.historyPtr];
+                    if (step) {
+                        ctx.applyHistoryStep(step, 'undo');
+                        ctx.historyPtr -= 1;
+                        ctx.historyVersion += 1;
+                    }
+                }
+                return;
+            }
+            if ((lower === "z" && event.shiftKey) || lower === "y") {
+                event.preventDefault();
+                if (ctx.historyPtr < ctx.history.length - 1) {
+                    const step = ctx.history[ctx.historyPtr + 1];
+                    if (step) {
+                        ctx.applyHistoryStep(step, 'redo');
+                        ctx.historyPtr += 1;
+                        ctx.historyVersion += 1;
+                    }
+                }
+                return;
+            }
+            // Ctrl+F opens the find overlay.
+            if (lower === "f") {
+                event.preventDefault();
+                ctx.findOpen = true;
+                return;
+            }
+        }
+        // Esc closes find when nothing else owns the key.
+        if (event.key === "Escape" && ctx.findOpen) {
+            event.preventDefault();
+            ctx.findOpen = false;
+            return;
+        }
+        // Delete / Backspace clears every editable cell in the selection
+        // range. No clipboard interaction - this is the "blank the cells I
+        // have selected" gesture, distinct from Ctrl/Cmd+X.
+        if ((event.key === "Delete" || event.key === "Backspace") &&
+            !event.ctrlKey && !event.metaKey && !event.altKey) {
+            if (ctx.clearSelectedCells()) {
+                event.preventDefault();
+                return;
+            }
+        }
+        const current = ctx.grid.getState().activeCell ?? {
+            rowIndex: 0,
+            colIndex: 0,
+            cellId: null,
+        };
+        if (event.key === "F2") {
+            event.preventDefault();
+            ctx.onCellDoubleClick(current.rowIndex, current.colIndex);
+            return;
+        }
+        const intent = getKeyboardIntent(event);
+        if (intent === "noop") {
+            // A printable character on the active cell starts editing seeded with it.
+            if (event.key.length === 1 &&
+                !event.ctrlKey &&
+                !event.metaKey &&
+                !event.altKey) {
+                if (ctx.startEditingWithChar(current.rowIndex, current.colIndex, event.key)) {
+                    event.preventDefault();
+                }
+            }
+            return;
+        }
+        event.preventDefault();
+        if (intent === "clearCells") {
+            // Excel `Delete` - clear contents of every cell in the selection
+            // (or the active cell if no range). Formatting is left alone, only
+            // the underlying value is wiped.
+            ctx.clearSelectedCellValues();
+            return;
+        }
+        if (intent === "activate") {
+            const row = ctx.allRows[current.rowIndex];
+            const column = ctx.allColumns[current.colIndex];
+            if (event.key === " ") {
+                row?.toggleSelected?.();
+                return;
+            }
+            if (event.ctrlKey && row?.getCanExpand?.()) {
+                row.toggleExpanded?.();
+                return;
+            }
+            if (column?.columnDef.editorType === "checkbox") {
+                ctx.toggleBooleanCell(current.rowIndex, current.colIndex);
+                return;
+            }
+            ctx.onCellDoubleClick(current.rowIndex, current.colIndex);
+            return;
+        }
+        // Excel-style page step: PageUp/PageDown jump by ~one visible
+        // page minus one row of overlap. Falls back to grid pagination's
+        // pageSize when pagination is on, or 10 as a final fallback.
+        function pageStep() {
+            const pageSize = ctx.grid.getState().pagination?.pageSize;
+            if (pageSize && pageSize > 0)
+                return pageSize;
+            const clientHeight = ctx.scrollContainer?.clientHeight ?? 0;
+            const headerHeight = ctx.headerHeight ?? 0;
+            const rowHeight = typeof ctx.props.rowHeight === 'function'
+                ? (ctx.props.rowHeight(current.rowIndex) ?? 30)
+                : (ctx.props.rowHeight ?? 30);
+            const usable = Math.max(0, clientHeight - headerHeight);
+            return Math.max(1, Math.floor(usable / Math.max(rowHeight, 1)) - 1);
+        }
+        const next = getNextActiveCell(current, intent, {
+            maxRow: Math.max(ctx.allRows.length - 1, 0),
+            maxCol: Math.max(ctx.allColumns.length - 1, 0),
+            pageSize: pageStep(),
+        });
+        ctx.setActiveCell(next.rowIndex, next.colIndex);
+        ctx.scrollActiveCellIntoView(next.rowIndex, next.colIndex);
+        // Shift extends the selection ONLY for arrow keys (Excel-style).
+        // Shift+Enter / Shift+Tab just change direction; they don't grow the
+        // range, otherwise hammering Shift+Tab to backspace through a row
+        // would paint a creeping rectangle behind the cursor.
+        const shouldExtend = event.shiftKey &&
+            (intent === "moveLeft" ||
+                intent === "moveRight" ||
+                intent === "moveUp" ||
+                intent === "moveDown");
+        if (shouldExtend)
+            ctx.extendSelection(next.rowIndex, next.colIndex);
+        else
+            ctx.setSelection(next.rowIndex, next.colIndex);
+    }
+    function onWindowKeydown(event) {
+        if (event.key === "Escape" && (ctx.columnMenuFor || ctx.operatorMenuFor)) {
+            ctx.closeMenus();
+        }
+    }
+    function onHeaderSortClick(event, columnId) {
+        const column = ctx.allColumns.find((entry) => entry.id === columnId);
+        if (!column?.getCanSort?.())
+            return;
+        const clauses = ctx.grid.getState().sorting ?? [];
+        const current = clauses.find((entry) => entry.id === columnId);
+        if (!event.shiftKey) {
+            // Single-sort: cycle this column's direction and clear all other
+            // sorts. Cycle order: none → asc → desc → none.
+            const nextClause = !current
+                ? [{ id: columnId, desc: false }]
+                : current.desc
+                    ? []
+                    : [{ id: columnId, desc: true }];
+            ctx.grid.store.setState((prev) => ({ ...prev, sorting: nextClause }));
+            return;
+        }
+        // Shift-click: append/toggle as part of a multi-sort.
+        const nextClause = !current
+            ? [...clauses, { id: columnId, desc: false }]
+            : current.desc
+                ? clauses.filter((entry) => entry.id !== columnId)
+                : clauses.map((entry) => entry.id === columnId ? { ...entry, desc: true } : entry);
+        ctx.grid.store.setState((prev) => ({ ...prev, sorting: nextClause }));
+    }
+    return {
+        onGridKeyDown,
+        onWindowKeydown,
+        onHeaderSortClick,
+    };
+}

package/dist/menus.d.ts

@@ -0,0 +1,40 @@
+import { type RowData, type TableFeatures } from "./index";
+import "./sv-grid-scrollbar";
+import type { FilterOperator } from "./SvGrid.types";
+export declare function createMenus<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(ctx: any): {
+    updateFilterRow: (columnId: string, value: string) => void;
+    updateFilterOperator: (columnId: string, operator: FilterOperator) => void;
+    updateFilterMenuValue: (columnId: string, value: string) => void;
+    updateFilterMenuValueTo: (columnId: string, valueTo: string) => void;
+    toggleCheckboxWithKeyboard: (event: KeyboardEvent, toggle: () => void) => void;
+    isColumnFiltered: (columnId: string) => boolean;
+    closeMenus: () => void;
+    openChooseColumns: (event: MouseEvent) => void;
+    openColumnMenu: (event: MouseEvent, columnId: string) => void;
+    openFilterMenu: (event: MouseEvent, columnId: string) => void;
+    openOperatorMenu: (event: MouseEvent, columnId: string) => void;
+    sortColumnFromMenu: (columnId: string, desc: boolean) => void;
+    clearColumnSort: (columnId: string) => void;
+    groupByColumnFromMenu: (columnId: string) => void;
+    clearGroupingFromMenu: (columnId: string) => void;
+    isFacetChecked: (columnId: string, value: string) => any;
+    toggleFacetValue: (columnId: string, value: string) => void;
+    isAllFacetsChecked: (columnId: string) => boolean;
+    toggleAllFacets: (columnId: string) => void;
+    clearColumnFilter: (columnId: string) => void;
+    changePage: (delta: number) => void;
+    goToPage: (pageIndex: number) => void;
+    setPageSize: (pageSize: number) => void;
+    openContextMenu: (event: MouseEvent, rowIndex: number, colIndex: number, columnId: string) => void;
+    closeContextMenu: () => void;
+    contextMenuItems: () => {
+        key: string;
+        label: string;
+        separator?: boolean;
+        disabled?: boolean;
+        run?: () => void;
+    }[];
+    saveComment: () => void;
+    removeComment: () => void;
+    closeCommentEditor: () => void;
+};

package/dist/menus.js

@@ -0,0 +1,390 @@
+import "./sv-grid-scrollbar";
+import { clampMenuX, cssEscape, } from "./SvGrid.helpers";
+export function createMenus(ctx) {
+    function updateFilterRow(columnId, value) {
+        ctx.filterRowValues = { ...ctx.filterRowValues, [columnId]: value };
+        const current = ctx.filterMenuValues[columnId] ?? {
+            operator: "contains",
+            value: "",
+        };
+        ctx.filterMenuValues = {
+            ...ctx.filterMenuValues,
+            [columnId]: { ...current, value },
+        };
+    }
+    function updateFilterOperator(columnId, operator) {
+        const current = ctx.filterMenuValues[columnId] ?? {
+            operator: "contains",
+            value: "",
+        };
+        ctx.filterMenuValues = {
+            ...ctx.filterMenuValues,
+            [columnId]: { ...current, operator },
+        };
+    }
+    function updateFilterMenuValue(columnId, value) {
+        const current = ctx.filterMenuValues[columnId] ?? {
+            operator: "contains",
+            value: "",
+        };
+        ctx.filterMenuValues = {
+            ...ctx.filterMenuValues,
+            [columnId]: { ...current, value },
+        };
+        ctx.filterRowValues = { ...ctx.filterRowValues, [columnId]: value };
+    }
+    /** Upper-bound input for the `between` operator. Only relevant when
+     *  the column's current operator is `between`; harmless to call
+     *  otherwise. */
+    function updateFilterMenuValueTo(columnId, valueTo) {
+        const current = ctx.filterMenuValues[columnId] ?? {
+            operator: "between",
+            value: "",
+        };
+        ctx.filterMenuValues = {
+            ...ctx.filterMenuValues,
+            [columnId]: { ...current, valueTo },
+        };
+    }
+    function toggleCheckboxWithKeyboard(event, toggle) {
+        if (event.key !== "Enter" && event.key !== " ")
+            return;
+        event.preventDefault();
+        toggle();
+    }
+    function isColumnFiltered(columnId) {
+        if (ctx.valueFilters[columnId])
+            return true;
+        const menuFilter = ctx.filterMenuValues[columnId];
+        return Boolean(menuFilter &&
+            (menuFilter.operator === "isBlank" || menuFilter.value.trim()));
+    }
+    function closeMenus() {
+        ctx.columnMenuFor = null;
+        ctx.filterMenuFor = null;
+        ctx.operatorMenuFor = null;
+        ctx.chooseColumnsPos = null;
+    }
+    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
+        // back to below the item if the popover would clip the viewport.
+        const trigger = event.currentTarget;
+        const menuEl = trigger.closest(".sv-grid-menu");
+        const anchor = (menuEl ?? trigger).getBoundingClientRect();
+        const panelWidth = 240;
+        const wantRight = anchor.right + 4;
+        const x = wantRight + panelWidth + 8 > window.innerWidth
+            ? clampMenuX(anchor.left - panelWidth - 4, panelWidth)
+            : clampMenuX(wantRight, panelWidth);
+        ctx.chooseColumnsPos = { x, y: anchor.top };
+    }
+    function openColumnMenu(event, columnId) {
+        event.stopPropagation();
+        const wasOpen = ctx.columnMenuFor === columnId;
+        closeMenus();
+        if (wasOpen)
+            return;
+        const rect = event.currentTarget.getBoundingClientRect();
+        ctx.columnMenuPos = {
+            x: clampMenuX(rect.right - 240, 240),
+            y: rect.bottom + 4,
+        };
+        ctx.columnMenuTab = "general";
+        ctx.columnMenuFor = columnId;
+    }
+    function openFilterMenu(event, columnId) {
+        event.stopPropagation();
+        const wasOpen = ctx.filterMenuFor === columnId;
+        closeMenus();
+        if (wasOpen)
+            return;
+        // If the consumer is running in row-mode (or any mode where the
+        // funnel popover wouldn't render), redirect the click to the
+        // inline filter input for this column. Without this the funnel
+        // would be a dead button - it visibly clicks but nothing happens
+        // because the menu is gated behind `showColumnFiltersEffective`.
+        if (!ctx.showColumnFiltersEffective && ctx.showFilterRowEffective) {
+            // Find the row-mode filter input and focus it. The input is
+            // tagged with `data-svgrid-filter-col` so we can target by id
+            // without depending on column position.
+            const input = ctx.scrollContainer?.querySelector(`[data-svgrid-filter-col="${cssEscape(columnId)}"]`);
+            if (input) {
+                input.focus();
+                input.select();
+                // Brief pulse so the user sees where focus landed.
+                input.classList.add("sv-grid-filter-value-pulse");
+                setTimeout(() => input.classList.remove("sv-grid-filter-value-pulse"), 700);
+            }
+            return;
+        }
+        const rect = event.currentTarget.getBoundingClientRect();
+        ctx.filterMenuPos = {
+            x: clampMenuX(rect.right - 260, 260),
+            y: rect.bottom + 4,
+        };
+        ctx.columnMenuSearch = "";
+        ctx.filterMenuFor = columnId;
+    }
+    function openOperatorMenu(event, columnId) {
+        event.stopPropagation();
+        const wasOpen = ctx.operatorMenuFor === columnId;
+        closeMenus();
+        if (wasOpen)
+            return;
+        const rect = event.currentTarget.getBoundingClientRect();
+        ctx.operatorMenuPos = { x: clampMenuX(rect.left, 184), y: rect.bottom + 4 };
+        ctx.operatorMenuFor = columnId;
+    }
+    function sortColumnFromMenu(columnId, desc) {
+        ctx.grid.store.setState((prev) => ({
+            ...prev,
+            sorting: [{ id: columnId, desc }],
+        }));
+        closeMenus();
+    }
+    function clearColumnSort(columnId) {
+        ctx.grid.store.setState((prev) => ({
+            ...prev,
+            sorting: (prev.sorting ?? []).filter((entry) => entry.id !== columnId),
+        }));
+        closeMenus();
+    }
+    function groupByColumnFromMenu(columnId) {
+        const current = ctx.grid.getState().grouping ?? [];
+        if (current.includes(columnId)) {
+            closeMenus();
+            return;
+        }
+        ctx.grid.setGrouping([...current, columnId]);
+        closeMenus();
+    }
+    function clearGroupingFromMenu(columnId) {
+        const current = ctx.grid.getState().grouping ?? [];
+        ctx.grid.setGrouping(current.filter((id) => id !== columnId));
+        closeMenus();
+    }
+    function isFacetChecked(columnId, value) {
+        const selected = ctx.valueFilters[columnId];
+        return selected ? selected.has(value) : true;
+    }
+    function toggleFacetValue(columnId, value) {
+        const allValues = ctx.columnMenuFacetValues;
+        const next = new Set(ctx.valueFilters[columnId] ?? allValues);
+        if (next.has(value))
+            next.delete(value);
+        else
+            next.add(value);
+        if (next.size === allValues.length) {
+            const copy = { ...ctx.valueFilters };
+            delete copy[columnId];
+            ctx.valueFilters = copy;
+        }
+        else {
+            ctx.valueFilters = { ...ctx.valueFilters, [columnId]: next };
+        }
+    }
+    function isAllFacetsChecked(columnId) {
+        const selected = ctx.valueFilters[columnId];
+        return !selected || selected.size >= ctx.columnMenuFacetValues.length;
+    }
+    function toggleAllFacets(columnId) {
+        if (isAllFacetsChecked(columnId)) {
+            ctx.valueFilters = { ...ctx.valueFilters, [columnId]: new Set() };
+        }
+        else {
+            const copy = { ...ctx.valueFilters };
+            delete copy[columnId];
+            ctx.valueFilters = copy;
+        }
+    }
+    function clearColumnFilter(columnId) {
+        if (ctx.valueFilters[columnId]) {
+            const next = { ...ctx.valueFilters };
+            delete next[columnId];
+            ctx.valueFilters = next;
+        }
+        if (ctx.filterMenuValues[columnId]) {
+            const next = { ...ctx.filterMenuValues };
+            delete next[columnId];
+            ctx.filterMenuValues = next;
+        }
+        if (ctx.filterRowValues[columnId]) {
+            const next = { ...ctx.filterRowValues };
+            delete next[columnId];
+            ctx.filterRowValues = next;
+        }
+    }
+    function changePage(delta) {
+        ctx.grid.setPagination((prev) => ({
+            ...prev,
+            pageIndex: Math.max((prev?.pageIndex ?? 0) + delta, 0),
+        }));
+    }
+    function goToPage(pageIndex) {
+        ctx.grid.setPagination((prev) => ({
+            ...prev,
+            pageIndex: Math.max(0, pageIndex),
+        }));
+    }
+    function setPageSize(pageSize) {
+        ctx.grid.setPagination((prev) => {
+            const oldSize = prev?.pageSize ?? 10;
+            const oldIndex = prev?.pageIndex ?? 0;
+            // Keep the first visible row in view when the page size changes.
+            const firstVisibleRow = oldIndex * oldSize;
+            return {
+                ...prev,
+                pageSize,
+                pageIndex: Math.max(0, Math.floor(firstVisibleRow / pageSize)),
+            };
+        });
+    }
+    function insertRowAt(t, offset) {
+        const data = ctx.internalData.slice();
+        const idx = t.row ? data.indexOf(t.row) : -1;
+        const at = idx < 0 ? data.length : idx + offset;
+        data.splice(at, 0, {});
+        ctx.internalData = data;
+    }
+    function removeRowAt(t) {
+        if (!t.row)
+            return;
+        ctx.internalData = ctx.internalData.filter((r) => r !== t.row);
+    }
+    function removeColAt(t) {
+        ctx.internalColumns = ctx.internalColumns.filter((d) => (d.id ?? d.field) !== t.columnId);
+    }
+    // Built-in items, keyed. `run` reads the live target passed at click time.
+    const builtins = {
+        copy: { label: "Copy", run: () => ctx.copySelectionToClipboard() },
+        cut: { label: "Cut", run: () => ctx.cutSelectionToClipboard() },
+        paste: { label: "Paste", run: () => void ctx.pasteFromClipboard() },
+        clear: { label: "Clear", run: () => ctx.clearSelectedCells() },
+        row_above: { label: "Insert row above", run: (t) => insertRowAt(t, 0) },
+        row_below: { label: "Insert row below", run: (t) => insertRowAt(t, 1) },
+        remove_row: { label: "Remove row", run: removeRowAt },
+        remove_col: { label: "Remove column", run: removeColAt },
+        comment: { label: "Edit comment", run: (t) => openCommentEditor(t) },
+    };
+    const DEFAULT_ITEMS = [
+        "copy", "cut", "paste", "clear", "separator",
+        "row_above", "row_below", "remove_row", "separator", "remove_col",
+    ];
+    function openContextMenu(event, rowIndex, colIndex, columnId) {
+        if (!ctx.props.contextMenu)
+            return;
+        event.preventDefault();
+        closeMenus();
+        ctx.contextMenuFor = null;
+        const rowModel = ctx.allRows[rowIndex];
+        const row = rowModel?.original ?? null;
+        const rowId = rowModel?.id ?? String(rowIndex);
+        ctx.contextMenuPos = {
+            x: clampMenuX(event.clientX, 220),
+            y: Math.max(8, Math.min(event.clientY, window.innerHeight - 16)),
+        };
+        ctx.contextMenuFor = { rowIndex, colIndex, columnId, rowId, row };
+    }
+    function closeContextMenu() {
+        ctx.contextMenuFor = null;
+    }
+    // ---- Editable comments ---------------------------------------------
+    function openCommentEditor(t) {
+        const cur = ctx.noteOverrides?.[t.rowId]?.[t.columnId] ??
+            ctx.props.notes?.[t.rowId]?.[t.columnId] ??
+            "";
+        ctx.commentDraft = cur;
+        ctx.commentEditFor = { rowId: t.rowId, columnId: t.columnId, x: ctx.contextMenuPos.x, y: ctx.contextMenuPos.y };
+        ctx.contextMenuFor = null;
+    }
+    function writeNote(rowId, columnId, note) {
+        const next = { ...ctx.noteOverrides };
+        next[rowId] = { ...(next[rowId] ?? {}), [columnId]: note };
+        ctx.noteOverrides = next;
+        ctx.props.onNoteChange?.({ rowId, columnId, note });
+    }
+    function saveComment() {
+        const e = ctx.commentEditFor;
+        if (!e)
+            return;
+        writeNote(e.rowId, e.columnId, ctx.commentDraft);
+        ctx.commentEditFor = null;
+    }
+    function removeComment() {
+        const e = ctx.commentEditFor;
+        if (!e)
+            return;
+        writeNote(e.rowId, e.columnId, "");
+        ctx.commentEditFor = null;
+    }
+    function closeCommentEditor() {
+        ctx.commentEditFor = null;
+    }
+    /** Resolve the configured items against the current target for rendering. */
+    function contextMenuItems() {
+        const target = ctx.contextMenuFor;
+        if (!target)
+            return [];
+        const cfg = ctx.props.contextMenu;
+        const entries = Array.isArray(cfg)
+            ? cfg
+            : [...DEFAULT_ITEMS, ...(ctx.props.editableComments ? ["separator", "comment"] : [])];
+        const out = [];
+        for (const entry of entries) {
+            if (entry === "separator") {
+                out.push({ key: "sep" + out.length, label: "", separator: true });
+                continue;
+            }
+            if (typeof entry === "string") {
+                const b = builtins[entry];
+                if (!b)
+                    continue;
+                out.push({ key: entry, label: b.label, run: () => b.run(target) });
+                continue;
+            }
+            if (entry.hidden?.(target))
+                continue;
+            out.push({
+                key: entry.key,
+                label: entry.label,
+                disabled: entry.disabled?.(target) ?? false,
+                run: () => entry.action(target),
+            });
+        }
+        // Drop leading/trailing/double separators.
+        return out.filter((it, i, a) => !it.separator || (i > 0 && i < a.length - 1 && !a[i - 1]?.separator));
+    }
+    return {
+        updateFilterRow,
+        updateFilterOperator,
+        updateFilterMenuValue,
+        updateFilterMenuValueTo,
+        toggleCheckboxWithKeyboard,
+        isColumnFiltered,
+        closeMenus,
+        openChooseColumns,
+        openColumnMenu,
+        openFilterMenu,
+        openOperatorMenu,
+        sortColumnFromMenu,
+        clearColumnSort,
+        groupByColumnFromMenu,
+        clearGroupingFromMenu,
+        isFacetChecked,
+        toggleFacetValue,
+        isAllFacetsChecked,
+        toggleAllFacets,
+        clearColumnFilter,
+        changePage,
+        goToPage,
+        setPageSize,
+        openContextMenu,
+        closeContextMenu,
+        contextMenuItems,
+        saveComment,
+        removeComment,
+        closeCommentEditor,
+    };
+}

package/dist/menus.test.d.ts

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