react-open-source-grid 1.4.9 → 1.5.1

package/dist/assets/components/DataGrid/gridApi.types.d.ts

@@ -0,0 +1,348 @@
+/**
+ * Grid API Types
+ * AG Grid-inspired API surface for programmatic grid control
+ */
+import type { Column, Row, FilterConfig, SortConfig, LayoutPreset } from './types';
+/**
+ * Column key - can be field name or column index
+ */
+export type ColKey = string | number;
+/**
+ * Row node representing a single row in the grid with metadata
+ */
+export interface RowNode<T = Row> {
+    /** Unique row ID */
+    id: string | number;
+    /** The actual row data */
+    data: T;
+    /** Row index in the current display order (after filter/sort) */
+    rowIndex: number;
+    /** Whether this row is currently selected */
+    selected: boolean;
+    /** For grouped rows */
+    group?: boolean;
+    /** For tree rows */
+    level?: number;
+    /** Parent node for tree/group */
+    parent?: RowNode<T> | null;
+    /** Child nodes for tree/group */
+    childrenAfterGroup?: RowNode<T>[];
+    /** Whether group/tree node is expanded */
+    expanded?: boolean;
+    /** Set selection state for this row */
+    setSelected(selected: boolean, clearOther?: boolean): void;
+    /** Set expanded state (for groups/tree) */
+    setExpanded?(expanded: boolean): void;
+}
+/**
+ * Row model providing access to grid data
+ */
+export interface RowModel {
+    /** Total number of rows (before filter) */
+    getRowCount(): number;
+    /** Get row node at specific index (after filter/sort) */
+    getRow(index: number): RowNode | null;
+    /** Iterate through all rows */
+    forEachNode(callback: (node: RowNode, index: number) => void): void;
+}
+/**
+ * Column state for persistence
+ */
+export interface ColumnState {
+    colId: string;
+    width?: number;
+    hide?: boolean;
+    pinned?: 'left' | 'right' | null;
+    sort?: 'asc' | 'desc' | null;
+    sortIndex?: number;
+}
+/**
+ * Parameters for refreshing cells
+ */
+export interface RefreshCellsParams {
+    /** Specific row nodes to refresh */
+    rowNodes?: RowNode[];
+    /** Specific columns to refresh */
+    columns?: ColKey[];
+    /** Force refresh even if data hasn't changed */
+    force?: boolean;
+}
+/**
+ * Parameters for redrawing rows
+ */
+export interface RedrawRowsParams {
+    /** Specific row nodes to redraw */
+    rowNodes?: RowNode[];
+}
+/**
+ * CSV export parameters
+ */
+export interface CsvExportParams {
+    /** Filename for the export (without extension) */
+    fileName?: string;
+    /** Column keys to include (default: all visible) */
+    columnKeys?: ColKey[];
+    /** Skip column headers */
+    skipHeader?: boolean;
+    /** Skip column group headers */
+    skipColumnGroupHeaders?: boolean;
+    /** Skip pinned top rows */
+    skipPinnedTop?: boolean;
+    /** Skip pinned bottom rows */
+    skipPinnedBottom?: boolean;
+    /** Only export selected rows */
+    onlySelected?: boolean;
+    /** Only export filtered rows */
+    onlyFiltered?: boolean;
+    /** Custom column separator (default: ',') */
+    columnSeparator?: string;
+    /** Suppress quotes around values */
+    suppressQuotes?: boolean;
+    /** Custom value processor */
+    processCellCallback?: (params: {
+        value: unknown;
+        column: Column;
+        node: RowNode;
+    }) => string;
+}
+/**
+ * Excel export parameters
+ */
+export interface ExcelExportParams extends CsvExportParams {
+    /** Sheet name */
+    sheetName?: string;
+    /** Author metadata */
+    author?: string;
+}
+/**
+ * Transaction for updating row data
+ */
+export interface RowDataTransaction<T = Row> {
+    /** Rows to add */
+    add?: T[];
+    /** Rows to update (matched by ID) */
+    update?: T[];
+    /** Rows to remove (matched by ID) */
+    remove?: T[];
+    /** Index to add rows at */
+    addIndex?: number;
+}
+/**
+ * Result of a transaction
+ */
+export interface RowNodeTransaction<T = Row> {
+    add: RowNode<T>[];
+    remove: RowNode<T>[];
+    update: RowNode<T>[];
+}
+/**
+ * Cell range for clipboard operations
+ */
+export interface CellRange {
+    startRow: RowNode;
+    endRow: RowNode;
+    columns: Column[];
+}
+/**
+ * Parameters for starting cell editing
+ */
+export interface StartEditingCellParams {
+    rowIndex: number;
+    colKey: ColKey;
+    /** Keyboard event that triggered editing */
+    key?: string;
+    /** Character to populate cell with */
+    charPress?: string;
+}
+/**
+ * Main Grid API Interface
+ * Provides programmatic access to grid functionality
+ */
+export interface GridApi {
+    /** Replace all row data */
+    setRowData(rows: Row[]): void;
+    /** Apply a transaction to add/remove/update rows */
+    applyTransaction(transaction: RowDataTransaction): RowNodeTransaction;
+    /** Apply transaction asynchronously (for better performance with large datasets) */
+    applyTransactionAsync(transaction: RowDataTransaction): Promise<RowNodeTransaction>;
+    /** Get the row model */
+    getModel(): RowModel;
+    /** Get number of displayed rows (after filter/sort) */
+    getDisplayedRowCount(): number;
+    /** Get row node at specific display index */
+    getDisplayedRowAtIndex(index: number): RowNode | null;
+    /** Iterate through all row nodes */
+    forEachNode(callback: (node: RowNode, index: number) => void): void;
+    /** Iterate through nodes after filter */
+    forEachNodeAfterFilter(callback: (node: RowNode, index: number) => void): void;
+    /** Iterate through nodes after filter and sort */
+    forEachNodeAfterFilterAndSort(callback: (node: RowNode, index: number) => void): void;
+    /** Get first displayed row index */
+    getFirstDisplayedRow(): number;
+    /** Get last displayed row index */
+    getLastDisplayedRow(): number;
+    /** Get current column definitions */
+    getColumnDefs(): Column[];
+    /** Replace column definitions */
+    setColumnDefs(colDefs: Column[]): void;
+    /** Get all columns */
+    getAllColumns(): Column[];
+    /** Get displayed columns in center (not pinned) */
+    getDisplayedCenterColumns(): Column[];
+    /** Get displayed left pinned columns */
+    getDisplayedLeftColumns(): Column[];
+    /** Get displayed right pinned columns */
+    getDisplayedRightColumns(): Column[];
+    /** Show or hide a column */
+    setColumnVisible(key: ColKey, visible: boolean): void;
+    /** Show or hide multiple columns */
+    setColumnsVisible(keys: ColKey[], visible: boolean): void;
+    /** Pin or unpin a column */
+    setColumnPinned(key: ColKey, pinned: 'left' | 'right' | null): void;
+    /** Auto-size specific columns to fit content */
+    autoSizeColumns(keys?: ColKey[]): void;
+    /** Auto-size all columns to fit content */
+    autoSizeAllColumns(): void;
+    /** Move column to new position */
+    moveColumn(key: ColKey, toIndex: number): void;
+    /** Move columns to new positions */
+    moveColumns(keys: ColKey[], toIndex: number): void;
+    /** Get current column state */
+    getColumnState(): ColumnState[];
+    /** Apply column state (restore from saved state) */
+    applyColumnState(state: ColumnState[]): void;
+    /** Reset column state to initial */
+    resetColumnState(): void;
+    /** Get column by key */
+    getColumn(key: ColKey): Column | null;
+    /** Check if any filter is currently active */
+    isAnyFilterPresent(): boolean;
+    /** Get current filter model */
+    getFilterModel(): FilterConfig;
+    /** Set filter model */
+    setFilterModel(model: FilterConfig): void;
+    /** Trigger filter changed event */
+    onFilterChanged(): void;
+    /** Destroy filter for specific column */
+    destroyFilter(colKey: ColKey): void;
+    /** Get filter instance for a column */
+    getFilterInstance(colKey: ColKey): unknown;
+    /** Clear all filters */
+    clearAllFilters(): void;
+    /** Get current sort model */
+    getSortModel(): SortConfig[];
+    /** Set sort model */
+    setSortModel(model: SortConfig[]): void;
+    /** Trigger sort changed event */
+    onSortChanged(): void;
+    /** Clear all sorting */
+    clearAllSorting(): void;
+    /** Get selected row nodes */
+    getSelectedNodes(): RowNode[];
+    /** Get selected row data */
+    getSelectedRows(): Row[];
+    /** Select all rows */
+    selectAll(): void;
+    /** Deselect all rows */
+    deselectAll(): void;
+    /** Select all filtered rows */
+    selectAllFiltered(): void;
+    /** Deselect all filtered rows */
+    deselectAllFiltered(): void;
+    /** Get number of selected rows */
+    getSelectedRowCount(): number;
+    /** Ensure row index is visible in viewport */
+    ensureIndexVisible(index: number, position?: 'top' | 'middle' | 'bottom'): void;
+    /** Ensure row node is visible in viewport */
+    ensureNodeVisible(node: RowNode, position?: 'top' | 'middle' | 'bottom'): void;
+    /** Set focused cell */
+    setFocusedCell(rowIndex: number, colKey: ColKey): void;
+    /** Clear focused cell */
+    clearFocusedCell(): void;
+    /** Get currently focused cell */
+    getFocusedCell(): {
+        rowIndex: number;
+        column: Column;
+    } | null;
+    /** Start editing a cell */
+    startEditingCell(params: StartEditingCellParams): void;
+    /** Stop editing (save or cancel) */
+    stopEditing(cancel?: boolean): void;
+    /** Get cells currently being edited */
+    getEditingCells(): Array<{
+        rowIndex: number;
+        column: Column;
+    }>;
+    /** Re-render specific cells */
+    refreshCells(params?: RefreshCellsParams): void;
+    /** Re-render column headers */
+    refreshHeader(): void;
+    /** Refresh tool panel */
+    refreshToolPanel(): void;
+    /** Redraw rows (full re-render) */
+    redrawRows(params?: RedrawRowsParams): void;
+    /** Resize columns to fit grid width */
+    sizeColumnsToFit(): void;
+    /** Force layout recalculation */
+    doLayout(): void;
+    /** Export data as CSV file */
+    exportDataAsCsv(params?: CsvExportParams): void;
+    /** Get data as CSV string */
+    getDataAsCsv(params?: CsvExportParams): string;
+    /** Export data as Excel file */
+    exportDataAsExcel(params?: ExcelExportParams): void;
+    /** Copy selected rows to clipboard */
+    copySelectedRowsToClipboard(): void;
+    /** Copy selected range to clipboard */
+    copySelectedRangeToClipboard(): void;
+    /** Show loading overlay */
+    showLoadingOverlay(): void;
+    /** Show no rows overlay */
+    showNoRowsOverlay(): void;
+    /** Hide all overlays */
+    hideOverlay(): void;
+    /** Get current page */
+    paginationGetCurrentPage(): number;
+    /** Go to specific page */
+    paginationGoToPage(page: number): void;
+    /** Go to next page */
+    paginationGoToNextPage(): void;
+    /** Go to previous page */
+    paginationGoToPreviousPage(): void;
+    /** Get total number of pages */
+    paginationGetTotalPages(): number;
+    /** Get page size */
+    paginationGetPageSize(): number;
+    /** Set page size */
+    paginationSetPageSize(size: number): void;
+    /** Set columns to group by */
+    setRowGroupColumns(colKeys: ColKey[]): void;
+    /** Add column to grouping */
+    addRowGroupColumn(colKey: ColKey): void;
+    /** Remove column from grouping */
+    removeRowGroupColumn(colKey: ColKey): void;
+    /** Get columns used for grouping */
+    getRowGroupColumns(): Column[];
+    /** Expand all groups/tree nodes */
+    expandAll(): void;
+    /** Collapse all groups/tree nodes */
+    collapseAll(): void;
+    /** Expand specific node */
+    onGroupExpandedOrCollapsed(node?: RowNode): void;
+    /** Save current layout with name */
+    saveLayout(name: string): Promise<void>;
+    /** Load layout by name */
+    loadLayout(name: string): Promise<void>;
+    /** Get current layout state */
+    getLayoutState(): LayoutPreset['layout'];
+    /** Apply layout state */
+    applyLayoutState(layout: LayoutPreset['layout']): void;
+    /** Destroy grid and clean up resources */
+    destroy(): void;
+    /** Check if grid has been destroyed */
+    isDestroyed(): boolean;
+    /** Add event listener */
+    addEventListener(eventType: string, listener: (event: unknown) => void): void;
+    /** Remove event listener */
+    removeEventListener(eventType: string, listener: (event: unknown) => void): void;
+}

