react-open-source-grid 1.5.0 → 1.5.1

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

@@ -0,0 +1,121 @@
+/**
+ * WebSocketMockFeed.ts
+ *
+ * Mock WebSocket server that simulates live market data feed.
+ * Generates realistic tick updates for testing market data mode.
+ *
+ * Features:
+ * - Simulates 1000+ ticks/sec
+ * - Random price movements
+ * - Bid/Ask spreads
+ * - Volume tracking
+ * - Burst updates
+ * - Configurable update frequency
+ */
+export interface MockMarketData {
+    symbol: string;
+    price: number;
+    bid: number;
+    ask: number;
+    size: number;
+    volume: number;
+    change: number;
+    changePercent: number;
+    high: number;
+    low: number;
+    open: number;
+    lastUpdate: number;
+}
+export interface MockFeedConfig {
+    symbols?: string[];
+    updateFrequency?: number;
+    priceVolatility?: number;
+    burstProbability?: number;
+    burstSize?: number;
+    port?: number;
+}
+/**
+ * Mock WebSocket Feed
+ * Simulates a WebSocket server for market data
+ */
+export declare class WebSocketMockFeed {
+    private config;
+    private marketData;
+    private updateIntervals;
+    private clients;
+    private isRunning;
+    constructor(config?: MockFeedConfig);
+    /**
+     * Generate default symbol list
+     */
+    private generateDefaultSymbols;
+    /**
+     * Initialize market data with random values
+     */
+    private initializeMarketData;
+    /**
+     * Generate random price
+     */
+    private randomPrice;
+    /**
+     * Update market data for a symbol
+     */
+    private updateSymbol;
+    /**
+     * Trigger burst of rapid updates
+     */
+    private triggerBurst;
+    /**
+     * Broadcast update to all connected clients
+     */
+    private broadcastUpdate;
+    /**
+     * Start generating updates
+     */
+    start(): void;
+    /**
+     * Stop generating updates
+     */
+    stop(): void;
+    /**
+     * Register a mock WebSocket client
+     */
+    connect(client: MockWebSocket): void;
+    /**
+     * Unregister a mock WebSocket client
+     */
+    disconnect(client: MockWebSocket): void;
+    /**
+     * Get current market data snapshot
+     */
+    getSnapshot(): MockMarketData[];
+    /**
+     * Get data for specific symbol
+     */
+    getSymbolData(symbol: string): MockMarketData | undefined;
+}
+/**
+ * Mock WebSocket client interface
+ */
+export interface MockWebSocket {
+    readyState: number;
+    send: (data: string) => void;
+    onmessage: ((event: {
+        data: string;
+    }) => void) | null;
+    onopen: (() => void) | null;
+    onclose: (() => void) | null;
+    onerror: ((error: any) => void) | null;
+    close: () => void;
+}
+/**
+ * Create a mock WebSocket that connects to the feed
+ */
+export declare function createMockWebSocket(feed: WebSocketMockFeed): MockWebSocket;
+/**
+ * Create and start a mock market data feed
+ */
+export declare function createMockFeed(config?: MockFeedConfig): {
+    feed: WebSocketMockFeed;
+    createConnection: () => MockWebSocket;
+};

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

@@ -0,0 +1,25 @@
+import type { Row, AggregateFunction, AggregateConfig, GroupedRow } from './types';
+/**
+ * Compute a single aggregate value for a set of rows
+ */
+export declare const computeAggregate: (rows: Row[], field: string, func: AggregateFunction) => number | null;
+/**
+ * Compute all configured aggregates for a set of rows
+ */
+export declare const computeAggregations: (rows: Row[], aggregateConfigs: AggregateConfig[]) => {
+    [key: string]: number | null;
+};
+/**
+ * Compute group-level aggregations for each group in grouped rows
+ */
+export declare const computeGroupAggregations: (groupedRows: (Row | GroupedRow)[], aggregateConfigs: AggregateConfig[]) => Map<string, {
+    [key: string]: number | null;
+}>;
+/**
+ * Format aggregate value for display
+ */
+export declare const formatAggregateValue: (value: number | null, func: AggregateFunction) => string;
+/**
+ * Get display label for an aggregate function
+ */
+export declare const getAggregateLabel: (func: AggregateFunction) => string;

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

