@jmruthers/pace-core 0.5.74 → 0.5.76

package/src/components/DataTable/utils/errorHandling.ts

@@ -1,494 +1,86 @@
 /**
- * @file Error Handling and Fallbacks for DataTable Performance
+ * @file Error Handling Stubs
  * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/ErrorHandling
- * @since 0.3.0
+ * @module Components/DataTable/Utils/Stubs
+ * 
+ * Minimal stubs for removed error handling utilities.
+ * This file exists only to prevent import errors in useDataTablePerformance.
  */
 
-import type { DataRecord, PaginationMode } from '../types';
+export interface FallbackConfig {
+  enabled: boolean;
+}
+
+export const DEFAULT_FALLBACK_CONFIG: FallbackConfig = {
+  enabled: false
+};
 
-/**
- * Error types for DataTable performance operations
- */
 export enum DataTableErrorType {
-  VIRTUALIZATION_ERROR = 'VIRTUALIZATION_ERROR',
-  SEARCH_INDEX_ERROR = 'SEARCH_INDEX_ERROR',
-  DATA_CHUNK_ERROR = 'DATA_CHUNK_ERROR',
-  SERVER_FETCH_ERROR = 'SERVER_FETCH_ERROR',
-  MEMORY_ERROR = 'MEMORY_ERROR',
-  PERFORMANCE_MONITOR_ERROR = 'PERFORMANCE_MONITOR_ERROR',
-  VISIBILITY_TRACKER_ERROR = 'VISIBILITY_TRACKER_ERROR',
+  VIRTUALIZATION = 'virtualization',
+  SEARCH_INDEX = 'search_index',
+  DATA_CHUNK = 'data_chunk',
+  SERVER_FETCH = 'server_fetch',
+  MEMORY = 'memory'
 }
 