package/dist/assets/components/DataGrid/gridReducer.d.ts

@@ -0,0 +1,4 @@
+import type { GridState, GridAction, Column } from './types';
+export type { GridState, GridAction };
+export declare const createInitialState: (columns: Column[], pageSize?: number) => GridState;
+export declare const gridReducer: (state: GridState, action: GridAction) => GridState;

package/dist/assets/components/DataGrid/groupingUtils.d.ts

@@ -0,0 +1,17 @@
+import type { Row, GroupedRow, AggregateFunction, ExpandedGroups } from './types';
+/**
+ * Compute aggregate value for a group of rows
+ */
+export declare const computeAggregate: (rows: Row[], field: string, func: AggregateFunction) => number;
+/**
+ * Group rows by specified fields recursively
+ */
+export declare const groupRows: (rows: Row[], groupByFields: string[], expandedGroups: ExpandedGroups, level?: number) => (Row | GroupedRow)[];
+/**
+ * Flatten grouped rows for rendering
+ */
+export declare const flattenGroupedRows: (groupedRows: (Row | GroupedRow)[]) => (Row | GroupedRow)[];
+/**
+ * Check if a row is a grouped row
+ */
+export declare const isGroupedRow: (row: Row | GroupedRow) => row is GroupedRow;

package/dist/assets/components/DataGrid/index.d.ts

