@jmruthers/pace-core 0.5.75 → 0.5.76

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

@@ -0,0 +1,247 @@
+/**
+ * @file Unit Tests for Hierarchical Sorting Utilities
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Utils/__tests__
+ */
+
+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].id).toBe('1');
+      expect(sorted[1].id).toBe('2');
+      expect(sorted[2].id).toBe('3');
+      expect(sorted[0].isParent).toBe(true);
+      expect(sorted[1].isParent).toBe(true);
+      expect(sorted[2].isParent).toBe(true);
+    });
+
+    it('includes all children after parents', () => {
+      const data = createMockData();
+      const sorted = sortHierarchicalDataByStructure(data);
+
+      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
+      const sorted = sortHierarchicalDataWithSorting(data, sorting);
+      
+      expect(sorted.length).toBe(data.length);
+    });
+
+    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', () => {
+      const sorting: SortingState = [{ id: 'name', desc: false }];
+      const config = getHierarchicalSortConfig(sorting, []);
+      
+      expect(config).toEqual(sorting);
+    });
+
+    it('returns empty array when no sorting', () => {
+      const config = getHierarchicalSortConfig([], []);
+      
+      expect(config).toEqual([]);
+    });
+
+    it('preserves sorting configuration', () => {
+      const sorting: SortingState = [{ id: 'value', desc: true }];
+      const config = getHierarchicalSortConfig(sorting, []);
+      
+      expect(config[0].id).toBe('value');
+      expect(config[0].desc).toBe(true);
+    });
+  });
+});
+

package/src/components/DataTable/utils/__tests__/hierarchicalUtils.test.ts

@@ -8,14 +8,16 @@
 import { describe, it, expect } from 'vitest';
 import {
   validateHierarchicalData,
-  sortHierarchicalData,
   groupHierarchicalData,
   getRowDepth,
+  calculateAllDepths,
   shouldShowColumnForRow,
   getCellRenderer,
   calculateIndentation,
+  calculateAllIndentation,
   createHierarchicalStructure
 } from '../hierarchicalUtils';
+import { sortHierarchicalDataByStructure } from '../hierarchicalSorting';
 import type { HierarchicalDataRow, DataTableColumn, DataRecord } from '../../types';
 
 interface TestHierarchicalData extends HierarchicalDataRow {
@@ -141,7 +143,7 @@ describe('[unit] sortHierarchicalData', () => {
       { id: 'child2', name: 'Child 2', value: 75, parentId: 'parent1', isParent: false }
     ];
     
-    const result = sortHierarchicalData(unsortedData);
+    const result = sortHierarchicalDataByStructure(unsortedData);
     
     expect(result[0].isParent).toBe(true);
     expect(result[0].id).toBe('parent1');
@@ -150,7 +152,7 @@ describe('[unit] sortHierarchicalData', () => {
   });
 
   it('handles data that is already sorted', () => {
-    const result = sortHierarchicalData(validHierarchicalData);
+    const result = sortHierarchicalDataByStructure(validHierarchicalData);
     
     // The function should maintain the order but group parents before children
     expect(result[0].isParent).toBe(true);
@@ -161,7 +163,7 @@ describe('[unit] sortHierarchicalData', () => {
   });
 
   it('handles empty data array', () => {
-    const result = sortHierarchicalData([]);
+    const result = sortHierarchicalDataByStructure([]);
     
     expect(result).toEqual([]);
   });
@@ -172,7 +174,7 @@ describe('[unit] sortHierarchicalData', () => {
       { id: 'parent2', name: 'Parent 2', value: 200, isParent: true }
     ];
     
-    const result = sortHierarchicalData(parentOnlyData);
+    const result = sortHierarchicalDataByStructure(parentOnlyData);
     
     expect(result).toEqual(parentOnlyData);
   });
@@ -183,7 +185,7 @@ describe('[unit] sortHierarchicalData', () => {
       { id: 'child2', name: 'Child 2', value: 75, parentId: 'parent1', isParent: false }
     ];
     
-    const result = sortHierarchicalData(childOnlyData);
+    const result = sortHierarchicalDataByStructure(childOnlyData);
     
     expect(result).toEqual(childOnlyData);
   });