@jmruthers/pace-core 0.2.6 → 0.4.1

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

@@ -1,510 +0,0 @@
-/**
- * @file Flexible Import Utility
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils
- * @since 0.3.0
- * 
- * A flexible CSV import utility that can automatically map CSV columns to data table fields.
- * This utility can be used across different data tables with different column structures.
- */
-
-export interface ColumnMapping {
-  [targetField: string]: string[];
-}
-
-export interface ImportOptions {
-  columnMappings?: ColumnMapping;
-  dateFormats?: readonly string[];
-  dateFormatHints?: Record<string, readonly string[]>; // Field-specific date format hints
-  defaultValues?: Record<string, any>;
-  timezone?: string; // Default timezone for date parsing
-  strictDateParsing?: boolean; // Whether to be strict about date format matching
-}
-
-// Predefined date format sets for common use cases
-export const DATE_FORMAT_SETS = {
-  // US formats (MM/DD/YYYY)
-  US: [
-    'MM/DD/YYYY',
-    'M/D/YYYY', 
-    'MM/DD/YY',
-    'M/D/YY',
-    'MM-DD-YYYY',
-    'M-D-YYYY',
-    'MM/DD/YYYY HH:mm:ss',
-    'M/D/YYYY h:mm:ss A',
-  ],
-  
-  // European formats (DD/MM/YYYY)
-  EUROPEAN: [
-    'DD/MM/YYYY',
-    'D/M/YYYY',
-    'DD/MM/YY', 
-    'D/M/YY',
-    'DD-MM-YYYY',
-    'D-M-YYYY',
-    'DD.MM.YYYY',
-    'D.M.YYYY',
-    'DD/MM/YYYY HH:mm:ss',
-    'D/M/YYYY h:mm:ss A',
-  ],
-  
-  // ISO formats
-  ISO: [
-    'YYYY-MM-DD',
-    'YYYY-MM-DDTHH:mm:ss',
-    'YYYY-MM-DDTHH:mm:ss.sssZ',
-    'YYYY-MM-DDTHH:mm:ssZ',
-    'YYYY-MM-DD HH:mm:ss',
-  ],
-  
-  // Natural language formats
-  NATURAL: [
-    'DD MMM YYYY',
-    'DD MMMM YYYY', 
-    'MMM DD, YYYY',
-    'MMMM DD, YYYY',
-    'YYYY MMM DD',
-    'YYYY MMMM DD',
-  ],
-  
-  // Time-only formats
-  TIME: [
-    'HH:mm:ss',
-    'HH:mm',
-    'h:mm:ss A',
-    'h:mm A',
-  ],
-  
-  // All common formats
-  ALL: [
-    'YYYY-MM-DD',
-    'YYYY-MM-DDTHH:mm:ss',
-    'YYYY-MM-DDTHH:mm:ss.sssZ',
-    'YYYY-MM-DDTHH:mm:ssZ',
-    'MM/DD/YYYY',
-    'M/D/YYYY',
-    'MM/DD/YY',
-    'M/D/YY',
-    'MM-DD-YYYY',
-    'M-D-YYYY',
-    'DD/MM/YYYY',
-    'D/M/YYYY',
-    'DD/MM/YY',
-    'D/M/YY',
-    'DD-MM-YYYY',
-    'D-M-YYYY',
-    'DD.MM.YYYY',
-    'D.M.YYYY',
-    'YYYY/MM/DD',
-    'YYYY.MM.DD',
-    'DD MMM YYYY',
-    'DD MMMM YYYY',
-    'MMM DD, YYYY',
-    'MMMM DD, YYYY',
-    'YYYY MMM DD',
-    'YYYY MMMM DD',
-    'HH:mm:ss',
-    'HH:mm',
-    'h:mm:ss A',
-    'h:mm A',
-    'MM/DD/YYYY HH:mm:ss',
-    'DD/MM/YYYY HH:mm:ss',
-    'YYYY-MM-DD HH:mm:ss',
-    'MM/DD/YYYY h:mm:ss A',
-    'DD/MM/YYYY h:mm:ss A',
-  ]
-} as const;
-
-/**
- * Flexible CSV import utility that automatically maps CSV columns to target fields
- * 
- * @param csvData - Array of CSV row objects
- * @param targetFields - Array of target field names to map to
- * @param options - Optional configuration for column mappings and parsing
- * @returns Array of transformed data objects
- * 
- * @example
- * ```typescript
- * const csvData = [
- *   { 'Meal code': 'PTRY', 'Meal type': 'Pantry', 'Meal date': '26/9/2025' },
- *   { 'Meal code': '26D', 'Meal type': 'Dinner', 'Meal date': '26/9/2025' }
- * ];
- * 
- * const transformed = flexibleImport(csvData, ['meal_code', 'mealtype_name', 'meal_date'], {
- *   columnMappings: {
- *     meal_code: ['Meal code', 'meal_code', 'code'],
- *     mealtype_name: ['Meal type', 'mealtype_name', 'type'],
- *     meal_date: ['Meal date', 'meal_date', 'date']
- *   }
- * });
- * ```
- */
-export function flexibleImport<T = any>(
-  csvData: any[],
-  targetFields: string[],
-  options: ImportOptions = {}
-): {
-  mappedData: T[];
-  mappings: Record<string, string | null>;
-  errors: any[];
-  warnings: any[];
-  stats: {
-    totalRows: number;
-    successfulRows: number;
-    errorRows: number;
-    warningRows: number;
-  };
-} {
-  console.log('🔄 Starting flexible import...');
-  console.log('🔄 Available CSV columns:', Object.keys(csvData[0] || {}));
-  console.log('🔄 Target fields:', targetFields);
-  
-  // Default column mappings
-  const defaultMappings: ColumnMapping = {
-    // Common field mappings
-    id: ['id', 'ID', 'Id', 'key', 'Key', 'primary_key'],
-    code: ['code', 'Code', 'key', 'Key', 'identifier', 'Identifier'],
-    name: ['name', 'Name', 'title', 'Title', 'label', 'Label'],
-    type: ['type', 'Type', 'category', 'Category', 'kind', 'Kind'],
-    date: ['date', 'Date', 'created_at', 'Created At', 'timestamp', 'Timestamp'],
-    status: ['status', 'Status', 'state', 'State', 'condition', 'Condition'],
-    priority: ['priority', 'Priority', 'pri', 'Pri', 'level', 'Level'],
-    cost: ['cost', 'Cost', 'price', 'Price', 'amount', 'Amount', 'value', 'Value'],
-    tags: ['tags', 'Tags', 'tag', 'Tag', 'categories', 'Categories', 'labels', 'Labels'],
-    description: ['description', 'Description', 'desc', 'Desc', 'details', 'Details'],
-    email: ['email', 'Email', 'e-mail', 'E-mail', 'email_address'],
-    phone: ['phone', 'Phone', 'telephone', 'Telephone', 'mobile', 'Mobile'],
-    address: ['address', 'Address', 'location', 'Location', 'addr', 'Addr']
-  };
-  
-  const columnMappings = { ...defaultMappings, ...options.columnMappings };
-  
-  // Function to find the best matching column name
-  const findColumn = (targetField: string): string | null => {
-    const possibleNames = columnMappings[targetField] || [targetField];
-    const csvColumns = Object.keys(csvData[0] || {});
-    
-    for (const possibleName of possibleNames) {
-      const found = csvColumns.find(col => 
-        col.toLowerCase() === possibleName.toLowerCase() ||
-        col.toLowerCase().includes(possibleName.toLowerCase()) ||
-        possibleName.toLowerCase().includes(col.toLowerCase())
-      );
-      if (found) {
-        console.log(`✅ Mapped ${targetField} -> ${found}`);
-        return found;
-      }
-    }
-    console.log(`❌ No mapping found for ${targetField}`);
-    return null;
-  };
-  
-  // Find all column mappings
-  const mappings: Record<string, string | null> = {};
-  targetFields.forEach(field => {
-    mappings[field] = findColumn(field);
-  });
-  
-  console.log('🔄 Column mappings:', mappings);
-  
-  // Enhanced date parsing with multiple format support
-  const parseDate = (dateStr: string, fieldName?: string): Date | null => {
-    if (!dateStr || typeof dateStr !== 'string') return null;
-    
-    const trimmedDate = dateStr.trim();
-    if (!trimmedDate) return null;
-    
-    // Try common date patterns first
-    const patterns = [
-      // ISO formats
-      { pattern: /^(\d{4})-(\d{1,2})-(\d{1,2})T(\d{1,2}):(\d{1,2}):(\d{1,2})/, type: 'iso-time' },
-      { pattern: /^(\d{4})-(\d{1,2})-(\d{1,2})T(\d{1,2}):(\d{1,2}):(\d{1,2})\.(\d{3})Z?$/, type: 'iso-time-ms' },
-      { pattern: /^(\d{4})-(\d{1,2})-(\d{1,2})$/, type: 'iso' },
-      
-      // US formats
-      { pattern: /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/, type: 'us-4' },
-      { pattern: /^(\d{1,2})\/(\d{1,2})\/(\d{2})$/, type: 'us-2' },
-      { pattern: /^(\d{1,2})-(\d{1,2})-(\d{4})$/, type: 'us-dash-4' },
-      
-      // European formats
-      { pattern: /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/, type: 'eu-4' },
-      { pattern: /^(\d{1,2})\/(\d{1,2})\/(\d{2})$/, type: 'eu-2' },
-      { pattern: /^(\d{1,2})-(\d{1,2})-(\d{4})$/, type: 'eu-dash-4' },
-      { pattern: /^(\d{1,2})\.(\d{1,2})\.(\d{4})$/, type: 'eu-dot-4' },
-      
-      // Natural language formats
-      { pattern: /^(\d{1,2})\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{4})$/i, type: 'natural-dd-mmm-yyyy' },
-      { pattern: /^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{1,2}),?\s+(\d{4})$/i, type: 'natural-mmm-dd-yyyy' },
-      { pattern: /^(\d{1,2})\s+(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{4})$/i, type: 'natural-dd-mmmm-yyyy' },
-      { pattern: /^(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{1,2}),?\s+(\d{4})$/i, type: 'natural-mmmm-dd-yyyy' },
-    ];
-    
-    // Month name mappings
-    const monthNames: Record<string, number> = {
-      'jan': 1, 'feb': 2, 'mar': 3, 'apr': 4, 'may': 5, 'jun': 6,
-      'jul': 7, 'aug': 8, 'sep': 9, 'oct': 10, 'nov': 11, 'dec': 12,
-      'january': 1, 'february': 2, 'march': 3, 'april': 4, 'june': 6,
-      'july': 7, 'august': 8, 'september': 9, 'october': 10, 'november': 11, 'december': 12
-    };
-    
-    for (const { pattern, type } of patterns) {
-      const match = trimmedDate.match(pattern);
-      if (match) {
-        try {
-          let year, month, day, hour = 0, minute = 0, second = 0;
-          
-          switch (type) {
-            case 'iso-time':
-              [, year, month, day, hour, minute, second] = match.map(Number);
-              break;
-            case 'iso-time-ms':
-              [, year, month, day, hour, minute, second] = match.map(Number);
-              break;
-            case 'iso':
-              [, year, month, day] = match.map(Number);
-              break;
-            case 'us-4':
-            case 'us-dash-4':
-              [, month, day, year] = match.map(Number);
-              break;
-            case 'us-2':
-              [, month, day, year] = match.map(Number);
-              year = year < 50 ? 2000 + year : 1900 + year;
-              break;
-            case 'eu-4':
-            case 'eu-dash-4':
-            case 'eu-dot-4':
-              [, day, month, year] = match.map(Number);
-              break;
-            case 'eu-2':
-              [, day, month, year] = match.map(Number);
-              year = year < 50 ? 2000 + year : 1900 + year;
-              break;
-            case 'natural-dd-mmm-yyyy':
-            case 'natural-dd-mmmm-yyyy':
-              [, day, , year] = match;
-              month = monthNames[match[2].toLowerCase()];
-              day = parseInt(day);
-              year = parseInt(year);
-              break;
-            case 'natural-mmm-dd-yyyy':
-            case 'natural-mmmm-dd-yyyy':
-              [, , day, year] = match;
-              month = monthNames[match[1].toLowerCase()];
-              day = parseInt(day);
-              year = parseInt(year);
-              break;
-            default:
-              continue;
-          }
-          
-          const date = new Date(year, month - 1, day, hour, minute, second);
-          if (!isNaN(date.getTime())) {
-            return date;
-          }
-        } catch (error) {
-          continue;
-        }
-      }
-    }
-    
-    // Fallback to native Date parsing
-    const nativeDate = new Date(trimmedDate);
-    if (!isNaN(nativeDate.getTime())) {
-      return nativeDate;
-    }
-    
-    return null;
-  };
-  
-  
-  // Parse different data types
-  const parseValue = (value: any, fieldName: string): any => {
-    if (value === null || value === undefined || value === '') {
-      return options.defaultValues?.[fieldName] || '';
-    }
-    
-    // Auto-detect and parse different data types
-    if (typeof value === 'string') {
-      // Try to parse as date first (for fields that might contain dates)
-      if (fieldName.toLowerCase().includes('date') || fieldName.toLowerCase().includes('time')) {
-        const dateValue = parseDate(value, fieldName);
-        if (dateValue) {
-          // Return ISO string for consistent date handling
-          return dateValue.toISOString();
-        }
-      }
-      
-      // Try to parse as boolean
-      if (value.toLowerCase() === 'true') return true;
-      if (value.toLowerCase() === 'false') return false;
-      
-      // Try to parse as array (comma-separated)
-      if (value.includes(',') && (fieldName.toLowerCase().includes('tag') || fieldName.toLowerCase().includes('category'))) {
-        return value.split(',').map((item: string) => item.trim()).filter((item: string) => item);
-      }
-      
-      // Try to parse as number (only if not a date field)
-      if (!fieldName.toLowerCase().includes('date') && !fieldName.toLowerCase().includes('time')) {
-        const numValue = parseFloat(value);
-        if (!isNaN(numValue) && isFinite(numValue)) {
-          return numValue;
-        }
-      }
-    }
-    
-    return value;
-  };
-  
-  const mappedData = csvData.map((row, index) => {
-    console.log(`🔄 Processing row ${index + 1}:`, row);
-    
-    const transformedRow: any = {};
-    
-    targetFields.forEach(field => {
-      const sourceColumn = mappings[field];
-      if (sourceColumn && row[sourceColumn] !== undefined) {
-        transformedRow[field] = parseValue(row[sourceColumn], field);
-      } else {
-        transformedRow[field] = options.defaultValues?.[field] || '';
-      }
-    });
-    
-    console.log(`🔄 Transformed row ${index + 1}:`, transformedRow);
-    return transformedRow;
-  });
-
-  // Validation and error handling
-  const validationErrors: any[] = [];
-  const validationWarnings: any[] = [];
-
-  return {
-    mappedData,
-    mappings,
-    errors: validationErrors,
-    warnings: validationWarnings,
-    stats: {
-      totalRows: csvData.length,
-      successfulRows: mappedData.length,
-      errorRows: validationErrors.length,
-      warningRows: validationWarnings.length,
-    }
-  };
-}
-
-/**
- * Predefined column mappings for common data table types
- */
-export const commonMappings = {
-  meal: {
-    meal_code: ['Meal code', 'meal_code', 'code', 'id'],
-    mealtype_name: ['Meal type', 'mealtype_name', 'type', 'meal_type'],
-    meal_date: ['Meal date', 'meal_date', 'date'],
-    meal_collectiondate: ['Collection date', 'meal_collectiondate', 'collection_date', 'collect_date'],
-    status: ['status', 'Status', 'state', 'State'],
-    priority: ['priority', 'Priority', 'pri', 'Pri'],
-    cost: ['cost', 'Cost', 'price', 'Price', 'amount', 'Amount'],
-    tags: ['tags', 'Tags', 'tag', 'Tag', 'categories', 'Categories']
-  },
-  
-  user: {
-    id: ['id', 'ID', 'user_id', 'User ID'],
-    name: ['name', 'Name', 'full_name', 'Full Name', 'username', 'Username'],
-    email: ['email', 'Email', 'e-mail', 'E-mail'],
-    phone: ['phone', 'Phone', 'telephone', 'Telephone'],
-    status: ['status', 'Status', 'state', 'State'],
-    role: ['role', 'Role', 'user_role', 'User Role'],
-    created_at: ['created_at', 'Created At', 'created', 'Created', 'date_created']
-  },
-  
-  event: {
-    id: ['id', 'ID', 'event_id', 'Event ID'],
-    name: ['name', 'Name', 'event_name', 'Event Name', 'title', 'Title'],
-    date: ['date', 'Date', 'event_date', 'Event Date', 'start_date', 'Start Date'],
-    location: ['location', 'Location', 'venue', 'Venue', 'place', 'Place'],
-    status: ['status', 'Status', 'state', 'State'],
-    description: ['description', 'Description', 'desc', 'Desc', 'details', 'Details']
-  }
-};
-
-/**
- * Helper function to create import options with predefined date format sets
- */
-export function createImportOptions(options: Partial<ImportOptions> = {}): ImportOptions {
-  return {
-    dateFormats: DATE_FORMAT_SETS.ALL,
-    strictDateParsing: false,
-    ...options,
-  };
-}
-
-/**
- * Helper function to create import options for specific regions
- */
-export function createRegionalImportOptions(region: 'US' | 'EUROPEAN' | 'ISO' | 'NATURAL' | 'ALL', options: Partial<ImportOptions> = {}): ImportOptions {
-  return {
-    dateFormats: DATE_FORMAT_SETS[region],
-    strictDateParsing: false,
-    ...options,
-  };
-}
-
-/**
- * Helper function to test if a string can be parsed as a date
- */
-export function testDateParsing(dateStr: string, formats?: string[]): { success: boolean; parsedDate?: Date; matchedFormat?: string } {
-  if (!dateStr || typeof dateStr !== 'string') {
-    return { success: false };
-  }
-  
-  const testFormats = formats || DATE_FORMAT_SETS.ALL;
-  
-  for (const format of testFormats) {
-    // This is a simplified version of the parseDateWithFormat function
-    // In a real implementation, you'd want to reuse the actual parsing logic
-    try {
-      const date = new Date(dateStr);
-      if (!isNaN(date.getTime())) {
-        return { success: true, parsedDate: date, matchedFormat: 'native' };
-      }
-    } catch (error) {
-      // Continue to next format
-    }
-  }
-  
-  return { success: false };
-}
-
-/**
- * Helper function to get suggested date formats based on sample data
- */
-export function suggestDateFormats(sampleDates: string[]): string[] {
-  const suggestions: string[] = [];
-  
-  for (const dateStr of sampleDates) {
-    if (!dateStr || typeof dateStr !== 'string') continue;
-    
-    // Check for common patterns
-    if (dateStr.includes('/')) {
-      if (dateStr.match(/^\d{1,2}\/\d{1,2}\/\d{4}$/)) {
-        suggestions.push('MM/DD/YYYY', 'DD/MM/YYYY');
-      } else if (dateStr.match(/^\d{1,2}\/\d{1,2}\/\d{2}$/)) {
-        suggestions.push('MM/DD/YY', 'DD/MM/YY');
-      }
-    } else if (dateStr.includes('-')) {
-      if (dateStr.match(/^\d{4}-\d{1,2}-\d{1,2}$/)) {
-        suggestions.push('YYYY-MM-DD');
-      }
-    } else if (dateStr.includes('.')) {
-      if (dateStr.match(/^\d{1,2}\.\d{1,2}\.\d{4}$/)) {
-        suggestions.push('DD.MM.YYYY', 'MM.DD.YYYY');
-      }
-    } else if (dateStr.match(/^\d{1,2}\s+\w+\s+\d{4}$/)) {
-      suggestions.push('DD MMM YYYY', 'MMM DD, YYYY');
-    }
-  }
-  
-  // Remove duplicates and return
-  return [...new Set(suggestions)];
-}

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