@@ -0,0 +1,41 @@
+export { DataGrid } from './DataGrid';
+export { VirtualScroller } from './VirtualScroller';
+export type { GridApi, RowNode, RowModel, ColKey, ColumnState, RefreshCellsParams, RedrawRowsParams, CsvExportParams, ExcelExportParams, RowDataTransaction, RowNodeTransaction, CellRange, StartEditingCellParams, } from './gridApi.types';
+export { GridApiImpl } from './gridApi';
+export { ColumnChooser } from './ColumnChooser';
+export { ExportMenu } from './ExportMenu';
+export { ColumnFilters } from './ColumnFilters';
+export { AdvancedFilterBuilder } from './AdvancedFilterBuilder';
+export { FacetedSearch } from './FacetedSearch';
+export type { FacetConfig, FacetedSearchProps } from './FacetedSearch';
+export { FilteredSearchBar } from './FilteredSearchBar';
+export type { SearchToken, FilterOption, FilteredSearchBarProps } from './FilteredSearchBar';
+export { LayoutPresetsManager } from './LayoutPresetsManager';
+export { InfiniteScrollDataGrid, ThemedInfiniteScrollDataGrid } from './InfiniteScrollDataGrid';
+export { ServerSideDataSource, createMockServerDataSource } from './ServerSideDataSource';
+export { ThemeSelector } from './ThemeSelector';
+export { getTheme, getThemeNames, generateThemeCSS, quartzTheme, alpineTheme, materialTheme, darkTheme, themes } from './themes';
+export type { ThemeName, GridTheme } from './themes';
+export { DensityToggle } from './DensityToggle';
+export { useDensityMode } from './useDensityMode';
+export type { UseDensityModeOptions, UseDensityModeReturn } from './useDensityMode';
+export { getDensityConfig, getDensityModes, getDensityLabel, generateDensityCSS, saveDensityMode, loadDensityMode, densityConfigs } from './densityModes';
+export type { DensityMode, DensityConfig } from './densityModes';
+export type { Column, Row, DataGridProps, GroupedRow, AggregateFunction, AggregateConfig, FooterConfig, VirtualScrollConfig, FilterType, FilterValue, FilterCondition, AdvancedFilterValue, FilterConfig, LayoutPreset, StorageStrategy, StorageAdapter, ServerConfig, UserProfileConfig, PersistenceConfig, TreeNode, TreeConfig, ExpandedNodes, RowPinConfig, ContextMenuItem, ContextMenuConfig, ContextMenuEvent, TooltipConfig, TooltipContent, TooltipPlacement } from './types';
+export type { ServerSideDataSourceConfig, ServerSideRequest, ServerSideResponse } from './ServerSideDataSource';
+export type { InfiniteScrollDataGridProps } from './InfiniteScrollDataGrid';
+export { handleExport, exportToCSV, exportToXLSX, generateFilename } from './exportUtils';
+export type { ExportFormat, ExportScope, ExcelStyling, ExportOptions } from './exportUtils';
+export { LayoutPersistenceManager, LocalStorageAdapter, ServerAdapter, UserProfileAdapter, getStorageAdapter, generatePresetId, createPreset } from './layoutPersistence';
+export { buildTreeFromFlat, flattenTree, toggleNodeExpansion, expandAllNodes, collapseAllNodes, getDescendantIds, getNodePath, getTreeDepth, countTreeNodes, filterTree, isTreeNode } from './treeDataUtils';
+export { StatusChip, ProgressBar, IconCell, ImageCell, ButtonCell, BadgeCell, PriorityIndicator, Rating, CurrencyCell, } from './CellRenderers';
+export { GridApiDemo } from './GridApiDemo';
+export { MarketDataGrid } from './MarketDataGrid';
+export type { MarketDataGridProps } from './MarketDataGrid';
+export { MarketDataEngine, createMarketDataEngine } from './MarketDataEngine';
+export type { CellUpdate as MarketCellUpdate, FlashAnimation as MarketFlashAnimation, MarketDataRow, MarketDataEngineConfig, RowUpdate } from './MarketDataEngine';
+export { useMarketData } from './useMarketData';
+export type { WebSocketConfig, MarketDataSubscription, ConnectionState, UseMarketDataOptions, UseMarketDataReturn } from './useMarketData';
+export { WebSocketMockFeed, createMockFeed, createMockWebSocket } from './WebSocketMockFeed';
+export type { MockMarketData, MockFeedConfig, MockWebSocket } from './WebSocketMockFeed';
+export type { MarketDataConfig } from './types';