-/**
- * Custom error class for DataTable operations
- */
 export class DataTableError extends Error {
-  public readonly type: DataTableErrorType;
-  public readonly timestamp: number;
-  public readonly context?: Record<string, any>;
-  public readonly recoverable: boolean;
-
   constructor(
     message: string,
-    type: DataTableErrorType,
-    context?: Record<string, any>,
-    recoverable: boolean = true
+    public type: DataTableErrorType,
+    public recoverable: boolean = true
   ) {
     super(message);
     this.name = 'DataTableError';
-    this.type = type;
-    this.timestamp = Date.now();
-    this.context = context;
-    this.recoverable = recoverable;
-  }
-}
-
-/**
- * Fallback configurations for different performance features
- */
-export interface FallbackConfig {
-  /** Fallback pagination mode when auto-detection fails */
-  fallbackPaginationMode: PaginationMode;
-  /** Fallback page size options */
-  fallbackPageSizeOptions: number[];
-  /** Maximum retry attempts for server requests */
-  maxRetries: number;
-  /** Retry delay in milliseconds */
-  retryDelay: number;
-  /** Maximum memory usage before falling back (in MB) */
-  maxMemoryUsage: number;
-  /** Enable graceful degradation */
-  enableGracefulDegradation: boolean;
-}
-
-/**
- * Default fallback configuration
- */
-export const DEFAULT_FALLBACK_CONFIG: FallbackConfig = {
-  fallbackPaginationMode: 'client',
-  fallbackPageSizeOptions: [10, 25, 50],
-  maxRetries: 3,
-  retryDelay: 1000,
-  maxMemoryUsage: 100, // 100MB
-  enableGracefulDegradation: true,
-};
-
-/**
- * Error recovery strategies
- */
-export interface ErrorRecoveryStrategy {
-  canRecover(error: DataTableError): boolean;
-  recover(error: DataTableError, context?: any): Promise<any> | any;
-  getFallback(error: DataTableError): any;
-}
-
-/**
- * Virtualization error recovery
- */
-export class VirtualizationErrorRecovery implements ErrorRecoveryStrategy {
-  canRecover(error: DataTableError): boolean {
-    return error.type === DataTableErrorType.VIRTUALIZATION_ERROR && error.recoverable;
-  }
-
-  recover(error: DataTableError): any {
-    console.warn('Virtualization failed, falling back to standard rendering:', error.message);
-    return {
-      enableVirtualization: false,
-      fallbackMessage: 'Virtual scrolling disabled due to compatibility issues',
-    };
-  }
-
-  getFallback(): any {
-    return {
-      enableVirtualization: false,
-      height: 400,
-      overscan: 0,
-    };
-  }
-}
-
-/**
- * Search index error recovery
- */
-export class SearchIndexErrorRecovery implements ErrorRecoveryStrategy {
-  canRecover(error: DataTableError): boolean {
-    return error.type === DataTableErrorType.SEARCH_INDEX_ERROR && error.recoverable;
-  }
-
-  recover(error: DataTableError): any {
-    console.warn('Search indexing failed, falling back to basic search:', error.message);
-    return {
-      enableSearchIndex: false,
-      fallbackMessage: 'Advanced search disabled, using basic text search',
-    };
-  }
-
-  getFallback(): any {
-    return {
-      enableSearchIndex: false,
-      fuzzySearch: false,
-    };
-  }
-}
-
-/**
- * Data chunk error recovery
- */
-export class DataChunkErrorRecovery implements ErrorRecoveryStrategy {
-  canRecover(error: DataTableError): boolean {
-    return error.type === DataTableErrorType.DATA_CHUNK_ERROR && error.recoverable;
-  }
-
-  recover(error: DataTableError): any {
-    console.warn('Data chunking failed, loading all data:', error.message);
-    return {
-      enableChunking: false,
-      fallbackMessage: 'Memory optimization disabled, all data loaded',
-    };
-  }
-
-  getFallback(): any {
-    return {
-      enableChunking: false,
-      chunkSize: Number.MAX_SAFE_INTEGER,
-    };
-  }
-}
-
-/**
- * Server fetch error recovery with retry logic
- */
-export class ServerFetchErrorRecovery implements ErrorRecoveryStrategy {
-  private retryCount = 0;
-  private readonly maxRetries: number;
-  private readonly retryDelay: number;
-
-  constructor(config: FallbackConfig = DEFAULT_FALLBACK_CONFIG) {
-    this.maxRetries = config.maxRetries;
-    this.retryDelay = config.retryDelay;
-  }
-
-  canRecover(error: DataTableError): boolean {
-    return error.type === DataTableErrorType.SERVER_FETCH_ERROR && 
-           this.retryCount < this.maxRetries;
-  }
-
-  async recover(error: DataTableError, retryFn?: () => Promise<any>): Promise<any> {
-    this.retryCount++;
-    const delay = this.retryDelay * Math.pow(2, this.retryCount - 1); // Exponential backoff
-    
-    console.warn(`Server fetch failed, retrying in ${delay}ms (attempt ${this.retryCount}/${this.maxRetries}):`, error.message);
-    
-    await new Promise(resolve => setTimeout(resolve, delay));
-    
-    if (retryFn) {
-      try {
-        const result = await retryFn();
-        this.retryCount = 0; // Reset on success
-        return result;
-      } catch (retryError) {
-        if (this.retryCount >= this.maxRetries) {
-          throw new DataTableError(
-            'Max retry attempts exceeded',
-            DataTableErrorType.SERVER_FETCH_ERROR,
-            { originalError: error, retryCount: this.retryCount },
-            false
-          );
-        }
-        return this.recover(error, retryFn);
-      }
-    }
-    
-    return this.getFallback(error);
-  }
-
-  getFallback(error: DataTableError): any {
-    return {
-      paginationMode: 'client',
-      fallbackMessage: 'Server unavailable, switched to client-side mode',
-      data: [],
-      totalCount: 0,
-    };
-  }
-}
-
-/**
- * Memory error recovery
- */
-export class MemoryErrorRecovery implements ErrorRecoveryStrategy {
-  private readonly maxMemoryUsage: number;
-
-  constructor(config: FallbackConfig = DEFAULT_FALLBACK_CONFIG) {
-    this.maxMemoryUsage = config.maxMemoryUsage;
-  }
-
-  canRecover(error: DataTableError): boolean {
-    return error.type === DataTableErrorType.MEMORY_ERROR;
-  }
-
-  recover(error: DataTableError): any {
-    console.warn('Memory usage too high, enabling aggressive optimizations:', error.message);
-    return {
-      enableChunking: true,
-      chunkSize: 100, // Smaller chunks
-      maxChunksInMemory: 2, // Fewer chunks in memory
-      enableVirtualization: true,
-      fallbackMessage: 'Memory optimization enabled to reduce usage',
-    };
-  }
-
-  getFallback(): any {
-    return {
-      paginationMode: 'server',
-      enableChunking: true,
-      chunkSize: 50,
-      maxChunksInMemory: 1,
-    };
   }
 }
 
