@everygrid/grid 0.4.7

package/dist/src/core/GridHandle.d.ts

@@ -0,0 +1,214 @@
+import { Everygrid } from './Everygrid';
+/**
+ * Identifies a row to the outside world: the `rowKey` field's value, else the row's data index.
+ * Where a key can be missing — an inserted row whose key field is still empty — it is null.
+ */
+export type RowKey = string | number;
+/** One cell's change, original → current. */
+export interface CellChange {
+    field: string;
+    from: unknown;
+    to: unknown;
+}
+export type RowStatus = 'inserted' | 'updated' | 'deleted';
+/**
+ * One row's change. `modified`: the row as it is now and as it was loaded, with the cells that
+ * differ. `inserted`: `row` is the new row (`original` is the same object, `cells` empty).
+ * `deleted`: `original` is the row as loaded (`cells` empty).
+ */
+export interface RowChange<T = Record<string, unknown>> {
+    status: RowStatus;
+    index: number;
+    /** Null for an inserted row whose key field is still empty. */
+    key: RowKey | null;
+    row: T;
+    original: T;
+    cells: CellChange[];
+}
+/** A change seen from a column: which row, and the value before and after. */
+export interface ColumnChange<T = Record<string, unknown>> extends CellChange {
+    index: number;
+    key: RowKey | null;
+    row: T;
+}
+/** One modified row in a patch: its key and only the fields that changed. */
+export interface RowPatch {
+    key: RowKey;
+    changes: Record<string, unknown>;
+}
+/** One deleted row in a patch: its key, and the row as it was loaded. */
+export interface RowDeletion<T = Record<string, unknown>> {
+    key: RowKey;
+    row: T;
+}
+/** The minimal payload for a save: new rows whole, updated rows as key + changed fields, deleted rows as key + row. */
+export interface Patch<T = Record<string, unknown>> {
+    inserted: T[];
+    updated: RowPatch[];
+    deleted: RowDeletion<T>[];
+}
+export type CellChangeEvent<T = Record<string, unknown>> = ColumnChange<T>;
+/** A checkbox-column change: everything checked now, plus what this change toggled. */
+export interface CheckEvent<T = Record<string, unknown>> {
+    /** The `checkbox.mapping` values of every checked row. */
+    values: unknown[];
+    /** The checked rows themselves, in data order. */
+    rows: T[];
+    /** The mapping values this change toggled. */
+    changed: unknown[];
+    /** Whether `changed` was checked (true) or unchecked (false). */
+    checked: boolean;
+}
+export interface GridEvents<T = Record<string, unknown>> {
+    /** One cell was edited (through the grid's UI or `set`). */
+    cellChange: (e: CellChangeEvent<T>) => void;
+    /** The set of changes moved: an edit, a cancel, or a commit. */
+    change: (changes: RowChange<T>[]) => void;
+    /** Rows were checked or unchecked, from the UI or the API. */
+    check: (e: CheckEvent<T>) => void;
+}
+/**
+ * Coordinates into one grid's data — grid → row → cell — with the same verbs at every level:
+ * `get`, `set`, `original`, `changes`, `cancel`. Handles are stateless views over
+ * the grid, so they are cheap to make and never go stale; a handle to a row that does not exist
+ * reports `exists() === false` and its writes are no-ops, so a chain never has to null-check.
+ *
+ * Row indices are positions in the loaded data, so they hold still under sort and filter. For
+ * "the n-th row on screen" use `visibleRow`.
+ */
+export declare class GridHandle<T extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly grid;
+    readonly id: string;
+    constructor(grid: Everygrid<T>, id: string);
+    exists(): boolean;
+    /** The loaded rows, in data order. Live objects — read, do not mutate; use `set`. */
+    data(): T[];
+    row(index: number): RowHandle<T>;
+    /** Every loaded row as a handle, in data order — a plain array: index it, filter it, map it. */
+    rows(): RowHandle<T>[];
+    /** A row of the insert grid, by its position there. */
+    insertedRow(index: number): RowHandle<T>;
+    rowByKey(key: RowKey): RowHandle<T>;
+    find(predicate: (row: T, index: number) => boolean): RowHandle<T>;
+    /** The n-th row as currently shown (after filter and sort), by its position on screen. */
+    visibleRow(position: number): RowHandle<T>;
+    cell(index: number, field: string): CellHandle<T>;
+    column(field: string): ColumnHandle<T>;
+    hasChanges(): boolean;
+    /** Every changed row — inserted, updated (with its changed cells) or deleted — in data order. */
+    changes(): RowChange<T>[];
+    insertedRows(): RowHandle<T>[];
+    updatedRows(): RowHandle<T>[];
+    deletedRows(): RowHandle<T>[];
+    /** Original vs current, summarised by kind. */
+    diff(): {
+        inserted: RowChange<T>[];
+        updated: RowChange<T>[];
+        deleted: RowChange<T>[];
+        cells: number;
+    };
+    /**
+     * What to send to a server: the inserted rows whole, the updated rows as key + changed fields,
+     * the deleted rows as key + the row as loaded.
+     */
+    patch(): Patch<T>;
+    /**
+     * Adds a row to the insert grid and returns its handle. The loaded data is untouched until
+     * commit, when the new rows join it at the end. Needs `rowActions.insertRow`.
+     */
+    insertRow(values?: Partial<T>): RowHandle<T>;
+    /** Cancels every change: edits undone, inserted rows dropped, deleted rows back. */
+    cancel(): void;
+    /**
+     * Accepts the current state as the new baseline — after a successful save, typically: deleted
+     * rows are removed for good, inserted rows become ordinary rows, edits are no longer marked.
+     */
+    commit(): void;
+    /** The checked rows, in data order — `g.checkedRows().forEach(r => r.delete())`. */
+    checkedRows(): RowHandle<T>[];
+    /** The `checkbox.mapping` values of the checked rows. */
+    checkedValues(): unknown[];
+    /** Checks rows by their mapping values. */
+    check(values: unknown[]): void;
+    uncheck(values: unknown[]): void;
+    checkAll(): void;
+    uncheckAll(): void;
+    /** Subscribe to grid events; returns the unsubscribe function. */
+    on<K extends keyof GridEvents<T>>(event: K, handler: GridEvents<T>[K]): () => void;
+}
+export declare class RowHandle<T extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly grid;
+    private readonly parent;
+    /** Position in the loaded data — or, for a row of the insert grid, in that grid. */
+    readonly index: number;
+    /** Which list `index` addresses: the loaded data, or the insert grid. */
+    readonly kind: 'data' | 'inserted';
+    /** The grid this row belongs to. */
+    readonly gridId: string;
+    constructor(grid: Everygrid<T>, parent: GridHandle<T>, index: number, kind?: 'data' | 'inserted');
+    private list;
+    exists(): boolean;
+    /** The row's key: its `rowKey` field, else its index; null while an inserted row's key is empty. */
+    key(): RowKey | null;
+    get(): T | undefined;
+    /** The row as it was loaded (the row itself when it has not been edited). */
+    original(): T | undefined;
+    /** Edited so that it differs from its original (and neither inserted nor deleted). */
+    updated(): boolean;
+    inserted(): boolean;
+    deleted(): boolean;
+    /** `inserted` / `updated` / `deleted`, or null for a row exactly as loaded. */
+    status(): RowStatus | null;
+    /** Changed in any way: inserted, updated or deleted. */
+    changed(): boolean;
+    checked(): boolean;
+    /** Checks (or, with false, unchecks) this row's checkbox. */
+    check(checked?: boolean): void;
+    /** Marks the row deleted (struck through until commit; cancel() brings it back). Needs `rowActions.deleteRow`. */
+    delete(): boolean;
+    changes(): CellChange[];
+    cell(field: string): CellHandle<T>;
+    /**
+     * Edits several cells at once. Fields the grid's `editableCols` does not allow are skipped (with
+     * a warning) unless `force` is set. Returns how many cells were written.
+     */
+    set(values: Partial<T>, opts?: {
+        force?: boolean;
+    }): number;
+    /** Cancels this row's change: an inserted row is dropped, a deleted one comes back, edits are undone. */
+    cancel(): void;
+}
+export declare class CellHandle<T extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly grid;
+    readonly row: RowHandle<T>;
+    readonly field: string;
+    constructor(grid: Everygrid<T>, row: RowHandle<T>, field: string);
+    exists(): boolean;
+    get(): unknown;
+    original(): unknown;
+    /** Differs from the loaded value. */
+    modified(): boolean;
+    /** Whether this cell can be edited: any cell of an inserted row, else what `editableCols` allows. */
+    isEditable(): boolean;
+    /**
+     * Edits the cell exactly as typing into it would: tracked, marked, synced to the engine. Honours
+     * `editableCols` like the UI does — a column not listed there is refused (false, with a warning)
+     * unless `force` is set, which is for code that knows better than the config.
+     */
+    set(value: unknown, opts?: {
+        force?: boolean;
+    }): boolean;
+    /** Puts the loaded value back. */
+    cancel(): void;
+}
+export declare class ColumnHandle<T extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly parent;
+    readonly field: string;
+    constructor(parent: GridHandle<T>, field: string);
+    /** Current values down the column, in data order. */
+    values(): unknown[];
+    /** Rows whose value in this column changed. */
+    changes(): ColumnChange<T>[];
+    /** Cancels every change in this column. */
+    cancel(): void;
+}