package/dist/assets/components/DataGrid/layoutPersistence.d.ts

@@ -0,0 +1,95 @@
+import type { LayoutPreset, StorageAdapter, ServerConfig, UserProfileConfig, PersistenceConfig } from './types';
+/**
+ * LocalStorage Adapter
+ * Stores layout presets in browser's localStorage
+ */
+export declare class LocalStorageAdapter implements StorageAdapter {
+    save(key: string, preset: LayoutPreset): Promise<void>;
+    load(key: string, presetId?: string): Promise<LayoutPreset | LayoutPreset[] | null>;
+    delete(key: string, presetId: string): Promise<void>;
+    list(key: string): Promise<LayoutPreset[]>;
+}
+/**
+ * Server Adapter
+ * Stores layout presets on a remote server via REST API
+ */
+export declare class ServerAdapter implements StorageAdapter {
+    private config;
+    constructor(config: ServerConfig);
+    save(key: string, preset: LayoutPreset): Promise<void>;
+    load(key: string, presetId?: string): Promise<LayoutPreset | LayoutPreset[] | null>;
+    delete(key: string, presetId: string): Promise<void>;
+    list(key: string): Promise<LayoutPreset[]>;
+}
+/**
+ * User Profile Adapter
+ * Stores layout presets associated with a specific user
+ * Uses localStorage with user-specific keys by default, but can use custom adapter
+ */
+export declare class UserProfileAdapter implements StorageAdapter {
+    private config;
+    private baseAdapter;
+    constructor(config: UserProfileConfig);
+    private getUserKey;
+    save(key: string, preset: LayoutPreset): Promise<void>;
+    load(key: string, presetId?: string): Promise<LayoutPreset | LayoutPreset[] | null>;
+    delete(key: string, presetId: string): Promise<void>;
+    list(key: string): Promise<LayoutPreset[]>;
+}
+/**
+ * Get storage adapter based on configuration
+ */
+export declare function getStorageAdapter(config: PersistenceConfig): StorageAdapter;
+/**
+ * Generate a unique ID for a preset
+ */
+export declare function generatePresetId(): string;
+/**
+ * Create a new layout preset from current grid state
+ */
+export declare function createPreset(name: string, layout: LayoutPreset['layout'], description?: string, id?: string): LayoutPreset;
+/**
+ * Layout Persistence Manager
+ * Main API for saving, loading, and managing layout presets
+ */
+export declare class LayoutPersistenceManager {
+    private adapter;
+    private storageKey;
+    constructor(config: PersistenceConfig);
+    /**
+     * Save a layout preset
+     */
+    savePreset(preset: LayoutPreset): Promise<void>;
+    /**
+     * Load a specific preset by ID
+     */
+    loadPreset(presetId: string): Promise<LayoutPreset | null>;
+    /**
+     * Load the most recently updated preset
+     */
+    loadLastPreset(): Promise<LayoutPreset | null>;
+    /**
+     * Delete a preset
+     */
+    deletePreset(presetId: string): Promise<void>;
+    /**
+     * List all presets
+     */
+    listPresets(): Promise<LayoutPreset[]>;
+    /**
+     * Check if a preset exists
+     */
+    hasPreset(presetId: string): Promise<boolean>;
+    /**
+     * Save current layout as auto-save (with special ID)
+     */
+    autoSave(layout: LayoutPreset['layout']): Promise<void>;
+    /**
+     * Load auto-saved layout
+     */
+    loadAutoSave(): Promise<LayoutPreset | null>;
+}
+/**
+ * Debounce helper for auto-save functionality
+ */
+export declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number): (...args: Parameters<T>) => void;