@@ -0,0 +1,36 @@
+import type { Row, Column, FilterValue } from './types';
+/**
+ * Context Menu Utility Functions
+ *
+ * Helper functions for context menu actions like copy, export, etc.
+ */
+/**
+ * Copy selected cells to clipboard
+ */
+export declare const copyToClipboard: (selectedRows: Set<string | number>, columns: Column[], rows: Row[], includeHeaders?: boolean) => Promise<void>;
+/**
+ * Copy a specific cell range to clipboard
+ */
+export declare const copyCellRange: (startRow: number, endRow: number, startCol: number, endCol: number, columns: Column[], rows: Row[], includeHeaders?: boolean) => Promise<void>;
+/**
+ * Export selected rows to CSV
+ */
+export declare const exportSelectedToCSV: (selectedRows: Set<string | number>, columns: Column[], rows: Row[], filename?: string) => void;
+/**
+ * Calculate optimal column width based on content
+ */
+export declare const calculateOptimalWidth: (column: Column, rows: Row[], minWidth?: number, maxWidth?: number, padding?: number) => number;
+/**
+ * Auto-size all columns
+ */
+export declare const autoSizeAllColumns: (columns: Column[], rows: Row[]) => {
+    [field: string]: number;
+};
+/**
+ * Create a "filter by value" filter configuration
+ */
+export declare const createFilterByValue: (value: unknown) => FilterValue;
+/**
+ * Get unique values for a column (for filter suggestions)
+ */
+export declare const getUniqueColumnValues: (column: Column, rows: Row[], maxValues?: number) => unknown[];

package/dist/assets/components/DataGrid/demos/TooltipDemo.d.ts

@@ -0,0 +1 @@
+export declare const TooltipDemo: () => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,42 @@
+/**
+ * DataGrid Density Mode System
+ * Provides Ultra Compact, Compact, Normal, and Comfortable display modes with CSS variables
+ */
+export type DensityMode = 'ultraCompact' | 'compact' | 'normal' | 'comfortable';
+export interface DensityConfig {
+    mode: DensityMode;
+    rowHeight: string;
+    cellPadding: string;
+    headerPadding: string;
+    fontSize: string;
+    fontSizeSmall: string;
+}
+/**
+ * Density mode configurations
+ * Defines row height, padding, and font sizes for each density mode
+ */
+export declare const densityConfigs: Record<DensityMode, DensityConfig>;
+/**
+ * Get density configuration by mode
+ */
+export declare function getDensityConfig(mode?: DensityMode): DensityConfig;
+/**
+ * Generate CSS variables from density configuration
+ */
+export declare function generateDensityCSS(mode: DensityMode): Record<string, string>;
+/**
+ * Get all density mode names
+ */
+export declare function getDensityModes(): DensityMode[];
+/**
+ * Get display label for density mode
+ */
+export declare function getDensityLabel(mode: DensityMode): string;
+/**
+ * Persist density mode to localStorage
+ */
+export declare function saveDensityMode(mode: DensityMode, key?: string): void;
+/**
+ * Load density mode from localStorage
+ */
+export declare function loadDensityMode(key?: string): DensityMode | null;

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