package/dist/src/core/GridHandle.test.d.ts

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

package/dist/src/core/ResizeUtils.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { IEverygrid } from './types';
+export declare const createResizeHandler: <T extends Record<string, unknown>>(grid: IEverygrid<T>, containerId: string, container: HTMLElement, requireTableContainer?: boolean) => (e: React.MouseEvent | React.TouchEvent, field: string) => void;

package/dist/src/core/highlightUtils.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+export declare const highlightText: (text: string, query: string, field?: string) => React.JSX.Element | string;
+export declare const makeElementGate: (rootData: unknown, query: string) => (el: unknown) => string;
+export declare const objectContainsFilter: (val: unknown, query: string, field?: string) => boolean;

package/dist/src/core/normalizeOptions.d.ts

@@ -0,0 +1,13 @@
+import { GridOptions } from './types';
+/**
+ * Folds the options a target carries into the root per-feature lists the runtime reads
+ * (`pagination: [{id, …}]` and friends), so the rest of the grid keeps one shape to look at.
+ * A target's own entry replaces a root entry with the same id. Targets keep only their identity,
+ * `data` and `links` afterwards.
+ */
+export declare function normalizeOptions<T>(options: GridOptions<T>): GridOptions<T>;
+/**
+ * The inverse for one grid: its target entry with every per-grid option folded back in — the
+ * shape a config file uses — plus the root-only options. What the toolbar's "config" button shows.
+ */
+export declare function targetConfigOf<T>(options: GridOptions<T>, id: string): Record<string, unknown>;