package/dist/assets/components/DataGrid/themes.d.ts

@@ -0,0 +1,113 @@
+/**
+ * DataGrid Theme System
+ * Provides multiple pre-built themes: Quartz, Alpine, Material, Dark
+ */
+export type ThemeName = 'quartz' | 'alpine' | 'material' | 'dark' | 'nord' | 'dracula' | 'solarized-light' | 'solarized-dark' | 'monokai' | 'one-dark';
+export interface GridTheme {
+    name: ThemeName;
+    displayName: string;
+    colors: {
+        background: string;
+        backgroundAlt: string;
+        headerBackground: string;
+        footerBackground: string;
+        border: string;
+        borderLight: string;
+        text: string;
+        textSecondary: string;
+        textInverse: string;
+        headerText: string;
+        hover: string;
+        active: string;
+        selected: string;
+        primary: string;
+        primaryHover: string;
+        primaryLight: string;
+        primaryDark: string;
+        primaryBackground: string;
+        textMuted: string;
+        borderHover: string;
+        success: string;
+        warning: string;
+        error: string;
+        info: string;
+    };
+    spacing: {
+        cellPadding: string;
+        headerPadding: string;
+        rowHeight: string;
+    };
+    typography: {
+        fontFamily: string;
+        fontSize: string;
+        fontSizeSmall: string;
+        fontWeight: string;
+        headerFontWeight: string;
+    };
+    borders: {
+        width: string;
+        radius: string;
+        style: string;
+    };
+    shadows: {
+        light: string;
+        medium: string;
+        heavy: string;
+    };
+}
+/**
+ * Quartz Theme - Modern white with clean aesthetics
+ */
+export declare const quartzTheme: GridTheme;
+/**
+ * Alpine Theme - Classic business with professional look
+ */
+export declare const alpineTheme: GridTheme;
+/**
+ * Material Theme - Material Design inspired
+ */
+export declare const materialTheme: GridTheme;
+/**
+ * Dark Theme - Dark mode for reduced eye strain
+ */
+export declare const darkTheme: GridTheme;
+/**
+ * Nord Theme - Cool, arctic-inspired colors
+ */
+export declare const nordTheme: GridTheme;
+/**
+ * Dracula Theme - Popular purple-tinted dark theme
+ */
+export declare const draculaTheme: GridTheme;
+/**
+ * Solarized Light Theme - Precision colors for readability
+ */
+export declare const solarizedLightTheme: GridTheme;
+/**
+ * Solarized Dark Theme - Dark variant of Solarized
+ */
+export declare const solarizedDarkTheme: GridTheme;
+/**
+ * Monokai Theme - Vibrant colors on dark background
+ */
+export declare const monokaiTheme: GridTheme;
+/**
+ * One Dark Theme - Atom's iconic dark theme
+ */
+export declare const oneDarkTheme: GridTheme;
+/**
+ * Theme registry - all available themes
+ */
+export declare const themes: Record<ThemeName, GridTheme>;
+/**
+ * Get theme by name
+ */
+export declare function getTheme(themeName: ThemeName): GridTheme;
+/**
+ * Get all available theme names
+ */
+export declare function getThemeNames(): ThemeName[];
+/**
+ * Generate CSS variables from theme
+ */
+export declare function generateThemeCSS(theme: GridTheme): Record<string, string>;