@jmruthers/pace-core 0.6.9 → 0.6.11

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

@@ -10,6 +10,7 @@
 
 import { createLogger } from '../../../utils/core/logger';
 import type { CellValue } from '../types';
+import { parseImportValue } from './importValueParser';
 
 /**
  * Column mapping interface for CSV import.
@@ -178,36 +179,6 @@ export interface ImportWarning {
   message: string;
 }
 
-/**
- * Sanitizes a string value by removing or escaping dangerous characters
- */
-function sanitizeString(value: string, options: ImportOptions): string {
-  const maxLength = options.maxStringLength || 10000;
-  let sanitized = value;
-  
-  // Truncate to max length
-  if (sanitized.length > maxLength) {
-    sanitized = sanitized.substring(0, maxLength);
-  }
-  
-  // Remove control characters if not allowed
-  if (!options.allowControlChars) {
-    // Keep tabs, newlines, carriage returns
-    sanitized = sanitized.replace(/[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F]/g, '');
-  }
-  
-  // Remove null bytes
-  sanitized = sanitized.replace(/\0/g, '');
-  
-  // Remove SQL injection attempts
-  sanitized = sanitized.replace(/['";]/g, (char) => {
-    // Escape quotes and semicolons
-    return char === '"' ? '"' : char === "'" ? ''' : ';';
-  });
-  
-  return sanitized;
-}
-
 /**
  * Validates a value against schema rules
  */
@@ -374,161 +345,7 @@ export function flexibleImport<T extends Record<string, unknown>>(
   targetFields.forEach(field => {
     mappings[field] = findColumn(field);
   });
-  
-  // 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: unknown, fieldName: string): unknown => {
-    if (value === null || value === undefined || value === '') {
-      return options.defaultValues?.[fieldName] || '';
-    }
-    
-    // Auto-detect and parse different data types
-    if (typeof value === 'string') {
-      // Sanitize string values
-      const sanitized = sanitizeString(value, options);
-      
-      // Try to parse as date first (for fields that might contain dates)
-      if (fieldName.toLowerCase().includes('date') || fieldName.toLowerCase().includes('time')) {
-        const dateValue = parseDate(sanitized, fieldName);
-        if (dateValue) {
-          // Return ISO string for consistent date handling
-          return dateValue.toISOString();
-        }
-      }
-      
-      // Try to parse as boolean
-      if (sanitized.toLowerCase() === 'true') return true;
-      if (sanitized.toLowerCase() === 'false') return false;
-      
-      // Try to parse as array (comma-separated)
-      if (sanitized.includes(',') && (fieldName.toLowerCase().includes('tag') || fieldName.toLowerCase().includes('category'))) {
-        return sanitized.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(sanitized);
-        if (!isNaN(numValue) && isFinite(numValue)) {
-          return numValue;
-        }
-      }
-      
-      return sanitized;
-    }
-    
-    return value;
-  };
-  
+
   const validationErrors: ImportError[] = [];
   const validationWarnings: ImportWarning[] = [];
   const mappedData: T[] = [];
@@ -544,7 +361,7 @@ export function flexibleImport<T extends Record<string, unknown>>(
       let value: unknown;
       
       if (sourceColumn && row[sourceColumn] !== undefined) {
-        value = parseValue(row[sourceColumn], field);
+        value = parseImportValue(row[sourceColumn], field, options);
       } else {
         value = options.defaultValues?.[field] || '';
       }

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

@@ -0,0 +1,235 @@
+/**
+ * @file Unit Tests for Hierarchical Sorting Utilities
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Utils
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  sortHierarchicalDataByStructure,
+  sortHierarchicalDataWithSorting,
+  isHierarchicalSortableColumn,
+  getHierarchicalSortConfig
+} from './hierarchicalSorting';
+import type { HierarchicalDataRow } from '../types';
+import type { SortingState } from '@tanstack/react-table';
+
+interface TestRow extends HierarchicalDataRow {
+  name: string;
+  value: number;
+  date: Date;
+}
+
+describe('[unit] hierarchicalSorting', () => {
+  const createMockData = (): TestRow[] => [
+    { id: '1', name: 'Parent 1', value: 10, date: new Date('2023-01-01'), isParent: true, parentId: null },
+    { id: '1-1', name: 'Child A', value: 5, date: new Date('2023-01-05'), isParent: false, parentId: '1' },
+    { id: '1-2', name: 'Child B', value: 15, date: new Date('2023-01-03'), isParent: false, parentId: '1' },
+    { id: '2', name: 'Parent 2', value: 20, date: new Date('2023-01-02'), isParent: true, parentId: null },
+    { id: '2-1', name: 'Child C', value: 8, date: new Date('2023-01-06'), isParent: false, parentId: '2' },
+    { id: '3', name: 'Parent 3', value: 5, date: new Date('2023-01-03'), isParent: true, parentId: null },
+  ];
+
+  describe('sortHierarchicalDataByStructure', () => {
+    it('sorts data with parents before children', () => {
+      const data = createMockData();
+      const sorted = sortHierarchicalDataByStructure(data);
+
+      // First 3 rows should be parents
+      expect(sorted[0].isParent).toBe(true);
+      expect(sorted[1].isParent).toBe(true);
+      expect(sorted[2].isParent).toBe(true);
+      
+      // All children come after parents
+      const parentCount = sorted.filter(r => r.isParent).length;
+      expect(parentCount).toBe(3);
+      const childCount = sorted.filter(r => !r.isParent).length;
+      expect(childCount).toBe(3);
+    });
+
+    it('maintains all rows in output', () => {
+      const data = createMockData();
+      const sorted = sortHierarchicalDataByStructure(data);
+
+      expect(sorted.length).toBe(data.length);
+      
+      const sortedIds = sorted.map(r => r.id);
+      const originalIds = data.map(r => r.id);
+      
+      expect(sortedIds.sort()).toEqual(originalIds.sort());
+    });
+
+    it('handles empty data array', () => {
+      const sorted = sortHierarchicalDataByStructure([]);
+      expect(sorted).toEqual([]);
+    });
+
+    it('handles data with only parents', () => {
+      const data = createMockData().filter(r => r.isParent);
+      const sorted = sortHierarchicalDataByStructure(data);
+      
+      expect(sorted.length).toBe(3);
+      expect(sorted.every(r => r.isParent)).toBe(true);
+    });
+  });
+
+  describe('sortHierarchicalDataWithSorting', () => {
+    it('returns original data when no sorting provided', () => {
+      const data = createMockData();
+      const sorted = sortHierarchicalDataWithSorting(data, []);
+      
+      expect(sorted.map(r => r.id)).toEqual(data.map(r => r.id));
+    });
+
+    it('sorts children within parent groups by name ascending', () => {
+      const data = createMockData();
+      const sorting: SortingState = [{ id: 'name', desc: false }];
+      
+      const sorted = sortHierarchicalDataWithSorting(data, sorting);
+      
+      // Parent 1 with sorted children
+      const parent1Index = sorted.findIndex(r => r.id === '1');
+      const parent1Children = sorted.slice(parent1Index + 1, parent1Index + 3);
+      
+      expect(parent1Children[0].name).toBe('Child A');
+      expect(parent1Children[1].name).toBe('Child B');
+    });
+
+    it('sorts children within parent groups by value descending', () => {
+      const data = createMockData();
+      const sorting: SortingState = [{ id: 'value', desc: true }];
+      
+      const sorted = sortHierarchicalDataWithSorting(data, sorting);
+      
+      // Parent 1 with sorted children (desc)
+      const parent1Index = sorted.findIndex(r => r.id === '1');
+      const parent1Children = sorted.slice(parent1Index + 1, parent1Index + 3);
+      
+      expect(parent1Children[0].value).toBe(15);
+      expect(parent1Children[1].value).toBe(5);
+    });
+
+    it('preserves parent-child relationships', () => {
+      const data = createMockData();
+      const sorting: SortingState = [{ id: 'name', desc: false }];
+      
+      const sorted = sortHierarchicalDataWithSorting(data, sorting);
+      
+      // Parent 1's children should come after Parent 1
+      const parent1Index = sorted.findIndex(r => r.id === '1');
+      const child1Index = sorted.findIndex(r => r.id === '1-1');
+      const child2Index = sorted.findIndex(r => r.id === '1-2');
+      
+      expect(child1Index).toBeGreaterThan(parent1Index);
+      expect(child2Index).toBeGreaterThan(parent1Index);
+    });
+
+    it('handles null values in sorting', () => {
+      const dataWithNull: TestRow[] = [
+        { id: '1', name: 'Parent 1', value: null as any, date: new Date(), isParent: true, parentId: null },
+        { id: '1-1', name: 'Child A', value: null as any, date: new Date(), isParent: false, parentId: '1' },
+        { id: '1-2', name: 'Child B', value: 10, date: new Date(), isParent: false, parentId: '1' },
+      ];
+      
+      const sorting: SortingState = [{ id: 'value', desc: false }];
+      const sorted = sortHierarchicalDataWithSorting(dataWithNull, sorting);
+      
+      expect(sorted.length).toBeGreaterThan(0);
+      // Null values should sort first (because null < any)
+      expect(sorted[0].value).toBeNull();
+    });
+
+    it('handles nested property access', () => {
+      const data = [
+        { 
+          id: '1', 
+          name: 'Parent 1', 
+          value: 10, 
+          date: new Date(),
+          isParent: true, 
+          parentId: null,
+          nested: { prop: 'B' }
+        } as any,
+        { 
+          id: '1-1', 
+          name: 'Child A', 
+          value: 5, 
+          date: new Date(),
+          isParent: false, 
+          parentId: '1',
+          nested: { prop: 'A' }
+        } as any,
+      ];
+      
+      const sorting: SortingState = [{ id: 'nested.prop', desc: false }];
+      const sorted = sortHierarchicalDataWithSorting(data, sorting);
+      
+      expect(sorted.length).toBe(2);
+      expect(sorted[1].id).toBe('1-1'); // Child A sorted first
+    });
+
+    it('handles missing column property gracefully', () => {
+      const data = createMockData();
+      const sorting: SortingState = [{ id: 'nonExistent', desc: false }];
+      
+      // Should not crash and maintain all rows
+      const sorted = sortHierarchicalDataWithSorting(data, sorting);
+      
+      expect(sorted.length).toBe(data.length);
+      // Parent-child relationships should be preserved
+      const parent1Index = sorted.findIndex(r => r.id === '1');
+      const child1Index = sorted.findIndex(r => r.id === '1-1');
+      expect(child1Index).toBeGreaterThan(parent1Index);
+    });
+
+    it('handles date sorting', () => {
+      const data = createMockData();
+      const sorting: SortingState = [{ id: 'date', desc: false }];
+      
+      const sorted = sortHierarchicalDataWithSorting(data, sorting);
+      
+      const parent1Index = sorted.findIndex(r => r.id === '1');
+      const parent1Children = sorted.slice(parent1Index + 1, parent1Index + 3);
+      
+      // Should sort by date ascending
+      expect(parent1Children[0].date.getTime()).toBeLessThan(parent1Children[1].date.getTime());
+    });
+  });
+
+  describe('isHierarchicalSortableColumn', () => {
+    const mockColumns = [
+      { id: 'name', accessorKey: 'name', hideForParent: false },
+      { id: 'value', accessorKey: 'value', hideForParent: true },
+      { id: 'date', accessorKey: 'date' },
+    ];
+
+    it('returns true for normal sortable columns', () => {
+      expect(isHierarchicalSortableColumn('name', mockColumns)).toBe(true);
+      expect(isHierarchicalSortableColumn('date', mockColumns)).toBe(true);
+    });
+
+    it('returns false for parent-hidden columns when specified', () => {
+      expect(isHierarchicalSortableColumn('value', mockColumns)).toBe(false);
+    });
+
+    it('returns true for non-existent columns', () => {
+      expect(isHierarchicalSortableColumn('nonExistent', mockColumns)).toBe(true);
+    });
+  });
+
+  describe('getHierarchicalSortConfig', () => {
+    it('returns original sorting state unchanged', () => {
+      const sorting: SortingState = [{ id: 'name', desc: false }];
+      const config = getHierarchicalSortConfig(sorting, []);
+      
+      expect(config).toEqual(sorting);
+    });
+
+    it('returns empty array when no sorting provided', () => {
+      const config = getHierarchicalSortConfig([], []);
+      
+      expect(config).toEqual([]);
+    });
+  });
+});
+

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

@@ -167,7 +167,7 @@ function compareValues(a: unknown, b: unknown): number {
  * 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>(
+export function isHierarchicalSortableColumn(
   columnId: string,
   columns: Array<{ id?: string; accessorKey?: string; hideForParent?: boolean }>
 ): boolean {
@@ -185,12 +185,12 @@ export function isHierarchicalSortableColumn<TData extends HierarchicalDataRow>(
  */
 export function getHierarchicalSortConfig(
   sorting: SortingState,
-  columns: Array<{ id?: string; accessorKey?: string; hideForParent?: boolean }>
+  _columns: Array<{ id?: string; accessorKey?: string; hideForParent?: boolean }>
 ): SortingState {
   if (sorting.length === 0) return sorting;
   
   const [sortConfig] = sorting;
-  const { id: columnId } = sortConfig;
+  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