@smartnet360/svelte-grid 0.1.0

package/dist/state/gridState.svelte.d.ts

@@ -0,0 +1,299 @@
+/**
+ * Grid State Factory
+ *
+ * Creates reactive state for the grid using Svelte 5 runes.
+ * This is the central state management for all grid operations.
+ */
+import type { ColumnDefinition, GridOptions, TablePlugin, RowData, SortConfig, SortDirection, FilterConfig, FilterOperator, GroupBy, GroupConfig, GroupInfo, DisplayRow } from '../types.js';
+declare const GRID_CONTEXT_KEY: unique symbol;
+export { GRID_CONTEXT_KEY };
+/**
+ * Grid state class using Svelte 5 runes
+ * Manages all reactive state for a grid instance
+ */
+export declare class GridStateManager<T = RowData> {
+    /** Raw data array */
+    rawData: T[];
+    /** Column definitions */
+    columns: ColumnDefinition<T>[];
+    /** Scroll position */
+    scrollTop: number;
+    scrollLeft: number;
+    /** Container dimensions */
+    containerHeight: number;
+    containerWidth: number;
+    /** Row height for virtual scrolling */
+    rowHeight: number;
+    /** Grid options */
+    options: Partial<GridOptions<T>>;
+    /** Current sort configuration (supports multi-sort) */
+    sortConfigs: SortConfig[];
+    /** Current filter configurations */
+    filterConfigs: FilterConfig[];
+    /** Header filter values (for UI inputs) */
+    headerFilterValues: Record<string, string>;
+    /** Group configuration */
+    groupByConfig: GroupConfig<T>[];
+    /** Set of open group keys (using string path like "field:value" or "field:value/field2:value2" for nested) */
+    openGroups: Set<string>;
+    /** Height of group header rows */
+    groupHeaderHeight: number;
+    /** Column widths (overrides column.width when user resizes) */
+    columnWidths: Record<string, number>;
+    /** Registered plugins */
+    private plugins;
+    /** Data pipeline handlers sorted by priority */
+    private pipelineHandlers;
+    /** Data after passing through filtering, sorting, and plugin pipeline */
+    processedData: T[];
+    /** Whether grouping is enabled */
+    isGrouped: boolean;
+    /** Build groups from processed data */
+    groupedData: GroupInfo<T>[];
+    /** Display rows - either flat data or grouped data with headers */
+    displayRows: DisplayRow<T>[];
+    /** Flatten groups into display rows (group headers + visible rows) */
+    private flattenGroups;
+    /** Build group hierarchy recursively */
+    private buildGroups;
+    /** Count total rows in a group including nested groups */
+    private countNestedRows;
+    /** Calculate aggregates for a group's rows */
+    private calculateAggregates;
+    /** Check if a group is open */
+    private isGroupOpen;
+    /** Apply filter configs to data */
+    private applyFilters;
+    /** Apply header filter values to data */
+    private applyHeaderFilters;
+    /** Check if a value matches a filter condition */
+    private matchesFilter;
+    /** Apply sort configs to data */
+    private applySorting;
+    /** Total number of rows after processing (includes group headers when grouped) */
+    totalRows: number;
+    /** Total data rows (without group headers) */
+    totalDataRows: number;
+    /** Visible columns (filtered for visibility) */
+    visibleColumns: ColumnDefinition<T>[];
+    /** Columns frozen to the left */
+    frozenLeftColumns: ColumnDefinition<T>[];
+    /** Columns frozen to the right */
+    frozenRightColumns: ColumnDefinition<T>[];
+    /** Scrollable (non-frozen) columns */
+    scrollableColumns: ColumnDefinition<T>[];
+    /** Number of rows frozen at the top (only applies when not grouped) */
+    frozenRowCount: number;
+    /** Frozen rows (always rendered at top) - only when not grouped */
+    frozenRows: T[];
+    /** Non-frozen display rows for virtual scrolling */
+    scrollableDisplayRows: DisplayRow<T>[];
+    /** Total scrollable rows (excluding frozen) */
+    scrollableRowCount: number;
+    /** Get effective row height for a display row */
+    getDisplayRowHeight(displayRow: DisplayRow<T>): number;
+    /** Total content height for scrollable area */
+    totalHeight: number;
+    /** Number of visible rows that fit in container (accounting for frozen row height) */
+    visibleRowCount: number;
+    /** Start index for visible scrollable rows (accounts for variable heights when grouped) */
+    startIndex: number;
+    /** End index for visible scrollable rows */
+    endIndex: number;
+    /** Visible display rows slice */
+    visibleDisplayRows: DisplayRow<T>[];
+    /** Legacy: visible data rows (for non-grouped compatibility) */
+    visibleRows: T[];
+    /** Offset for positioning visible rows (accounts for variable heights when grouped) */
+    offsetY: number;
+    constructor(options: GridOptions<T>);
+    /**
+     * Set grid options and update state
+     */
+    setOptions(options: GridOptions<T>): void;
+    /**
+     * Set new data
+     */
+    setData(data: T[]): void;
+    /**
+     * Update a single row by index
+     */
+    updateRow(index: number, data: Partial<T>): void;
+    /**
+     * Add a row at the end or at specific index
+     */
+    addRow(data: T, index?: number): void;
+    /**
+     * Remove a row by index
+     */
+    removeRow(index: number): void;
+    /**
+     * Get row by key value
+     */
+    getRowByKey(keyField: keyof T, keyValue: unknown): T | undefined;
+    /**
+     * Set column definitions
+     */
+    setColumns(columns: ColumnDefinition<T>[]): void;
+    /**
+     * Update a single column definition
+     */
+    updateColumn(field: string, updates: Partial<ColumnDefinition<T>>): void;
+    /**
+     * Show/hide a column
+     */
+    setColumnVisibility(field: string, visible: boolean): void;
+    /**
+     * Get column by field name
+     */
+    getColumn(field: string): ColumnDefinition<T> | undefined;
+    /**
+     * Set sort for a field (replaces existing sort)
+     */
+    setSort(field: string, direction: SortDirection): void;
+    /**
+     * Toggle sort for a field (cycles through: none -> asc -> desc -> none)
+     */
+    toggleSort(field: string, multiSort?: boolean): void;
+    /**
+     * Clear all sorting
+     */
+    clearSort(): void;
+    /**
+     * Get current sort direction for a field
+     */
+    getSortDirection(field: string): SortDirection;
+    /**
+     * Get sort index for multi-sort (0-based, -1 if not sorted)
+     */
+    getSortIndex(field: string): number;
+    /**
+     * Set a programmatic filter
+     */
+    setFilter(field: string, operator: FilterOperator, value: unknown): void;
+    /**
+     * Remove a filter for a field
+     */
+    removeFilter(field: string): void;
+    /**
+     * Clear all filters
+     */
+    clearFilters(): void;
+    /**
+     * Set header filter value (for UI input)
+     */
+    setHeaderFilter(field: string, value: string): void;
+    /**
+     * Get header filter value
+     */
+    getHeaderFilter(field: string): string;
+    /**
+     * Set column width (from user resize)
+     */
+    setColumnWidth(field: string, width: number): void;
+    /**
+     * Get effective column width (user-set or default)
+     */
+    getColumnWidth(field: string): number | undefined;
+    /**
+     * Reset column width to default
+     */
+    resetColumnWidth(field: string): void;
+    /**
+     * Reset all column widths
+     */
+    resetAllColumnWidths(): void;
+    /**
+     * Auto-fit column width to content (double-click resize)
+     */
+    autoFitColumn(field: string): void;
+    /**
+     * Auto-fit all columns to their content
+     */
+    autoFitAllColumns(): void;
+    /**
+     * Get the sticky left position for a frozen left column
+     */
+    getFrozenLeftPosition(field: string): number;
+    /**
+     * Get the sticky right position for a frozen right column
+     */
+    getFrozenRightPosition(field: string): number;
+    /**
+     * Get total width of frozen left columns
+     */
+    get frozenLeftWidth(): number;
+    /**
+     * Get total width of frozen right columns
+     */
+    get frozenRightWidth(): number;
+    /**
+     * Set the number of frozen rows
+     */
+    setFrozenRowCount(count: number): void;
+    /**
+     * Set group configuration
+     * @param groupBy - Field name, array of fields, function, or GroupConfig
+     */
+    setGroupBy(groupBy: GroupBy<T> | undefined): void;
+    /**
+     * Toggle a group open/closed
+     */
+    toggleGroup(groupPath: string): void;
+    /**
+     * Expand all groups
+     */
+    expandAllGroups(): void;
+    /**
+     * Collapse all groups
+     */
+    collapseAllGroups(): void;
+    /**
+     * Get the path for a group (used for open/closed tracking)
+     */
+    private getGroupPath;
+    /**
+     * Get groups at a specific level
+     */
+    getGroupsAtLevel(level: number): GroupInfo<T>[];
+    /**
+     * Set group header height
+     */
+    setGroupHeaderHeight(height: number): void;
+    /**
+     * Update scroll position
+     */
+    setScrollPosition(top: number, left?: number): void;
+    /**
+     * Update container dimensions
+     */
+    setContainerDimensions(width: number, height: number): void;
+    /**
+     * Scroll to a specific row index
+     */
+    scrollToRow(index: number): void;
+    /**
+     * Register a plugin
+     */
+    registerPlugin(plugin: TablePlugin<T>): void;
+    /**
+     * Unregister a plugin
+     */
+    unregisterPlugin(name: string): void;
+    /**
+     * Get plugin API
+     */
+    getPluginApi(name: string): Record<string, (...args: unknown[]) => unknown> | undefined;
+    /**
+     * Get all plugin header cell enhancements for a column
+     */
+    getHeaderCellEnhancements(column: ColumnDefinition<T>): Record<string, unknown>;
+    /**
+     * Destroy the state manager and cleanup plugins
+     */
+    destroy(): void;
+}
+/**
+ * Factory function to create a new grid state manager
+ */
+export declare function createGridState<T>(options: GridOptions<T>): GridStateManager<T>;