@@ -1,151 +0,0 @@
-/**
- * @file Hierarchical Sorting Utilities
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/hierarchicalSorting
- * @since 0.4.35
- */
-
-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
- */
-export function sortHierarchicalData<TData extends HierarchicalDataRow>(
-  data: TData[],
-  sorting: SortingState
-): TData[] {
-  if (sorting.length === 0) {
-    return data;
-  }
-
-  const [sortConfig] = sorting;
-  const { id: columnId, desc } = sortConfig;
-
-  // Group data by parent
-  const parentGroups = new Map<string, { parent: TData; children: TData[] }>();
-  
-  data.forEach(row => {
-    if (row.isParent) {
-      parentGroups.set(row.id, { parent: row, children: [] });
-    } else if (row.parentId) {
-      const group = parentGroups.get(row.parentId);
-      if (group) {
-        group.children.push(row);
-      }
-    }
-  });
-
-  // Sort children within each parent group
-  const sortedGroups = Array.from(parentGroups.values()).map(group => {
-    const sortedChildren = [...group.children].sort((a, b) => {
-      const aValue = getSortValue(a, columnId);
-      const bValue = getSortValue(b, columnId);
-      
-      if (aValue === bValue) return 0;
-      
-      const comparison = compareValues(aValue, bValue);
-      return desc ? -comparison : comparison;
-    });
-
-    return {
-      parent: group.parent,
-      children: sortedChildren
-    };
-  });
-
-  // Reconstruct the sorted data maintaining parent-child order
-  const sortedData: TData[] = [];
-  
-  sortedGroups.forEach(group => {
-    sortedData.push(group.parent);
-    sortedData.push(...group.children);
-  });
-
-  return sortedData;
-}
-
-/**
- * Gets the sort value for a row and column
- */
-function getSortValue<TData extends HierarchicalDataRow>(
-  row: TData, 
-  columnId: string
-): any {
-  // Handle nested property access (e.g., "user.name")
-  const keys = columnId.split('.');
-  let value: any = row;
-  
-  for (const key of keys) {
-    if (value && typeof value === 'object' && key in value) {
-      value = value[key];
-    } else {
-      return null;
-    }
-  }
-  
-  return value;
-}
-
-/**
- * Compares two values for sorting
- */
-function compareValues(a: any, b: any): number {
-  // Handle null/undefined values
-  if (a == null && b == null) return 0;
-  if (a == null) return -1;
-  if (b == null) return 1;
-
-  // Handle numbers
-  if (typeof a === 'number' && typeof b === 'number') {
-    return a - b;
-  }
-
-  // Handle dates
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() - b.getTime();
-  }
-
-  // Handle strings (case-insensitive)
-  const aStr = String(a).toLowerCase();
-  const bStr = String(b).toLowerCase();
-  
-  if (aStr < bStr) return -1;
-  if (aStr > bStr) return 1;
-  return 0;
-}
-
-/**
- * Determines if a column should be sortable in hierarchical mode
- * Child-only columns should not affect parent row order
- */
-export function isHierarchicalSortableColumn<TData extends HierarchicalDataRow>(
-  columnId: string,
-  columns: any[]
-): boolean {
-  const column = columns.find(col => col.id === columnId || col.accessorKey === columnId);
-  
-  if (!column) return true;
-  
-  // If column is hidden for parent rows, it should only sort children within parents
-  return !column.hideForParent;
-}
-
-/**
- * Gets the effective sorting configuration for hierarchical data
- * Returns null if the column should not sort parent rows
- */
-export function getHierarchicalSortConfig(
-  sorting: SortingState,
-  columns: any[]
-): SortingState {
-  if (sorting.length === 0) return sorting;
-  
-  const [sortConfig] = sorting;
-  const { id: columnId } = sortConfig;
-  
-  // If this is a child-only column, we still want to sort but only within parent groups
-  // The main sorting logic will handle this appropriately
-  return sorting;
-}