@jmruthers/pace-core 0.6.10 → 0.6.11

package/src/components/DataTable/ui/toolbar/GroupingDropdown.tsx

@@ -0,0 +1,107 @@
+import React from 'react';
+import { Button } from '../../../Button/Button';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+} from '../../../Select/Select';
+import { Group } from 'lucide-react';
+import type { DataTableColumn, DataRecord, SimpleColumn } from '../../types';
+
+/**
+ * Props for the GroupingDropdown component.
+ * @template TData - The type of data records in the table
+ */
+interface GroupingDropdownProps<TData extends DataRecord = DataRecord> {
+  columns: (DataTableColumn<TData> | SimpleColumn<TData>)[];
+  currentGroupBy: string | null;
+  onGroupByChange: (columnId: string | null) => void;
+  className?: string;
+}
+
+/**
+ * Dropdown component for selecting grouping column in DataTable.
+ * Allows users to group table rows by a specific column.
+ * 
+ * @template TData - The type of data records in the table
+ * @param props - Grouping dropdown configuration
+ * @returns The rendered grouping dropdown
+ */
+export function GroupingDropdown<TData extends DataRecord>({ 
+  columns, 
+  currentGroupBy, 
+  onGroupByChange,
+  className
+}: GroupingDropdownProps<TData>) {
+  // Convert columns to a consistent format for grouping
+  const convertedColumns = columns.map(col => {
+    if ('accessorKey' in col && 'header' in col) {
+      // DataTableColumn format
+      return {
+        accessorKey: col.accessorKey,
+        header: typeof col.header === 'string' ? col.header : String(col.accessorKey),
+        enableGrouping: col.enableGrouping || false,
+      };
+    } else if ('key' in col && 'label' in col) {
+      // SimpleColumn format
+      return {
+        accessorKey: col.key,
+        header: col.label,
+        enableGrouping: false, // SimpleColumn doesn't support grouping by default
+      };
+    } else {
+      // Fallback for unknown format
+      return {
+        accessorKey: 'unknown',
+        header: 'Unknown',
+        enableGrouping: false,
+      };
+    }
+  });
+
+  const groupableColumns = convertedColumns.filter(col => col.enableGrouping && col.accessorKey);
+  
+  if (groupableColumns.length === 0) {
+    return null;
+  }
+
+  return (
+    <Select className="w-40">
+      <SelectTrigger asChild>
+        <Button 
+          variant="outline" 
+          className={className || ''}
+        >
+          <Group className="size-4 mr-2 flex-shrink-0" />
+          <span className="truncate">Grouping</span>
+        </Button>
+      </SelectTrigger>
+      <SelectContent>
+        <SelectItem
+          value="no-grouping"
+          onClick={() => onGroupByChange(null)}
+          className={`px-3 py-2 ${!currentGroupBy ? 'bg-main-50' : 'hover:bg-sec-50'}`}
+        >
+          No grouping
+        </SelectItem>
+        {groupableColumns.map((column) => {
+          const columnId = String(column.accessorKey);
+          const isSelected = currentGroupBy === columnId;
+          const displayName = column.header || String(column.accessorKey);
+          
+          return (
+            <SelectItem
+              key={columnId}
+              value={columnId}
+              onClick={() => onGroupByChange(columnId)}
+              className={`px-3 py-2 ${isSelected ? 'bg-main-50' : 'hover:bg-sec-50'}`}
+            >
+              {displayName}
+            </SelectItem>
+          );
+        })}
+      </SelectContent>
+    </Select>
+  );
+}