@@ -0,0 +1,98 @@
+import type { Row, TreeNode, GroupedRow } from './types';
+/**
+ * Row Dragging / Reorder Utilities
+ *
+ * Utilities for implementing drag-and-drop row reordering functionality.
+ */
+export interface DragRowConfig {
+    enabled: boolean;
+    showDragHandle?: boolean;
+    allowCrossGroup?: boolean;
+    allowExternalDrop?: boolean;
+    onRowDrop?: (sourceIndex: number, targetIndex: number, row: Row) => void;
+    onRowMove?: (sourceIndex: number, targetIndex: number) => void;
+    onExternalDrop?: (data: any, targetIndex: number) => void;
+    dragHandlePosition?: 'left' | 'right';
+}
+export interface DragState {
+    isDragging: boolean;
+    draggedRowId: string | number | null;
+    draggedRowIndex: number | null;
+    dropTargetIndex: number | null;
+    dropPosition: 'before' | 'after' | null;
+}
+export declare const initialDragState: DragState;
+/**
+ * Reorder rows array based on drag-and-drop indices
+ */
+export declare const reorderRows: <T extends Row>(rows: T[], sourceIndex: number, targetIndex: number) => T[];
+/**
+ * Get the drop position (before/after) based on mouse position within the row
+ */
+export declare const getDropPosition: (event: React.DragEvent, rowElement: HTMLElement) => "before" | "after";
+/**
+ * Calculate the target index based on drop position
+ */
+export declare const calculateTargetIndex: (dropTargetIndex: number, dropPosition: "before" | "after" | null, sourceIndex: number) => number;
+/**
+ * Check if a row can be dropped at the target location
+ */
+export declare const canDropRow: (sourceIndex: number, targetIndex: number, _sourceRow: Row | TreeNode | GroupedRow, _targetRow: Row | TreeNode | GroupedRow, config: DragRowConfig) => boolean;
+/**
+ * Create drag data transfer object
+ */
+export declare const createDragData: (row: Row, rowIndex: number, tableId?: string) => string;
+/**
+ * Parse drag data transfer object
+ */
+export declare const parseDragData: (dataTransfer: string) => {
+    row: Row;
+    rowIndex: number;
+    tableId?: string;
+    timestamp: number;
+} | null;
+/**
+ * Check if drag data is from the same table
+ */
+export declare const isSameTable: (dragData: ReturnType<typeof parseDragData>, currentTableId?: string) => boolean;
+/**
+ * Get visual drop indicator styles
+ */
+export declare const getDropIndicatorStyle: (isOver: boolean, position: "before" | "after" | null) => React.CSSProperties;
+/**
+ * Handle drag start event
+ */
+export declare const handleDragStart: (event: React.DragEvent, row: Row, rowIndex: number, tableId?: string) => void;
+/**
+ * Handle drag end event
+ */
+export declare const handleDragEnd: (event: React.DragEvent) => void;
+/**
+ * Handle drag over event (required for drop to work)
+ */
+export declare const handleDragOver: (event: React.DragEvent) => void;
+/**
+ * Validate drop operation
+ */
+export declare const validateDrop: (event: React.DragEvent, config: DragRowConfig, tableId?: string) => boolean;
+/**
+ * Get draggable row props
+ */
+export declare const getDraggableRowProps: (row: Row, rowIndex: number, isDragging: boolean, config: DragRowConfig, tableId?: string) => {
+    draggable: boolean;
+    onDragStart: (e: React.DragEvent) => void;
+    onDragEnd: (event: React.DragEvent) => void;
+    style: {
+        cursor: string;
+        opacity: number;
+        transition: string;
+    };
+};
+/**
+ * Get drop target props
+ */
+export declare const getDropTargetProps: (rowIndex: number, onDragOver: (e: React.DragEvent, index: number) => void, onDragLeave: () => void, onDrop: (e: React.DragEvent, index: number) => void) => {
+    onDragOver: (e: React.DragEvent) => void;
+    onDragLeave: () => void;
+    onDrop: (e: React.DragEvent) => void;
+};

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