package/dist/src/core/normalizeOptions.test.d.ts

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

package/dist/src/core/types.d.ts

@@ -0,0 +1,361 @@
+import { default as React } from 'react';
+export interface KeyTree {
+    [key: string]: KeyTree;
+}
+/** Loading/indexing progress for a mounted target — returned by `Everygrid.getLoadProgress(id)`
+ *  so a host (tab bar, shell) can show a grid's progress even while that grid's view is hidden. */
+export interface GridLoadProgress {
+    /** True while the grid is still streaming/indexing its data. */
+    active: boolean;
+    /** Indexing percent 0–100, or -1 when indeterminate (streaming with an unknown total). */
+    percent: number;
+    /** Rows loaded/streamed so far. */
+    rowsLoaded: number;
+    /** Engine stage, when known. */
+    stage?: 'indexing' | 'ready';
+}
+/**
+ * One grid. Besides its identity (`id`, `title`) a target carries every per-grid option, so a
+ * grid is configured in one place instead of naming its id under each feature. Single-value
+ * options take a shorthand (`rowKey: "id"`, `checkbox: "id"`, `editableCols: [...]`).
+ *
+ * The older per-feature form (`pagination: [{id, …}]` at the root) is still accepted; the two are
+ * merged at construction with the target's own entry winning — see `normalizeOptions`.
+ */
+export interface GridTargetConfig {
+    id: string;
+    title?: string;
+    data?: Record<string, unknown>[];
+    /** Fields rendered as links. */
+    links?: string[];
+    /** Field (or fields) that identify a row to the outside world — see `GridRowKeyConfig`. */
+    rowKey?: string | string[];
+    rowActions?: Omit<GridRowActionsConfig, 'id'>;
+    toolbar?: Omit<GridToolbarConfig, 'id'>;
+    /** Fields the reader may edit. */
+    editableCols?: string[];
+    /** Checkbox column: the field whose values `checkedValues()` reports, or the full config. */
+    checkbox?: string | Omit<GridCheckboxConfig, 'id'>;
+    colors?: Omit<GridColorConfig, 'id'>;
+    /** Fields the narrow (mobile) layout shows by default. */
+    mobileColumns?: string[];
+    pagination?: Omit<GridPaginationConfig, 'id'>;
+    virtualScroll?: Omit<GridVirtualScrollConfig, 'id'>;
+    dataLimit?: Omit<GridDataLimitConfig, 'id'>;
+    /** Column labels for this grid only: `locale → field → label` (the root `columnI18n` also
+     *  holds `common` entries shared by every grid). */
+    columnI18n?: Record<string, Record<string, string>>;
+}
+/**
+ * Localized column display names: `locale → ('common' | gridId) → field → label`.
+ * A grid id's entry overrides `common`; any field with no entry falls back to the raw field key.
+ * Only display and the search-suggestion label use this — queries stay in real field keys, so WASM,
+ * the JS matcher, and highlight are untouched and locale can switch with no query rewriting.
+ */
+export type ColumnI18n = Record<string, Record<string, Record<string, string>>>;
+export interface GridColumn {
+    headerName: string;
+    field: string;
+    type?: string;
+    width?: number;
+    options?: string[];
+    mapping?: string;
+}
+export interface EditableColConfig {
+    id: string;
+    cols: string[];
+}
+/**
+ * Which field identifies a row to the outside world — what `GridHandle` reports as a row's `key`
+ * and what `patch()` sends. Several fields make a composite key, joined with `|`. Without an
+ * entry the key is the row's index in the loaded data.
+ */
+export interface GridRowKeyConfig {
+    id: string;
+    field: string | string[];
+}
+/**
+ * Row-level editing per grid. `insertRow` puts a "+ row" button in the toolbar that adds an empty
+ * row above the data rows — kept apart from the loaded data, so its rows and their indices stay
+ * put until commit moves the new rows in (at the end). `deleteRow` puts a delete button on every
+ * row; a deleted row stays on screen, struck through, until commit removes it or revert brings it
+ * back. An inserted row is simply dropped by revert. Both show up in `GridHandle.changes()` /
+ * `patch()`.
+ */
+export interface GridRowActionsConfig {
+    id: string;
+    insertRow?: boolean;
+    deleteRow?: boolean;
+}
+/**
+ * Default columns for the narrow (mobile) layout, where rows scroll horizontally and each carries a
+ * detail button opening the whole row. `cols` lists the field keys to show until the user picks
+ * their own (the mobile "Columns" action, same whitelist as desktop); with no entry every column
+ * shows. Fields that do not exist are skipped.
+ */
+export interface GridMobileColumnsConfig {
+    id: string;
+    cols: string[];
+}
+export interface GridColorConfig {
+    id: string;
+    font?: {
+        header?: string;
+        body?: string;
+    };
+    bg?: {
+        header?: string;
+        body?: string;
+    };
+}
+export interface ServerFetchParams {
+    page: number;
+    pageSize: number;
+    sortField?: string;
+    sortAsc?: boolean;
+    filterText?: string;
+}
+export interface ServerFetchResult<T = Record<string, unknown>> {
+    data: T[];
+    total: number;
+}
+export interface GridPaginationConfig {
+    id: string;
+    pageSize?: number;
+    active?: boolean;
+    position?: 'top' | 'bottom' | 'all';
+    serverSide?: boolean;
+    /**
+     * Where the "Showing 1–5 of 10" line goes.
+     * - `'strip'` (default) — the band between the toolbar and the table, so it shows even on a
+     *   grid with a single page or no pagination at all.
+     * - `'inline'` — inside the pagination bar, the layout used before that band existed.
+     */
+    rowCount?: 'strip' | 'inline';
+}
+/**
+ * Virtual scrolling: renders only the rows in view instead of a whole page.
+ * When active for a target, that target's pagination is ignored (the grid becomes one
+ * continuous scroll over the full filtered result).
+ *
+ * Requires a fixed row height — variable-height rows are not supported in this mode.
+ */
+/** Options for a reload the host asks for — see `Everygrid.reload` / `reloadData`. */
+export interface ReloadOptions {
+    /**
+     * The host asked for this reload, not the reader — leave the toolbar's reload button alone.
+     * The data still loads with the usual loading UI.
+     */
+    silent?: boolean;
+    /**
+     * The incoming rows replace the previous result rather than refreshing it, so the body drops to
+     * the loading state instead of showing rows that answer the old query.
+     */
+    discard?: boolean;
+}
+export interface GridVirtualScrollConfig {
+    id: string;
+    active?: boolean;
+    /** Row height in px. Every row is forced to exactly this. Default 36. */
+    rowHeight?: number;
+    /** Extra rows rendered above and below the viewport. Default 6. */
+    overscan?: number;
+    /** Rows fetched from the engine per request. Default 200. */
+    blockSize?: number;
+}
+/**
+ * Caps how many rows a target loads into the browser. Loading a whole large dataset — into JS and
+ * again into the WASM worker — can exceed a device's per-tab memory limit and crash the tab
+ * (typical on phones). With a cap the grid loads only the first N rows and shows a banner instead.
+ *
+ * For genuinely large data the right answer is server-side pagination (`pagination.serverSide` +
+ * `serverFetcher`); this is a safety net for when a full dataset reaches the client anyway.
+ */
+/**
+ * Toolbar (search box + action buttons) per grid; `active: false` hides it. On by default.
+ * `showConfig` adds a "config" button that opens the grid's effective configuration — every
+ * config entry that names this grid — in the popup viewer. Off by default.
+ */
+export interface GridToolbarConfig {
+    id: string;
+    active?: boolean;
+    showConfig?: boolean;
+}
+export interface GridDataLimitConfig {
+    id: string;
+    /**
+     * Hard cap on rows loaded. A number caps at exactly that; `'auto'` derives a device-appropriate
+     * cap from reported RAM and whether the device looks mobile. Omit (or `active: false`) for no cap.
+     */
+    maxRows?: number | 'auto';
+    active?: boolean;
+}
+export interface GridCheckboxConfig {
+    id: string;
+    mapping: string;
+    active?: boolean;
+}
+export interface GridLinkConfig {
+    id: string;
+    cols: string[];
+}
+export interface IEverygrid<T extends Record<string, unknown>> {
+    options: GridOptions<T>;
+    pinnedColumns: Set<string>;
+    activeEditFields: Map<string, Set<string>>;
+    sortConfig: Map<string, {
+        field: string;
+        direction: 'asc' | 'desc' | null;
+    }>;
+    hiddenFieldsMap: Map<string, Set<string>>;
+    exportState: Map<string, {
+        done: number;
+        total: number;
+    }>;
+    commaSeparatedFields: Set<string>;
+    linkFields: Set<string>;
+    isExcelViewMode: boolean;
+    activePopup: React.ReactElement | null;
+    activePopupData: {
+        data: unknown;
+    } | null;
+    /** Title for the active detail popup — the field the cell belongs to, or undefined for a fallback. */
+    activePopupTitle: string | null;
+    activePopupSubtitle: string | null;
+    activePopupSubtitleTitle: string | null;
+    activePopupRow: unknown | null;
+    activePopupRowKey: string | null;
+    wasmReady: boolean;
+    filterText: string;
+    checkedValues: Map<string, Set<unknown>>;
+    _streamRows: Map<string, Record<string, unknown>[]>;
+    _streamTotal: Map<string, number>;
+    _processing: Map<string, boolean>;
+    _wasmRawTotal: Map<string, number>;
+    _wasmPageCache: Map<string, {
+        rows: unknown[];
+        total: number;
+    }>;
+    _dataSource: Map<string, string | (() => Promise<Record<string, unknown>[]>)>;
+    _reloading: Map<string, 'button' | 'silent'>;
+    reloadData(containerId: string): Promise<void>;
+    _indexingAllRows: Map<string, Record<string, unknown>[]>;
+    _indexingStage: Map<string, 'indexing' | 'ready'>;
+    _indexingProgress: Map<string, number>;
+    _wasStreaming: Set<string>;
+    /** Targets with a data load in flight, on any load path. */
+    _loading: Set<string>;
+    renderGrid(container: HTMLElement, _updatePinned?: boolean): void;
+    resetCell(item: T, field: string, container: HTMLElement): void;
+    syncRowHeights(container: HTMLElement): void;
+    showPopup?(data: unknown, rowData?: unknown, title?: string): void;
+    closePopup(): void;
+    showTextPopup?(text: string, rowData?: unknown, title?: string): void;
+    showEditPopup(rowData: Record<string, unknown>, field: string, data: unknown): void;
+    updateData(rowData: Record<string, unknown>, field: string, value: unknown): void;
+    updateColumnWidth(containerId: string, field: string, width: number): void;
+    getCurrentWidths(containerId: string): Map<string, number>;
+    isCellModified(rowData: T, field: string): boolean;
+    isColumnNumeric(field: string): boolean;
+    isColumnDate(field: string): boolean;
+    isColumnObject(field: string): boolean;
+    getDisplayItems(containerId: string, items: T[]): T[];
+    getColumns(containerId: string, items: T[], isMobile?: boolean): GridColumn[];
+    columnLabel(field: string, containerId: string): string;
+    getMobileColumns(containerId: string): string[] | undefined;
+    isColumnBoolean(field: string): boolean;
+    getRowActions(containerId: string): {
+        insertRow: boolean;
+        deleteRow: boolean;
+    };
+    hasToolbar(containerId: string): boolean;
+    cancelAll(containerId: string): void;
+    cancelCell(containerId: string, rowData: Record<string, unknown>, field: string): void;
+    showsConfig(containerId: string): boolean;
+    getTargetConfig(containerId: string): Record<string, unknown>;
+    showConfig(container: HTMLElement): void;
+    getCheckboxMapping(containerId: string): string | undefined;
+    getCheckedValues(containerId: string): unknown[];
+    getCheckedRows(containerId: string): T[];
+    setChecked(containerId: string, values: unknown[], checked: boolean): void;
+    clearChecked(containerId: string): void;
+    insertRow(containerId: string, values?: Partial<T>, at?: number): T;
+    getInsertedRows(): T[];
+    deleteRow(containerId: string, rowData: T): void;
+    restoreRow(containerId: string, rowData: T): void;
+    isRowInserted(row: T): boolean;
+    isRowDeleted(row: T): boolean;
+    showMobileColumnSelector(allFields: string[], container: HTMLElement): void;
+    showDiff(container: HTMLElement): void;
+    showRowDetail(row: T, container: HTMLElement): void;
+    getDataFields(containerId: string): string[];
+    getSearchKeys(containerId: string, fallbackSample?: unknown[]): KeyTree;
+    exportExcel(containerId: string, scope?: 'filtered' | 'all'): Promise<void>;
+    cancelExport(containerId: string): void;
+    getEditableFields(containerId: string): string[];
+    getPagination(containerId: string): GridPaginationConfig | undefined;
+    /** Resolved virtual-scroll config, or undefined when the target scrolls by pages. */
+    getVirtualScroll(containerId: string): GridVirtualScrollConfig | undefined;
+    /** Resolved row cap for a target (`'auto'` turned into a number), or undefined for no cap. */
+    getDataLimit(containerId: string): number | undefined;
+    /** Set when a load was capped: how many rows are shown, and the true total if it is known. */
+    _dataLimited: Map<string, {
+        shown: number;
+        total: number | null;
+    }>;
+    /**
+     * Rows for the half-open range [start, end) of the current filtered result.
+     * Returns synchronously from the block cache; blocks that are missing come back as `undefined`
+     * holes and are fetched in the background, which re-renders the grid when they land.
+     */
+    getRowsInRange(containerId: string, start: number, end: number): (T | undefined)[];
+    toggleExcelViewMode(container: HTMLElement): void;
+    resetColumnWidths(container: HTMLElement): void;
+    showColumnSelector(allFields: string[], container: HTMLElement): void;
+    showHiddenColumnSelector(container: HTMLElement): void;
+    checkHasChanges(): boolean;
+    reset(container: HTMLElement): void;
+    resetSort(container: HTMLElement): void;
+    setFilter(text: string, container?: HTMLElement): void;
+    applyWasmState(containerId: string): void;
+    applyWasmFilter(containerId: string): Promise<void>;
+    invalidateSortCache(containerId?: string): void;
+    fetchServerPage(containerId: string): Promise<void>;
+    currentPage: Map<string, number>;
+    getCurrentPage(containerId: string): number;
+    getTotalPages(containerId: string): number;
+    getFilteredTotal(containerId: string): number;
+    setCurrentPage(containerId: string, page: number, container: HTMLElement): void;
+    getGridTitle(containerId: string): string | undefined;
+    subscribe(callback: () => void): () => void;
+    notify(): void;
+    destroy(): void;
+}
+export interface GridOptions<T = Record<string, unknown>> {
+    targets: (string | GridTargetConfig)[];
+    data?: T[];
+    dataUrl?: string;
+    columns?: GridColumn[];
+    columnI18n?: ColumnI18n;
+    mobileColumns?: GridMobileColumnsConfig[];
+    editableCols?: EditableColConfig[];
+    rowKey?: GridRowKeyConfig[];
+    rowActions?: GridRowActionsConfig[];
+    toolbar?: GridToolbarConfig[];
+    colors?: GridColorConfig[];
+    links?: GridLinkConfig[];
+    checkbox?: GridCheckboxConfig[];
+    pagination?: GridPaginationConfig | GridPaginationConfig[];
+    virtualScroll?: GridVirtualScrollConfig | GridVirtualScrollConfig[];
+    dataLimit?: GridDataLimitConfig | GridDataLimitConfig[];
+    serverFetcher?: (params: ServerFetchParams) => Promise<ServerFetchResult>;
+    /**
+     * `cache` mode for the fetch that loads a target's data from a URL.
+     * Defaults to 'no-store' (always hit the network). Set to 'default' to let the browser
+     * cache the response — worth it for large datasets that rarely change, since a reload
+     * then costs a revalidation instead of a full re-download.
+     */
+    dataCache?: RequestCache;
+    onDataChange?: (data: Record<string, unknown>[], originalData: Record<string, unknown>[]) => void;
+    onCellClick?: (rowData: Record<string, unknown>, field: string) => void;
+}