-/**
- * Central error recovery manager
- */
 export class ErrorRecoveryManager {
-  private strategies: Map<DataTableErrorType, ErrorRecoveryStrategy> = new Map();
-  private errorLog: DataTableError[] = [];
-  private readonly maxErrorLogSize = 100;
-
-  constructor(config: FallbackConfig = DEFAULT_FALLBACK_CONFIG) {
-    this.strategies.set(DataTableErrorType.VIRTUALIZATION_ERROR, new VirtualizationErrorRecovery());
-    this.strategies.set(DataTableErrorType.SEARCH_INDEX_ERROR, new SearchIndexErrorRecovery());
-    this.strategies.set(DataTableErrorType.DATA_CHUNK_ERROR, new DataChunkErrorRecovery());
-    this.strategies.set(DataTableErrorType.SERVER_FETCH_ERROR, new ServerFetchErrorRecovery(config));
-    this.strategies.set(DataTableErrorType.MEMORY_ERROR, new MemoryErrorRecovery(config));
-  }
-
-  /**
-   * Handle error with appropriate recovery strategy
-   */
-  async handleError(error: DataTableError, context?: any): Promise<any> {
-    // Log the error
-    this.logError(error);
-
-    // Get recovery strategy
-    const strategy = this.strategies.get(error.type);
-    if (!strategy) {
-      console.error('No recovery strategy found for error type:', error.type);
-      throw error;
-    }
-
-    // Attempt recovery
-    if (strategy.canRecover(error)) {
-      try {
-        return await strategy.recover(error, context);
-      } catch (recoveryError) {
-        console.error('Recovery failed:', recoveryError);
-        return strategy.getFallback(error);
-      }
-    }
-
-    // Return fallback if recovery not possible
-    return strategy.getFallback(error);
+  constructor(private config: FallbackConfig) {}
+  
+  async handleError(error: DataTableError) {
+    return { recovered: false, strategy: null };
   }
-
-  /**
-   * Log error for debugging and monitoring
-   */
-  private logError(error: DataTableError): void {
-    this.errorLog.push(error);
-    
-    // Maintain log size
-    if (this.errorLog.length > this.maxErrorLogSize) {
-      this.errorLog.shift();
-    }
-
-    // Log to console with context
-    console.error('DataTable Error:', {
-      type: error.type,
-      message: error.message,
-      timestamp: new Date(error.timestamp).toISOString(),
-      context: error.context,
-      recoverable: error.recoverable,
-    });
-  }
-
-  /**
-   * Get error statistics for monitoring
-   */
-  getErrorStats(): {
-    totalErrors: number;
-    errorsByType: Record<string, number>;
-    recentErrors: DataTableError[];
-  } {
-    const errorsByType: Record<string, number> = {};
-    
-    for (const error of this.errorLog) {
-      errorsByType[error.type] = (errorsByType[error.type] || 0) + 1;
-    }
-
-    return {
-      totalErrors: this.errorLog.length,
-      errorsByType,
-      recentErrors: this.errorLog.slice(-10), // Last 10 errors
-    };
-  }
-
-  /**
-   * Clear error log
-   */
+  
   clearErrorLog(): void {
-    this.errorLog = [];
+    // Stub method
   }
 }
 
-/**
- * Safe execution wrapper with error handling
- */
-export async function safeExecute<T>(
-  operation: () => Promise<T> | T,
-  errorType: DataTableErrorType,
-  context?: Record<string, any>,
-  recoveryManager?: ErrorRecoveryManager
-): Promise<T | null> {
-  try {
-    return await operation();
-  } catch (error) {
-    const dataTableError = new DataTableError(
-      error instanceof Error ? error.message : 'Unknown error',
-      errorType,
-      { ...context, originalError: error }
-    );
-
-    if (recoveryManager) {
-      try {
-        return await recoveryManager.handleError(dataTableError);
-      } catch (recoveryError) {
-        console.error('Recovery failed:', recoveryError);
-        return null;
-      }
-    }
-
-    throw dataTableError;
-  }
-}
-
-/**
- * Memory usage monitor with automatic fallbacks
- */
 export class MemoryMonitor {
-  private readonly maxMemoryUsage: number;
-  private checkInterval: NodeJS.Timeout | null = null;
-  private onMemoryExceeded?: (usage: number) => void;
-
-  constructor(
-    maxMemoryUsage: number = 100, // MB
-    onMemoryExceeded?: (usage: number) => void
-  ) {
-    this.maxMemoryUsage = maxMemoryUsage;
-    this.onMemoryExceeded = onMemoryExceeded;
+  constructor(private threshold: number = 100) {}
+  
+  getCurrentUsage(): number {
+    return 0;
   }
-
-  /**
-   * Start monitoring memory usage
-   */
-  startMonitoring(interval: number = 5000): void {
-    this.checkInterval = setInterval(() => {
-      const memoryUsage = this.getCurrentMemoryUsage();
-      
-      if (memoryUsage > this.maxMemoryUsage) {
-        this.onMemoryExceeded?.(memoryUsage);
-        
-        // Trigger memory error for recovery
-        const error = new DataTableError(
-          `Memory usage exceeded ${this.maxMemoryUsage}MB (current: ${memoryUsage}MB)`,
-          DataTableErrorType.MEMORY_ERROR,
-          { memoryUsage, maxMemoryUsage: this.maxMemoryUsage }
-        );
-        
-        console.warn(error.message);
-      }
-    }, interval);
+  
+  checkThreshold(): boolean {
+    return true;
   }
-
-  /**
-   * Stop monitoring
-   */
+  
   stopMonitoring(): void {
-    if (this.checkInterval) {
-      clearInterval(this.checkInterval);
-      this.checkInterval = null;
-    }
-  }
-
-  /**
-   * Get current memory usage in MB
-   */
-  private getCurrentMemoryUsage(): number {
-    if ('memory' in performance) {
-      const memory = (performance as any).memory;
-      return memory.usedJSHeapSize / (1024 * 1024);
-    }
-    return 0;
+    // Stub method
   }
 }
 
-/**
- * Circuit breaker pattern for preventing cascading failures
- */
 export class CircuitBreaker {
-  private failureCount = 0;
-  private lastFailureTime = 0;
-  private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';
-
-  constructor(
-    private readonly failureThreshold: number = 5,
-    private readonly timeout: number = 60000 // 1 minute
-  ) {}
-
-  async execute<T>(operation: () => Promise<T>): Promise<T> {
-    if (this.state === 'OPEN') {
-      if (Date.now() - this.lastFailureTime > this.timeout) {
-        this.state = 'HALF_OPEN';
-      } else {
-        throw new DataTableError(
-          'Circuit breaker is OPEN',
-          DataTableErrorType.SERVER_FETCH_ERROR,
-          { state: this.state, failureCount: this.failureCount },
-          false
-        );
-      }
-    }
-
-    try {
-      const result = await operation();
-      this.onSuccess();
-      return result;
-    } catch (error) {
-      this.onFailure();
-      throw error;
-    }
-  }
-
-  private onSuccess(): void {
-    this.failureCount = 0;
-    this.state = 'CLOSED';
-  }
+  constructor() {}
+  
+  isOpen(): boolean {
+    return false;
+  }
+  
+  recordSuccess(): void {}
+  
+  recordFailure(): void {}
+  
+  reset(): void {}
+}
 
-  private onFailure(): void {
-    this.failureCount++;
-    this.lastFailureTime = Date.now();
-    
-    if (this.failureCount >= this.failureThreshold) {
-      this.state = 'OPEN';
-    }
+export function safeExecute<T>(fn: () => T, fallback: T): T {
+  try {
+    return fn();
+  } catch {
+    return fallback;
   }
+}
 
-  getState(): { state: string; failureCount: number; lastFailureTime: number } {
-    return {
-      state: this.state,
-      failureCount: this.failureCount,
-      lastFailureTime: this.lastFailureTime,
-    };
-  }
-} 

package/src/components/DataTable/utils/exportUtils.ts

@@ -82,6 +82,7 @@ export function generateCSVContent<TData>(
  * @param data - Array of data objects to export
  * @param columns - Column definitions for mapping
  * @param filename - Optional filename for download (default: "download.csv")
+ * @returns Promise that resolves when export is complete, rejects on error
  * 
  * @example
  * ```tsx
@@ -96,7 +97,12 @@ export function generateCSVContent<TData>(
  *   { accessorKey: 'email', header: 'Email' }
  * ];
  * 
- * exportToCSV(users, columns, 'users.csv');
+ * try {
+ *   await exportToCSV(users, columns, 'users.csv');
+ *   showSuccessToast('Data exported successfully');
+ * } catch (error) {
+ *   showErrorToast('Failed to export data');
+ * }
  * ```
  * 
  * @remarks
@@ -104,23 +110,48 @@ export function generateCSVContent<TData>(
  * - Uses column headers for CSV headers
  * - Sanitizes data to prevent CSV injection
  * - Triggers browser download
+ * - Throws error if export fails
  */
 export function exportToCSV<TData>(
   data: TData[],
   columns: any[],
   filename: string = "download.csv"
-): void {
-  const csvContent = generateCSVContent(data, columns);
-  
-  // Create and trigger download
-  const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" });
-  const link = document.createElement("a");
-  const url = URL.createObjectURL(blob);
-  
-  link.setAttribute("href", url);
-  link.setAttribute("download", filename);
-  link.style.display = "none";
-  document.body.appendChild(link);
-  link.click();
-  document.body.removeChild(link);
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    try {
+      if (!data || data.length === 0) {
+        throw new Error('No data to export');
+      }
+
+      if (!columns || columns.length === 0) {
+        throw new Error('No columns defined for export');
+      }
+
+      const csvContent = generateCSVContent(data, columns);
+      
+      // Create and trigger download
+      const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" });
+      const link = document.createElement("a");
+      const url = URL.createObjectURL(blob);
+      
+      link.setAttribute("href", url);
+      link.setAttribute("download", filename);
+      link.style.display = "none";
+      
+      // Handle click event
+      link.onclick = () => {
+        setTimeout(() => {
+          URL.revokeObjectURL(url);
+          resolve();
+        }, 100);
+      };
+      
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+    } catch (error) {
+      console.error('Failed to export data to CSV:', error);
+      reject(error);
+    }
+  });
 }

package/src/components/DataTable/utils/hierarchicalSorting.ts

@@ -9,10 +9,57 @@ import type { HierarchicalDataRow } from '../types';
 import type { SortingState } from '@tanstack/react-table';
 
 /**
- * Sorts hierarchical data while preserving parent-child relationships
- * Parent rows maintain their order, child rows are sorted within their parent groups
+ * Sorts hierarchical data by structure only (parents before children).
+ * This is the basic hierarchical ordering without any column-based sorting.
+ * 
+ * @param data - Array of hierarchical data rows
+ * @returns Data sorted with parents first, then their children
+ * 
+ * @example
+ * ```tsx
+ * const sorted = sortHierarchicalDataByStructure([...data]);
+ * ```
  */
-export function sortHierarchicalData<TData extends HierarchicalDataRow>(
+export function sortHierarchicalDataByStructure<TData extends HierarchicalDataRow>(
+  data: TData[]
+): TData[] {
+  const sorted: TData[] = [];
+  const processed = new Set<string>();
+  
+  // First, add all parent rows
+  data.forEach(row => {
+    if (row.isParent && !processed.has(row.id)) {
+      sorted.push(row);
+      processed.add(row.id);
+    }
+  });
+  
+  // Then, add children in order
+  data.forEach(row => {
+    if (!row.isParent && !processed.has(row.id)) {
+      sorted.push(row);
+      processed.add(row.id);
+    }
+  });
+  
+  return sorted;
+}
+
+/**
+ * Sorts hierarchical data while preserving parent-child relationships.
+ * Parent rows maintain their order, child rows are sorted within their parent groups.
+ * This applies column-based sorting based on the provided sorting state.
+ * 
+ * @param data - Array of hierarchical data rows
+ * @param sorting - TanStack Table sorting state (column + direction)
+ * @returns Data sorted with parents first, children sorted within each parent
+ * 
+ * @example
+ * ```tsx
+ * const sorted = sortHierarchicalDataWithSorting(data, [{ id: 'name', desc: false }]);
+ * ```
+ */
+export function sortHierarchicalDataWithSorting<TData extends HierarchicalDataRow>(
   data: TData[],
   sorting: SortingState
 ): TData[] {