@@ -0,0 +1,30 @@
+import type { Column, Row } from './types';
+export type ExportFormat = 'csv' | 'xlsx';
+export type ExportScope = 'all' | 'filtered' | 'selected' | 'page';
+export type ExcelStyling = 'basic' | 'professional';
+export interface ExportOptions {
+    format: ExportFormat;
+    scope: ExportScope;
+    includeHeader?: boolean;
+    styling?: ExcelStyling;
+    filename?: string;
+}
+/**
+ * Converts a dataset to CSV format and triggers download
+ */
+export declare const exportToCSV: (data: Row[], columns: Column[], filename?: string) => void;
+/**
+ * Converts a dataset to XLSX format with optional styling and triggers download
+ */
+export declare const exportToXLSX: (data: Row[], columns: Column[], options?: {
+    filename?: string;
+    styling?: ExcelStyling;
+}) => Promise<void>;
+/**
+ * Generates a filename with timestamp
+ */
+export declare const generateFilename: (format: ExportFormat, scope: ExportScope) => string;
+/**
+ * Handles the complete export process
+ */
+export declare const handleExport: (data: Row[], columns: Column[], options: ExportOptions) => Promise<void>;

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

@@ -0,0 +1,17 @@
+import type { Row, FilterConfig } from './types';
+/**
+ * Apply all filters to rows
+ */
+export declare const applyFilters: (rows: Row[], filterConfig: FilterConfig) => Row[];
+/**
+ * Check if any filters are active
+ */
+export declare const hasActiveFilters: (filterConfig: FilterConfig) => boolean;
+/**
+ * Get count of active filters
+ */
+export declare const getActiveFilterCount: (filterConfig: FilterConfig) => number;
+/**
+ * Clear all filters
+ */
+export declare const clearAllFilters: () => FilterConfig;

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