package/src/components/DataTable/utils/{__tests__/a11yUtils.test.ts → a11yUtils.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file Accessibility Utils Tests
  * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/__tests__
+ * @module Components/DataTable/Utils
  * @since 0.4.0
  */
 
@@ -20,7 +20,7 @@ import {
   announceBulkOperation,
   getAriaSortValue,
   getRowDescription,
-} from '../a11yUtils';
+} from './a11yUtils';
 
 describe('[unit] a11yUtils', () => {
   beforeEach(() => {

package/src/components/DataTable/utils/{__tests__/aggregationUtils.test.ts → aggregationUtils.test.ts}

@@ -1,12 +1,12 @@
 /**
  * @file Unit Tests for Aggregation Utilities
  * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/__tests__
+ * @module Components/DataTable/Utils
  */
 
 import { describe, it, expect } from 'vitest';
-import { sum, average, count, min, max } from '../aggregationUtils';
-import type { DataTableColumn, DataRecord } from '../../types';
+import { sum, average, count, min, max } from './aggregationUtils';
+import type { DataTableColumn, DataRecord } from '../types';
 
 interface TestRow extends DataRecord {
   cost: number;

package/src/components/DataTable/utils/{__tests__/columnUtils.test.ts → columnUtils.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file Column Utils Tests
  * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/__tests__
+ * @module Components/DataTable/Utils
  * @since 0.4.0
  * 
  * Test suite for column utility functions.
@@ -9,7 +9,7 @@
 
 import { describe, it, expect } from 'vitest';
 import React from 'react';
-import { getColumnHeaderText } from '../columnUtils';
+import { getColumnHeaderText } from './columnUtils';
 import type { Column } from '@tanstack/react-table';
 
 const createMockColumn = (overrides: Partial<Column<any, unknown>> = {}): Column<any, unknown> => ({

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

@@ -0,0 +1,74 @@
+/**
+ * @file CSV Parse Utility Tests
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Utils
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseCSVLine, parseCSVToRecords } from './csvParse';
+
+describe('parseCSVLine', () => {
+  it('splits simple comma-separated values', () => {
+    expect(parseCSVLine('a,b,c')).toEqual(['a', 'b', 'c']);
+  });
+
+  it('trims whitespace around values', () => {
+    expect(parseCSVLine(' a , b , c ')).toEqual(['a', 'b', 'c']);
+  });
+
+  it('handles quoted values containing commas', () => {
+    expect(parseCSVLine('"a,b",c,d')).toEqual(['a,b', 'c', 'd']);
+  });
+
+  it('handles single value', () => {
+    expect(parseCSVLine('only')).toEqual(['only']);
+  });
+
+  it('handles empty string', () => {
+    expect(parseCSVLine('')).toEqual(['']);
+  });
+});
+
+describe('parseCSVToRecords', () => {
+  it('parses header and one data row', () => {
+    const csv = 'name,age\nAlice,30';
+    const result = parseCSVToRecords(csv);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({ name: 'Alice', age: '30' });
+  });
+
+  it('parses multiple rows', () => {
+    const csv = 'a,b\n1,2\n3,4';
+    const result = parseCSVToRecords(csv);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({ a: '1', b: '2' });
+    expect(result[1]).toEqual({ a: '3', b: '4' });
+  });
+
+  it('strips quotes from header and values', () => {
+    const csv = '"col1","col2"\n"v1","v2"';
+    const result = parseCSVToRecords(csv);
+    expect(result[0]).toEqual({ col1: 'v1', col2: 'v2' });
+  });
+
+  it('throws when fewer than 2 lines', () => {
+    expect(() => parseCSVToRecords('header only')).toThrow(
+      'CSV must have at least a header row and one data row'
+    );
+    expect(() => parseCSVToRecords('')).toThrow(
+      'CSV must have at least a header row and one data row'
+    );
+  });
+
+  it('handles quoted values with commas in data', () => {
+    const csv = 'name,address\n"Alice","123 Main St, Apt 4"';
+    const result = parseCSVToRecords(csv);
+    expect(result[0]).toEqual({ name: 'Alice', address: '123 Main St, Apt 4' });
+  });
+
+  it('fills missing columns with empty string', () => {
+    const csv = 'a,b,c\n1,2';
+    const result = parseCSVToRecords(csv);
+    expect(result[0]).toEqual({ a: '1', b: '2', c: '' });
+  });
+});

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

@@ -0,0 +1,65 @@
+/**
+ * @file CSV Parse Utility
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Utils
+ *
+ * Simple CSV parsing for ImportModal: parse a single line (handles quoted commas)
+ * and parse full CSV text into records (header row + data rows).
+ */
+
+/**
+ * Parse a single CSV line into an array of values.
+ * Handles quoted commas (values inside double quotes can contain commas).
+ *
+ * @param line - Raw CSV line
+ * @returns Array of trimmed string values
+ */
+export function parseCSVLine(line: string): string[] {
+  const result: string[] = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    } else if (char === ',' && !inQuotes) {
+      result.push(current.trim());
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+
+/**
+ * Parse CSV text into an array of record objects.
+ * First line is treated as headers; remaining lines become rows with header keys.
+ *
+ * @param csvText - Full CSV file content
+ * @returns Array of records (objects keyed by header names)
+ * @throws Error if CSV has fewer than 2 lines (header + at least one data row)
+ */
+export function parseCSVToRecords(csvText: string): Array<Record<string, unknown>> {
+  const lines = csvText.split('\n').filter((line) => line.trim());
+
+  if (lines.length < 2) {
+    throw new Error('CSV must have at least a header row and one data row');
+  }
+
+  const headers = parseCSVLine(lines[0]).map((h) => h.replace(/"/g, '').trim());
+
+  const data = lines.slice(1).map((line) => {
+    const values = parseCSVLine(line).map((v) => v.replace(/"/g, '').trim());
+    const row: Record<string, unknown> = {};
+    headers.forEach((header, colIndex) => {
+      row[header] = values[colIndex] ?? '';
+    });
+    return row;
+  });
+
+  return data;
+}

package/src/components/DataTable/utils/{__tests__/errorHandling.test.ts → errorHandling.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file Error Handling Tests
  * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/__tests__
+ * @module Components/DataTable/Utils
  * @since 0.3.0
  * 
  * Tests for error handling stubs. These are minimal implementations
@@ -18,7 +18,7 @@ import {
   safeExecute,
   DEFAULT_FALLBACK_CONFIG,
   type FallbackConfig,
-} from '../errorHandling';
+} from './errorHandling';
 
 describe('[unit] errorHandling', () => {
   describe('DataTableErrorType', () => {

package/src/components/DataTable/utils/{__tests__/exportUtils.test.ts → exportUtils.test.ts}

@@ -1,13 +1,13 @@
 /**
  * @file Export Utils Tests
  * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/__tests__
+ * @module Components/DataTable/Utils
  * @since 0.1.0
  */
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { generateCSVContent, exportToCSV, exportToCSVWithTableRows } from '../exportUtils';
-import type { ExportColumn } from '../exportUtils';
+import { generateCSVContent, exportToCSV, exportToCSVWithTableRows } from './exportUtils';
+import type { ExportColumn } from './exportUtils';
 
 // Mock the logger utility
 const mockLogger = {

package/src/components/DataTable/utils/{__tests__/flexibleImport.test.ts → flexibleImport.test.ts}

@@ -1,11 +1,11 @@
 /**
  * @file Unit Tests for flexibleImport Utility
  * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/__tests__
+ * @module Components/DataTable/Utils
  */
 
 import { describe, it, expect, beforeEach } from 'vitest';
-import { flexibleImport, DATE_FORMAT_SETS, commonMappings, suggestDateFormats } from '../flexibleImport';
+import { flexibleImport, DATE_FORMAT_SETS, commonMappings, suggestDateFormats } from './flexibleImport';
 // ImportOptions removed - not used in tests
 
 describe('[unit] flexibleImport', () => {

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/{__tests__/hierarchicalSorting.test.ts → hierarchicalSorting.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file Unit Tests for Hierarchical Sorting Utilities
  * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/__tests__
+ * @module Components/DataTable/Utils
  */
 
 import { describe, it, expect } from 'vitest';
@@ -10,8 +10,8 @@ import {
   sortHierarchicalDataWithSorting,
   isHierarchicalSortableColumn,
   getHierarchicalSortConfig
-} from '../hierarchicalSorting';
-import type { HierarchicalDataRow } from '../../types';
+} from './hierarchicalSorting';
+import type { HierarchicalDataRow } from '../types';
 import type { SortingState } from '@tanstack/react-table';
 
 interface TestRow extends HierarchicalDataRow {

package/src/components/DataTable/utils/{__tests__/hierarchicalUtils.test.ts → hierarchicalUtils.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file Hierarchical Utils Tests
  * @package @jmruthers/pace-core
- * @module Components/DataTable/Utils/__tests__
+ * @module Components/DataTable/Utils
  * @since 0.4.35
  */
 
@@ -16,8 +16,8 @@ import {
   calculateIndentation,
   calculateAllIndentation,
   createHierarchicalStructure
-} from '../hierarchicalUtils';
-import type { HierarchicalDataRow, DataTableColumn, DataRecord } from '../../types';
+} from './hierarchicalUtils';
+import type { HierarchicalDataRow, DataTableColumn, DataRecord } from '../types';
 
 interface TestHierarchicalData extends HierarchicalDataRow {
   id: string;