rowvia 0.1.0

package/dist/types/api.d.ts

@@ -0,0 +1,6 @@
+import type { Grid } from './grid';
+import type { ColumnApi, GridApi } from './types';
+export declare function createGridApi(grid: Grid): {
+    api: GridApi;
+    columnApi: ColumnApi;
+};

package/dist/types/components/detailDialog.d.ts

@@ -0,0 +1,13 @@
+export interface DetailDialogContent {
+    title: string;
+    fields: Array<{
+        label: string;
+        value: string;
+    }>;
+}
+/** Text-only detail dialog owned by its mount, with no global IDs or selectors. */
+export declare function createDetailDialog(container: HTMLElement): {
+    open(content: DetailDialogContent): void;
+    close: () => void;
+    destroy(): void;
+};

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

@@ -0,0 +1,116 @@
+import type { Column, GridOptions, RowDataTransaction, RowNode, RowNodeTransactionResult } from '../types';
+import { type RowNodeServices } from './rowNode';
+import { EventService } from './eventService';
+export interface RowModel {
+    getType(): string;
+    /** optional: notify the model that the visible row window changed */
+    onViewportChanged?(startRow: number, endRow: number): void;
+    /** optional: remote models re-fetch after sort/filter/group changes */
+    onSortOrFilterChanged?(): void;
+    /** optional: expand/collapse a group node */
+    setNodeExpanded?(node: RowNode, expanded: boolean): void;
+    /** optional: grid api handle (client-side model only) */
+    setGridApi?(api: any): void;
+    getRowCount(): number;
+    getRow(index: number): RowNode | undefined;
+    getRowNode(id: string): RowNode | undefined;
+    forEachNode(callback: (node: RowNode, index: number) => void): void;
+    forEachLeafNode(callback: (node: RowNode, index: number) => void): void;
+    isEmpty(): boolean;
+    getTopLevelRows(): RowNode[];
+    refreshModel(step?: string): void;
+    updateRowData(rowData: any[]): void;
+    applyTransaction(transaction: RowDataTransaction): RowNodeTransactionResult | null;
+    destroy(): void;
+    expandAll(): void;
+    collapseAll(): void;
+    getPinnedTopRowCount(): number;
+    getPinnedBottomRowCount(): number;
+    getRowIndexAtPixel?(pixel: number): number;
+}
+interface FilterModelEntry {
+    filterType: string;
+    type?: string;
+    filter?: any;
+    filterTo?: any;
+    dateFrom?: string;
+    dateTo?: string;
+    values?: any[];
+    operator?: 'AND' | 'OR';
+    condition1?: any;
+    condition2?: any;
+    filterModels?: any[];
+}
+export declare class ClientSideRowModel implements RowModel {
+    private options;
+    private eventService;
+    private columns;
+    private getFilterModel;
+    private getQuickFilter;
+    private isPaginationEnabled;
+    private getPageSize;
+    private getCurrentPage;
+    private rowHeightProvider;
+    private rowNodeServices;
+    private rowData;
+    private rootRowNodes;
+    /** the original (ungrouped) data rows — grouping always starts from these */
+    private dataRows;
+    private rowsToDisplay;
+    private rowNodeMap;
+    private expandedGroups;
+    private groupDefaultExpandedApplied;
+    private pinnedTopRows;
+    private pinnedBottomRows;
+    private displayStartIndex;
+    private totalRowCount;
+    constructor(params: {
+        options: GridOptions;
+        eventService: EventService;
+        columns: () => Column[];
+        getFilterModel: () => Record<string, FilterModelEntry>;
+        getQuickFilter: () => string;
+        isPaginationEnabled: () => boolean;
+        getPageSize: () => number;
+        getCurrentPage: () => number;
+        rowHeight: () => number;
+        rowNodeServices: RowNodeServices;
+    });
+    getType(): string;
+    isEmpty(): boolean;
+    getTopLevelRows(): RowNode[];
+    getRowCount(): number;
+    /** total rows before pagination slicing */
+    getTotalRowCount(): number;
+    getRow(index: number): RowNode | undefined;
+    getRowNode(id: string): RowNode | undefined;
+    forEachNode(callback: (node: RowNode, index: number) => void): void;
+    forEachLeafNode(callback: (node: RowNode, index: number) => void): void;
+    getPinnedTopRowCount(): number;
+    getPinnedBottomRowCount(): number;
+    getPinnedTopRow(index: number): RowNode | undefined;
+    getPinnedBottomRow(index: number): RowNode | undefined;
+    getRowIndexAtPixel(pixel: number): number;
+    updateRowData(rowData: any[]): void;
+    private rebuildRows;
+    private createRowNode;
+    private buildTreeData;
+    applyTransaction(transaction: RowDataTransaction): RowNodeTransactionResult | null;
+    refreshModel(step?: string): void;
+    private doFilter;
+    /** exposed so the advanced filter can evaluate per-condition models */
+    doesNodePassFilterModel(node: RowNode, column: Column, model: any): boolean;
+    private doesNodePassFilter;
+    private doSort;
+    private doGroup;
+    private buildDisplayRows;
+    private isGrandTotal;
+    private createFooterNode;
+    private createGrandTotalNode;
+    expandAll(): void;
+    collapseAll(): void;
+    setNodeExpanded(node: RowNode, expanded: boolean): void;
+    setGridApi(api: any): void;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,95 @@
+import type { ColDef, Column, ColumnState, PinPosition, GridOptions } from '../types';
+import { EventService } from './eventService';
+export interface ColumnGroupInfo {
+    id: string;
+    headerName: string;
+    openByDefault: boolean;
+    parentId: string | null;
+    depth: number;
+    childColumnIds: string[];
+}
+export declare class ColumnModel {
+    private options;
+    private eventService;
+    private gridApi;
+    private measureCtx;
+    private gridColumnDefs;
+    private columns;
+    private displayOrder;
+    private autoGroupColumnDef;
+    pivotMode: boolean;
+    private columnGroups;
+    private openGroups;
+    private groupsInitialised;
+    constructor(options: GridOptions, eventService: EventService, gridApi: any);
+    setGridApi(api: any): void;
+    getAutoGroupColumnDef(): ColDef;
+    getOptions(): GridOptions;
+    setPivotMode(pivotMode: boolean, source?: string): void;
+    isPivotMode(): boolean;
+    setColumnDefs(colDefs: ColDef[]): void;
+    /** derive columnDefs from the fields of the first row (ag-grid autoGenerateColumnDefs) */
+    static generateColumnDefs(rowData: any[], fieldCase?: (field: string) => string): ColDef[];
+    /** column groups (spanning headers) */
+    getColumnGroups(): ColumnGroupInfo[];
+    getGroupDepth(): number;
+    isGroupOpen(groupId: string): boolean;
+    setGroupOpen(groupId: string, open: boolean): void;
+    getColumnDefs(): ColDef[];
+    private buildColumns;
+    private createColumn;
+    private pushColumnInto;
+    private buildColumn;
+    /**
+     * Generates the value columns produced by pivoting: one column per distinct
+     * value of each pivot column, grouped under the pivot column's header, plus a
+     * grand-total column per pivot column.
+     */
+    updatePivotColumns(rowData: any[]): void;
+    /** aggregate the leaves of a node for a pivot column/value pair */
+    private evaluatePivotValue;
+    /** creates/updates/removes the auto group column shown when grouping or using tree data */
+    private updateAutoGroupColumn;
+    private updateVisible;
+    private isGroupChainOpen;
+    refreshAll(): void;
+    getAllColumns(): Column[];
+    getColumn(key: string | Column): Column | undefined;
+    /** columns in display order (respects reordering), all sections */
+    getColumns(): Column[];
+    getDisplayedColumns(): Column[];
+    getDisplayedLeftColumns(): Column[];
+    getDisplayedCenterColumns(): Column[];
+    getDisplayedRightColumns(): Column[];
+    getDisplayedColumnsByType(): {
+        left: Column[];
+        center: Column[];
+        right: Column[];
+    };
+    getRowGroupColumns(): Column[];
+    getPivotColumns(): Column[];
+    getValueColumns(): Column[];
+    isRowGroupActive(): boolean;
+    setRowGroupColumns(colIds: Array<string | Column>, source?: string): void;
+    addRowGroupColumn(colKey: string | Column, source?: string): void;
+    removeRowGroupColumn(colKey: string | Column, source?: string): void;
+    setValueColumns(colIds: Array<string | Column>, source?: string): void;
+    addValueColumn(colKey: string | Column, aggFunc?: string, source?: string): void;
+    setPivotColumns(colIds: Array<string | Column>, source?: string): void;
+    setColumnVisible(colKey: string | Column, visible: boolean, source?: string): void;
+    setColumnsVisible(keys: Array<string | Column>, visible: boolean, source?: string): void;
+    setColumnPinned(colKey: string | Column, pinned: PinPosition, source?: string): void;
+    setColumnsPinned(keys: Array<string | Column>, pinned: PinPosition, source?: string): void;
+    moveColumn(key: string | Column, toIndex: number, source?: string): void;
+    moveColumnByIndex(fromIndex: number, toIndex: number, source?: string): void;
+    getColumnState(): ColumnState[];
+    applyColumnState(state: ColumnState[], applyOrder?: boolean): void;
+    resetColumnState(): void;
+    private getMeasureContext;
+    measureTextWidth(text: string): number;
+    /** assign widths: flex columns share the leftover space of their section */
+    sizeColumnsToFit(containerWidth: number, skipColumnIds?: string[]): void;
+    autoSizeColumn(colKey: string | Column, skipHeader?: boolean): void;
+    autoSizeAllColumns(skipHeader?: boolean): void;
+}
+export declare function titleCase(field: string): string;

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

@@ -0,0 +1,11 @@
+import type { GridEventType } from '../types';
+type Listener = (event: any) => void;
+/** Minimal pub/sub used across the grid. */
+export declare class EventService {
+    private listeners;
+    addEventListener(eventType: GridEventType | string, listener: Listener): void;
+    removeEventListener(eventType: GridEventType | string, listener: Listener): void;
+    dispatchEvent(eventType: GridEventType | string, event?: any): void;
+    hasListener(eventType: GridEventType | string): boolean;
+}
+export {};

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

@@ -0,0 +1,42 @@
+/**
+ * Formula engine — tokenizer, Pratt parser and evaluator for cell formulas.
+ * Supports field references (resolved from row data), A1-style references
+ * (resolved via a supplied header map), operators and a function library.
+ */
+export type FormulaValue = number | string | boolean | null | undefined | Date;
+export interface FormulaContext {
+    /** row data keyed by field name */
+    data?: Record<string, any>;
+    /** A1-style lookup: (columnLetter, rowNumber) => value */
+    a1Lookup?: (col: string, row: number) => FormulaValue;
+    /** the current row number for relative references */
+    rowNumber?: number;
+}
+export declare class FormulaError extends Error {
+    code: string;
+    constructor(code: string);
+}
+type TokenType = 'number' | 'string' | 'ident' | 'cell' | 'op' | 'lparen' | 'rparen' | 'comma';
+interface Token {
+    type: TokenType;
+    value: string;
+}
+export declare function tokenize(input: string): Token[];
+interface AstNode {
+    type: 'number' | 'string' | 'ref' | 'cell' | 'call' | 'unary' | 'binary' | 'range';
+    value?: any;
+    name?: string;
+    args?: AstNode[];
+    operator?: string;
+    left?: AstNode;
+    right?: AstNode;
+}
+export declare function parse(tokens: Token[]): AstNode;
+export declare const FORMULA_FUNCTIONS: string[];
+/** register a custom formula function (ag-grid formula custom functions) */
+export declare function registerFormulaFunction(name: string, fn: (args: FormulaValue[], context: FormulaContext) => FormulaValue): void;
+/** evaluate a formula string (with or without the leading '=') */
+export declare function evaluateFormula(formula: string, context?: FormulaContext): FormulaValue;
+/** true when a value/getter string is a formula */
+export declare function isFormula(value: any): value is string;
+export {};

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

@@ -0,0 +1,15 @@
+/**
+ * UI text for menus, popups and tool panels. Mirrors ag-grid's `localeText`
+ * option: the grid merges user-supplied keys over these English defaults and
+ * every built-in string resolves through `t(key)` / `translate(key, fallback)`.
+ */
+export declare const DEFAULT_LOCALE_TEXT: Record<string, string>;
+/** filter condition value → locale key (same names as ag-grid) */
+export declare const CONDITION_LABELS: Record<string, string>;
+/** resolves UI text: user overrides first, then the English defaults, then the key itself */
+export declare class LocaleText {
+    private overrides;
+    constructor(overrides: Record<string, string>);
+    t(key: string): string;
+}
+export declare function createLocaleText(overrides?: Record<string, string>): LocaleText;

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

@@ -0,0 +1,170 @@
+import type { Column, GridOptions, RowDataTransaction, RowNode, RowNodeTransactionResult, SortModelItem } from '../types';
+import { type RowNodeServices } from './rowNode';
+import type { EventService } from './eventService';
+import type { RowModel } from './clientSideRowModel';
+/** ag-grid compatible server-side request */
+export interface ServerSideGetRowsRequest {
+    startRow: number;
+    endRow: number;
+    rowGroupCols: Column[];
+    valueCols: Column[];
+    pivotCols: Column[];
+    groupKeys: string[];
+    sortModel: SortModelItem[];
+    filterModel: Record<string, any>;
+    successCallback: (rowsThisBlock: any[], lastRow?: number) => void;
+    failCallback: () => void;
+}
+export interface ServerSideDatasource {
+    getRows: (request: ServerSideGetRowsRequest) => void;
+    destroy?: () => void;
+}
+/** ag-grid marks server-side group rows with `childCount` / `group` on the data */
+export declare function isServerSideGroupRow(data: any): boolean;
+interface Store {
+    rows: (RowNode | null)[];
+    lastRow: number | null;
+    loading: boolean;
+    failed: boolean;
+}
+export interface RemoteRowModelParams {
+    options: GridOptions;
+    eventService: EventService;
+    columns: () => Column[];
+    getSortModel: () => SortModelItem[];
+    getFilterModel: () => Record<string, any>;
+    rowHeight: () => number;
+    rowNodeServices: RowNodeServices;
+}
+/**
+ * Server-Side Row Model — block loading with server-side sorting, filtering and
+ * grouping. Stores rows per group path and lazily requests blocks.
+ */
+export declare class ServerSideRowModel implements RowModel {
+    private options;
+    private eventService;
+    private columns;
+    private getSortModel;
+    private getFilterModel;
+    private rowHeightProvider;
+    private rowNodeServices;
+    private datasource;
+    private stores;
+    private rowNodeMap;
+    private displayRows;
+    private blockSize;
+    private pureLoad;
+    constructor(params: RemoteRowModelParams);
+    getType(): string;
+    setDatasource(datasource: ServerSideDatasource | null): void;
+    getStore(groupPath: string): Store | undefined;
+    private getOrCreateStore;
+    isLoading(): boolean;
+    /** request a block of rows for a group path (creates placeholders while loading) */
+    private loadBlock;
+    private onBlockLoaded;
+    private createNode;
+    private buildDisplayRows;
+    /** ensure the block covering [startRow, endRow] of the visible window is loaded */
+    private ensureLoaded;
+    refreshModel(step?: string): void;
+    /** called by the grid when the visible range changes */
+    onViewportChanged(startRow: number, endRow: number): void;
+    setNodeExpanded(node: RowNode, expanded: boolean): void;
+    private groupPathFor;
+    purgeCache(): void;
+    /** refresh after sort/filter/group changes — everything is re-fetched */
+    onSortOrFilterChanged(): void;
+    getRowCount(): number;
+    /** total rows on the server (root store's lastRow) */
+    getTotalRowCount(): number;
+    getRow(index: number): RowNode | undefined;
+    getRowNode(id: string): RowNode | undefined;
+    forEachNode(callback: (node: RowNode, index: number) => void): void;
+    forEachLeafNode(callback: (node: RowNode, index: number) => void): void;
+    isEmpty(): boolean;
+    getTopLevelRows(): RowNode[];
+    updateRowData(rowData: any[]): void;
+    applyTransaction(transaction: RowDataTransaction): RowNodeTransactionResult | null;
+    destroy(): void;
+    expandAll(): void;
+    collapseAll(): void;
+    getPinnedTopRowCount(): number;
+    getPinnedBottomRowCount(): number;
+}
+/**
+ * Infinite Row Model — lazy-loads pages as the user scrolls.
+ */
+export declare class InfiniteRowModel implements RowModel {
+    private options;
+    private eventService;
+    private getSortModel;
+    private getFilterModel;
+    private rowNodeServices;
+    private datasource;
+    private nodes;
+    private rowNodeMap;
+    private blockSize;
+    private lastRow;
+    private loading;
+    constructor(params: RemoteRowModelParams);
+    getType(): string;
+    setDatasource(datasource: ServerSideDatasource | null): void;
+    private loadBlock;
+    onViewportChanged(startRow: number, endRow: number): void;
+    onSortOrFilterChanged(): void;
+    isLoading(): boolean;
+    getRowCount(): number;
+    getRow(index: number): RowNode | undefined;
+    getRowNode(id: string): RowNode | undefined;
+    forEachNode(callback: (node: RowNode, index: number) => void): void;
+    forEachLeafNode(callback: (node: RowNode, index: number) => void): void;
+    isEmpty(): boolean;
+    getTopLevelRows(): RowNode[];
+    updateRowData(): void;
+    applyTransaction(): RowNodeTransactionResult | null;
+    destroy(): void;
+    refreshModel(): void;
+    expandAll(): void;
+    collapseAll(): void;
+    getPinnedTopRowCount(): number;
+    getPinnedBottomRowCount(): number;
+}
+/**
+ * Viewport Row Model — renders only the rows inside the current viewport,
+ * requesting them from the datasource.
+ */
+export declare class ViewportRowModel implements RowModel {
+    private options;
+    private eventService;
+    private rowNodeServices;
+    private datasource;
+    private nodes;
+    private rowNodeMap;
+    private firstRow;
+    private lastRow;
+    private loading;
+    constructor(params: RemoteRowModelParams);
+    getType(): string;
+    setDatasource(datasource: ServerSideDatasource | null): void;
+    setViewportRange(firstRow: number, lastRow: number): void;
+    setViewportDatasource(datasource: ServerSideDatasource | null): void;
+    onViewportChanged(startRow: number, endRow: number): void;
+    isLoading(): boolean;
+    getRowCount(): number;
+    getRow(index: number): RowNode | undefined;
+    getRowNode(id: string): RowNode | undefined;
+    forEachNode(callback: (node: RowNode, index: number) => void): void;
+    forEachLeafNode(callback: (node: RowNode, index: number) => void): void;
+    isEmpty(): boolean;
+    getTopLevelRows(): RowNode[];
+    updateRowData(): void;
+    applyTransaction(): RowNodeTransactionResult | null;
+    destroy(): void;
+    refreshModel(): void;
+    expandAll(): void;
+    collapseAll(): void;
+    getPinnedTopRowCount(): number;
+    getPinnedBottomRowCount(): number;
+}
+export {};

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

@@ -0,0 +1,51 @@
+import type { RowNode, Column } from '../types';
+export interface RowNodeServices {
+    selectNode: (node: RowNode, clearSelection: boolean) => void;
+    deselectNode: (node: RowNode) => void;
+    isNodeSelected: (node: RowNode) => boolean;
+    getRowGroupColumnCount?: () => number;
+}
+export declare class RowNodeImpl implements RowNode {
+    id: string;
+    __id: string;
+    data: any;
+    parent: RowNode | null;
+    children: RowNode[] | null;
+    group: boolean;
+    key: string | null;
+    level: number;
+    uiLevel: number;
+    rowGroupIndex: number | undefined;
+    expanded: boolean;
+    selectable: boolean;
+    selected: boolean;
+    rowPinned: 'top' | 'bottom' | null;
+    detailNode: RowNode | null;
+    masterNode: RowNode | null;
+    footer: boolean;
+    groupData: Record<string, any> | null;
+    rowHeight: number | null;
+    allChildrenCount: number | null;
+    stub: boolean;
+    rowIndex: number | null;
+    __displayIndex: number | undefined;
+    private services;
+    private _id;
+    constructor(data: any, services: RowNodeServices, id?: string);
+    /** true when this is a group node (row grouping) */
+    get isGroup(): boolean;
+    /** true when this row has a detail child (master detail) */
+    get isMaster(): boolean;
+    setSelected(selected: boolean, clearSelection?: boolean, _source?: string): number;
+    isSelected(): boolean;
+    setData(data: any): void;
+    setDataValue(colKey: string | Column, newValue: any): void;
+    setExpanded(expanded: boolean): void;
+    setPinned(pinned: 'top' | 'bottom' | null): void;
+    /** whether node passes the current filter (set by row model) */
+    __passesFilter: boolean;
+    /** depth-first child count including all descendants */
+    __childCount: number;
+    /** whether children were already loaded for this group */
+    __childrenLoaded: boolean;
+}

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

@@ -0,0 +1,38 @@
+/** Internal utilities. */
+export declare const KEY_ENTER = 13;
+export declare const KEY_ESCAPE = 27;
+export declare const KEY_SPACE = 32;
+export declare const KEY_TAB = 9;
+export declare const KEY_BACKSPACE = 8;
+export declare const KEY_DELETE = 46;
+export declare const KEY_LEFT = 37;
+export declare const KEY_UP = 38;
+export declare const KEY_RIGHT = 39;
+export declare const KEY_DOWN = 40;
+export declare const KEY_PAGE_UP = 33;
+export declare const KEY_PAGE_DOWN = 34;
+export declare const KEY_HOME = 36;
+export declare const KEY_END = 35;
+export declare const KEY_A = 65;
+export declare const KEY_C = 67;
+export declare const KEY_V = 86;
+export declare const KEY_X = 88;
+export declare const KEY_F = 70;
+export declare const KEY_P = 80;
+export declare function escapeHtml(value: any): string;
+export declare function escapeString(value: any): string;
+export declare function nextId(prefix?: string): string;
+export declare function debounce(func: (...args: any[]) => void, wait: number): (...args: any[]) => void;
+export declare function throttle(func: (...args: any[]) => void, wait: number): (...args: any[]) => void;
+export declare function requestAnimationFrameThrottle(func: (...args: any[]) => void): (...args: any[]) => void;
+export declare function formatNumberCommas(value: number, decimals?: number): string;
+export declare function parseFloatingPoint(value: any): number | null;
+export declare function isNumeric(value: any): boolean;
+export declare function defaultComparator(valueA: any, valueB: any): number;
+export declare function fuzzyMatch(filterValue: string, cellValue: any): boolean;
+export declare function deepClone<T>(obj: T): T;
+export declare function isEventFromInput(el: EventTarget | null): boolean;
+/** linear interpolation easing used for smooth scrolling */
+export declare function easeInOutCubic(t: number): number;
+export declare function addEventListener(element: Element | Document | Window, type: string, listener: (event: any) => void, options?: AddEventListenerOptions): () => void;
+export declare function setElementSize(element: HTMLElement, width?: string, height?: string): void;

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

@@ -0,0 +1,14 @@
+import type { AggFunc, Column, RowNode, GridApi } from '../types';
+export declare function getValueForColumn(column: Column, node: RowNode, api: GridApi): any;
+export declare function formatValue(column: Column, node: RowNode, api: GridApi): string | null;
+export declare function applyBuiltInFormatter(name: string, value: any, params?: {
+    column?: Column;
+}): string | null;
+export declare function formatDate(value: any): string;
+export declare function formatByType(column: Column, value: any): string | null;
+export declare function parseValue(column: Column, value: any): any;
+export declare function applyBuiltInParser(type: string | undefined, value: any): any;
+export declare function getComparator(column: Column): (a: RowNode, b: RowNode) => number;
+/** compare group keys; groups always sort before leaf rows when using default order */
+export declare function compareGroupValues(column: Column, a: RowNode, b: RowNode): number;
+export declare function applyAggregate(column: Column, aggFunc: AggFunc | undefined, values: any[]): any;

package/dist/types/features/chartService.d.ts

@@ -0,0 +1,49 @@
+import type { Column } from '../types';
+import type { Grid } from '../grid';
+import type { PopupService } from './popupService';
+export type ChartType = 'line' | 'area' | 'column' | 'bar' | 'pie' | 'scatter';
+interface ChartSeries {
+    title: string;
+    data: number[];
+}
+export interface ChartData {
+    categories: string[];
+    series: ChartSeries[];
+}
+export declare class ChartService {
+    private grid;
+    private popupService;
+    private charts;
+    private chartCounter;
+    private currentType;
+    private timeSeries;
+    constructor(grid: Grid, popupService: PopupService);
+    isEnabled(): boolean;
+    /** extract chart data from the grid (grouped or flat) */
+    getChartData(params?: {
+        categoryColumn?: Column;
+        valueColumns?: Column[];
+    }): ChartData;
+    buildChartPanel(): HTMLElement;
+    createChart(params?: {
+        type?: ChartType;
+        categoryColumn?: Column;
+        valueColumns?: Column[];
+        title?: string;
+    }): string;
+    destroyChart(id: string): void;
+    getChartModels(): any[];
+    refreshCharts(): void;
+    /** show a tooltip for the data point under the pointer */
+    private onChartHover;
+    /** persist created charts to localStorage so they survive reloads */
+    private storageKey;
+    saveCharts(): void;
+    loadCharts(): void;
+    private restoreChart;
+    private renderChart;
+    private renderPie;
+    private formatTick;
+    private truncate;
+}
+export {};

package/dist/types/features/columnMenu.d.ts

@@ -0,0 +1,9 @@
+import type { Column } from '../types';
+import type { Grid } from '../grid';
+import type { PopupService } from './popupService';
+export declare class ColumnMenuService {
+    private grid;
+    private popupService;
+    constructor(grid: Grid, popupService: PopupService);
+    openColumnMenu(column: Column, anchor: HTMLElement): void;
+}

package/dist/types/features/contextMenu.d.ts

@@ -0,0 +1,27 @@
+import type { Grid } from '../grid';
+import type { PopupService } from './popupService';
+export interface MenuItem {
+    name: string;
+    label?: string;
+    icon?: string;
+    disabled?: boolean;
+    checked?: boolean;
+    subMenu?: MenuItem[];
+    action?: () => void;
+    separator?: boolean;
+    cssClasses?: string[];
+    shortcut?: string;
+}
+export declare class ContextMenuService {
+    private grid;
+    private popupService;
+    constructor(grid: Grid, popupService: PopupService);
+    private getDefaultItems;
+    private hasSelection;
+    private isGroupActive;
+    openContextMenu(anchor: HTMLElement, params: {
+        column?: any;
+        node?: any;
+    }): void;
+    private buildMenu;
+}