@@ -0,0 +1,142 @@
+/**
+ * Grid API Implementation
+ * Concrete implementation of the GridApi interface
+ */
+import type { Dispatch } from 'react';
+import type { GridApi, RowNode, RowModel, ColumnState, RefreshCellsParams, RedrawRowsParams, CsvExportParams, ExcelExportParams, RowDataTransaction, RowNodeTransaction, StartEditingCellParams, ColKey } from './gridApi.types';
+import type { Column, Row, FilterConfig, SortConfig, LayoutPreset } from './types';
+import type { GridAction, GridState } from './gridReducer';
+import { LayoutPersistenceManager } from './layoutPersistence';
+/**
+ * Grid API Implementation
+ */
+export declare class GridApiImpl implements GridApi {
+    private state;
+    private dispatch;
+    private columns;
+    private rows;
+    private persistenceManager;
+    private destroyed;
+    private containerRef;
+    private eventListeners;
+    private setInternalRows?;
+    constructor(state: GridState, dispatch: Dispatch<GridAction>, columns: Column[], rows: Row[], containerRef: React.RefObject<HTMLDivElement | null>, persistenceManager?: LayoutPersistenceManager | null, setInternalRows?: (rows: Row[]) => void);
+    /**
+     * Update internal state reference (called by parent component on state change)
+     */
+    updateState(state: GridState): void;
+    /**
+     * Update internal data references
+     */
+    updateData(columns: Column[], rows: Row[]): void;
+    /**
+     * Update callback references
+     */
+    updateCallbacks(setInternalRows?: (rows: Row[]) => void): void;
+    setRowData(rows: Row[]): void;
+    applyTransaction(transaction: RowDataTransaction): RowNodeTransaction;
+    applyTransactionAsync(transaction: RowDataTransaction): Promise<RowNodeTransaction>;
+    getModel(): RowModel;
+    getDisplayedRowCount(): number;
+    getDisplayedRowAtIndex(index: number): RowNode | null;
+    forEachNode(callback: (node: RowNode, index: number) => void): void;
+    forEachNodeAfterFilter(callback: (node: RowNode, index: number) => void): void;
+    forEachNodeAfterFilterAndSort(callback: (node: RowNode, index: number) => void): void;
+    getFirstDisplayedRow(): number;
+    getLastDisplayedRow(): number;
+    getColumnDefs(): Column[];
+    setColumnDefs(colDefs: Column[]): void;
+    getAllColumns(): Column[];
+    getDisplayedCenterColumns(): Column[];
+    getDisplayedLeftColumns(): Column[];
+    getDisplayedRightColumns(): Column[];
+    setColumnVisible(key: ColKey, visible: boolean): void;
+    setColumnsVisible(keys: ColKey[], visible: boolean): void;
+    setColumnPinned(key: ColKey, pinned: 'left' | 'right' | null): void;
+    autoSizeColumns(keys?: ColKey[]): void;
+    autoSizeAllColumns(): void;
+    moveColumn(key: ColKey, toIndex: number): void;
+    moveColumns(keys: ColKey[], toIndex: number): void;
+    getColumnState(): ColumnState[];
+    applyColumnState(state: ColumnState[]): void;
+    resetColumnState(): void;
+    getColumn(key: ColKey): Column | null;
+    isAnyFilterPresent(): boolean;
+    getFilterModel(): FilterConfig;
+    setFilterModel(model: FilterConfig): void;
+    onFilterChanged(): void;
+    destroyFilter(colKey: ColKey): void;
+    getFilterInstance(_colKey: ColKey): unknown;
+    clearAllFilters(): void;
+    getSortModel(): SortConfig[];
+    setSortModel(model: SortConfig[]): void;
+    onSortChanged(): void;
+    clearAllSorting(): void;
+    getSelectedNodes(): RowNode[];
+    getSelectedRows(): Row[];
+    selectAll(): void;
+    deselectAll(): void;
+    selectAllFiltered(): void;
+    deselectAllFiltered(): void;
+    getSelectedRowCount(): number;
+    ensureIndexVisible(index: number, position?: 'top' | 'middle' | 'bottom'): void;
+    ensureNodeVisible(node: RowNode, position?: 'top' | 'middle' | 'bottom'): void;
+    setFocusedCell(rowIndex: number, colKey: ColKey): void;
+    clearFocusedCell(): void;
+    getFocusedCell(): {
+        rowIndex: number;
+        column: Column;
+    } | null;
+    startEditingCell(params: StartEditingCellParams): void;
+    stopEditing(cancel?: boolean): void;
+    getEditingCells(): Array<{
+        rowIndex: number;
+        column: Column;
+    }>;
+    refreshCells(params?: RefreshCellsParams): void;
+    refreshHeader(): void;
+    refreshToolPanel(): void;
+    redrawRows(params?: RedrawRowsParams): void;
+    sizeColumnsToFit(): void;
+    doLayout(): void;
+    exportDataAsCsv(params?: CsvExportParams): void;
+    getDataAsCsv(params?: CsvExportParams): string;
+    exportDataAsExcel(params?: ExcelExportParams): void;
+    copySelectedRowsToClipboard(): void;
+    copySelectedRangeToClipboard(): void;
+    showLoadingOverlay(): void;
+    showNoRowsOverlay(): void;
+    hideOverlay(): void;
+    paginationGetCurrentPage(): number;
+    paginationGoToPage(page: number): void;
+    paginationGoToNextPage(): void;
+    paginationGoToPreviousPage(): void;
+    paginationGetTotalPages(): number;
+    paginationGetPageSize(): number;
+    paginationSetPageSize(size: number): void;
+    setRowGroupColumns(colKeys: ColKey[]): void;
+    addRowGroupColumn(colKey: ColKey): void;
+    removeRowGroupColumn(colKey: ColKey): void;
+    getRowGroupColumns(): Column[];
+    expandAll(): void;
+    collapseAll(): void;
+    onGroupExpandedOrCollapsed(node?: RowNode): void;
+    saveLayout(name: string): Promise<void>;
+    loadLayout(name: string): Promise<void>;
+    getLayoutState(): LayoutPreset['layout'];
+    applyLayoutState(layout: LayoutPreset['layout']): void;
+    destroy(): void;
+    isDestroyed(): boolean;
+    addEventListener(eventType: string, listener: (event: unknown) => void): void;
+    removeEventListener(eventType: string, listener: (event: unknown) => void): void;
+    private ensureNotDestroyed;
+    private createRowNode;
+    private resolveColKey;
+    private getDisplayedRows;
+    private getFilteredRows;
+    private applySorting;
+    private calculateColumnWidth;
+    private formatCsvValue;
+    private copyToClipboard;
+    private fireEvent;
+}