@jmruthers/pace-core 0.5.181 → 0.5.183

package/src/components/DataTable/hooks/__tests__/useDataTableConfiguration.test.ts

@@ -0,0 +1,124 @@
+/**
+ * @file Unit tests for useDataTableConfiguration
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Hooks/__tests__
+ */
+
+import { renderHook } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import type { ColumnDef } from '@tanstack/react-table';
+import { useDataTableConfiguration } from '../useDataTableConfiguration';
+import type { DataRecord, NormalizedDataTableFeatureConfig } from '../../types';
+import type { TableHandlers, TableStateSnapshot } from '../useTableHandlers';
+
+interface TestRow extends DataRecord {
+  id: string;
+  name: string;
+}
+
+const columns: ColumnDef<TestRow>[] = [
+  { accessorKey: 'name', header: 'Name' },
+  { accessorKey: 'status', header: 'Status' },
+];
+
+const stateSnapshot: TableStateSnapshot<TestRow> = {
+  sorting: [],
+  columnFilters: [],
+  columnVisibility: {},
+  rowSelection: {},
+  grouping: [],
+  expanded: {},
+  pagination: { pageIndex: 0, pageSize: 10 },
+  globalFilter: '',
+  columnOrder: ['status', 'name'],
+};
+
+const handlers: TableHandlers = {
+  onSortingChange: () => {},
+  onColumnFiltersChange: () => {},
+  onColumnVisibilityChange: () => {},
+  onRowSelectionChange: () => {},
+  onGroupingChange: () => {},
+  onExpandedChange: () => {},
+  onPaginationChange: () => {},
+  onColumnOrderChange: () => {},
+};
+
+const baseFeatures: NormalizedDataTableFeatureConfig = {
+  search: false,
+  pagination: true,
+  sorting: true,
+  filtering: true,
+  import: false,
+  export: false,
+  selection: false,
+  creation: false,
+  editing: false,
+  deletion: false,
+  deleteSelected: false,
+  grouping: false,
+  columnVisibility: true,
+  columnReordering: true,
+  hierarchical: false,
+};
+
+describe('useDataTableConfiguration', () => {
+  it('pins selection column to the front of the order when enabled', () => {
+    const { result } = renderHook(() =>
+      useDataTableConfiguration<TestRow>({
+        data: [],
+        columns,
+        stateSnapshot,
+        handlers,
+        features: { ...baseFeatures, selection: true },
+        getRowId: row => row.id,
+        finalPaginationMode: 'client',
+        finalDataCount: 2,
+        pageSize: 10,
+      })
+    );
+
+    expect(result.current.state.columnOrder).toEqual(['select', 'status', 'name']);
+  });
+
+  it('enables manual pagination only when server config is available', () => {
+    const { result } = renderHook(() =>
+      useDataTableConfiguration<TestRow>({
+        data: [],
+        columns,
+        stateSnapshot,
+        handlers,
+        features: baseFeatures,
+        getRowId: row => row.id,
+        finalPaginationMode: 'server',
+        finalDataCount: 100,
+        pageSize: 25,
+        hasServerSideConfig: true,
+      })
+    );
+
+    expect(result.current.manualPagination).toBe(true);
+    expect(result.current.getPaginationRowModel).toBeUndefined();
+    expect(result.current.pageCount).toBe(4);
+  });
+
+  it('keeps client-side pagination when server config is missing', () => {
+    const { result } = renderHook(() =>
+      useDataTableConfiguration<TestRow>({
+        data: [],
+        columns,
+        stateSnapshot,
+        handlers,
+        features: baseFeatures,
+        getRowId: row => row.id,
+        finalPaginationMode: 'server',
+        finalDataCount: 100,
+        pageSize: 25,
+        hasServerSideConfig: false,
+      })
+    );
+
+    expect(result.current.manualPagination).toBe(false);
+    expect(typeof result.current.getPaginationRowModel).toBe('function');
+  });
+});

package/src/components/DataTable/hooks/__tests__/useDataTableDataPipeline.test.ts

@@ -0,0 +1,117 @@
+/**
+ * @file Unit tests for useDataTableDataPipeline
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Hooks/__tests__
+ */
+
+import { renderHook } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useDataTableDataPipeline } from '../useDataTableDataPipeline';
+import { defaultDataTableFeatures, type DataRecord, type NormalizedDataTableFeatureConfig } from '../../types';
+
+const mockValidateHierarchicalData = vi.fn(() => ({ isValid: true, errors: [] as string[] }));
+const mockSortByStructure = vi.fn((rows: unknown[]) => rows);
+const mockSortWithSorting = vi.fn((rows: unknown[], _sorting: unknown) => rows);
+const mockHierarchicalState = vi.fn(() => ({
+  visibleRows: [],
+  toggleRow: vi.fn(),
+}));
+
+vi.mock('../../utils/hierarchicalUtils', () => ({
+  validateHierarchicalData: (...args: unknown[]) => mockValidateHierarchicalData(...args),
+}));
+
+vi.mock('../../utils/hierarchicalSorting', () => ({
+  sortHierarchicalDataByStructure: (...args: unknown[]) => mockSortByStructure(...args),
+  sortHierarchicalDataWithSorting: (...args: unknown[]) => mockSortWithSorting(...args),
+}));
+
+vi.mock('../useHierarchicalState', () => ({
+  useHierarchicalState: (...args: unknown[]) => mockHierarchicalState(...args),
+}));
+
+interface TestRow extends DataRecord {
+  id: string;
+  isParent?: boolean;
+}
+
+const baseFeatures: NormalizedDataTableFeatureConfig = {
+  ...defaultDataTableFeatures,
+  pagination: true,
+};
+
+describe('useDataTableDataPipeline', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockHierarchicalState.mockReturnValue({ visibleRows: [], toggleRow: vi.fn() });
+    mockSortByStructure.mockImplementation(rows => rows);
+    mockSortWithSorting.mockImplementation(rows => rows);
+  });
+
+  it('falls back to client data when server pagination is detected but no server data is present', () => {
+    const data: TestRow[] = [{ id: '1' }, { id: '2' }];
+
+    const { result } = renderHook(() =>
+      useDataTableDataPipeline<TestRow>({
+        data,
+        features: baseFeatures,
+        sorting: [],
+        finalPaginationMode: 'server',
+        serverData: null,
+      })
+    );
+
+    expect(result.current.finalTableData).toEqual(data);
+    expect(result.current.dataCount).toBe(0);
+  });
+
+  it('uses server data and total count when provided', () => {
+    const serverRows: TestRow[] = [{ id: 'server-1' }];
+
+    const { result } = renderHook(() =>
+      useDataTableDataPipeline<TestRow>({
+        data: [],
+        features: baseFeatures,
+        sorting: [],
+        finalPaginationMode: 'server',
+        serverData: { data: serverRows, totalCount: 42, pageIndex: 0, pageSize: 10 },
+      })
+    );
+
+    expect(result.current.finalTableData).toEqual(serverRows);
+    expect(result.current.dataCount).toBe(42);
+  });
+
+  it('validates and sorts hierarchical data when enabled', () => {
+    const structuredRows: TestRow[] = [
+      { id: 'parent', isParent: true },
+      { id: 'child', isParent: false },
+    ];
+
+    mockSortByStructure.mockReturnValue(structuredRows);
+    mockHierarchicalState.mockReturnValue({ visibleRows: structuredRows, toggleRow: vi.fn() });
+    mockSortWithSorting.mockImplementation((_rows, _sorting) => structuredRows.slice().reverse());
+
+    const hierarchicalFeatures: NormalizedDataTableFeatureConfig = {
+      ...baseFeatures,
+      hierarchical: true,
+    };
+
+    const { result } = renderHook(() =>
+      useDataTableDataPipeline<TestRow>({
+        data: structuredRows,
+        features: hierarchicalFeatures,
+        hierarchical: { enabled: true },
+        sorting: [{ id: 'name', desc: false }],
+        finalPaginationMode: 'client',
+        serverData: null,
+      })
+    );
+
+    expect(mockValidateHierarchicalData).toHaveBeenCalled();
+    expect(mockSortByStructure).toHaveBeenCalledWith(structuredRows);
+    expect(mockSortWithSorting).toHaveBeenCalled();
+    expect(result.current.hierarchicalState).toEqual({ visibleRows: structuredRows, toggleRow: expect.any(Function) });
+    expect(result.current.finalTableData).toEqual(structuredRows.slice().reverse());
+  });
+});

package/src/components/DataTable/hooks/__tests__/useDataTablePermissions.test.ts

@@ -0,0 +1,102 @@
+/**
+ * @file Unit tests for useDataTablePermissions
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Hooks/__tests__
+ */
+
+import { renderHook } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useDataTablePermissions } from '../useDataTablePermissions';
+import type { DataTableFeatureConfig } from '../../types';
+
+type CanResult = { can: boolean; isLoading: boolean; error: null };
+
+const mockUseUnifiedAuth = vi.fn(() => ({
+  user: { id: 'user-1' },
+  selectedOrganisation: { id: 'org-1' },
+  selectedEvent: { event_id: 'event-1' },
+  supabase: {},
+}));
+
+const mockUseResolvedScope = vi.fn(() => ({
+  resolvedScope: { organisationId: 'org-1', appId: 'app-1', eventId: 'event-1' },
+  isLoading: false,
+}));
+
+const mockUseCan = vi.fn<(userId: string, scope: unknown, permission: string) => CanResult>();
+
+vi.mock('../../../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuth(),
+  UnifiedAuthProvider: (props: { children: unknown }) => props.children,
+}));
+
+vi.mock('../../../../rbac/hooks', () => ({
+  useResolvedScope: (...args: unknown[]) => mockUseResolvedScope(...args),
+  useCan: (...args: Parameters<typeof mockUseCan>) => mockUseCan(...args),
+}));
+
+vi.mock('../../../../hooks/useToast', () => ({
+  useToast: () => ({
+    toast: vi.fn(),
+  }),
+}));
+
+vi.mock('../../../../utils/core/logger', () => {
+  const mockLoggerInstance = {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  };
+  return {
+    createLogger: () => mockLoggerInstance,
+    logger: mockLoggerInstance,
+  };
+});
+
+describe('useDataTablePermissions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockUseCan.mockImplementation(() => ({ can: false, isLoading: false, error: null }));
+  });
+
+  it('requires either pageId or pageName', () => {
+    expect(() =>
+      renderHook(() => useDataTablePermissions({}, {}))
+    ).toThrow('rbac.pageId or rbac.pageName');
+  });
+
+  it('filters features based on permission results', () => {
+    const featureConfig: DataTableFeatureConfig = {
+      creation: true,
+      editing: true,
+      deletion: true,
+      deleteSelected: true,
+      export: true,
+      import: true,
+    };
+
+    const allowedPermissions = new Set(['read:page.users', 'update:page.users']);
+
+    mockUseCan.mockImplementation((_, scope, permission) => ({
+      can: allowedPermissions.has(permission),
+      isLoading: false,
+      error: null,
+    }));
+
+    const { result } = renderHook(() =>
+      useDataTablePermissions({ pageId: 'users' }, featureConfig)
+    );
+
+    expect(result.current.effectivePageId).toBe('users');
+    expect(result.current.secureFeatures.creation).toBe(false);
+    expect(result.current.secureFeatures.editing).toBe(true);
+    expect(result.current.secureFeatures.deletion).toBe(false);
+    expect(result.current.secureFeatures.deleteSelected).toBe(false);
+    expect(result.current.secureFeatures.export).toBe(true);
+    expect(result.current.secureFeatures.import).toBe(false);
+
+    const scopes = mockUseCan.mock.calls.map(([, scope]) => scope);
+    expect(new Set(scopes).size).toBe(1);
+  });
+});

package/src/components/DataTable/hooks/__tests__/useEffectiveColumnOrder.test.ts

@@ -0,0 +1,53 @@
+/**
+ * @file Unit tests for useEffectiveColumnOrder
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Hooks/__tests__
+ */
+
+import { renderHook } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import type { DataTableColumn, DataRecord } from '../../types';
+import { useEffectiveColumnOrder } from '../useEffectiveColumnOrder';
+
+type TestRow = DataRecord & { id: string; name: string };
+
+const baseColumns: DataTableColumn<TestRow>[] = [
+  { id: 'name', accessorKey: 'name', header: 'Name' },
+  { accessorKey: 'status', header: 'Status' },
+];
+
+describe('useEffectiveColumnOrder', () => {
+  it('derives column order from definitions when no external order is provided', () => {
+    const { result } = renderHook(() =>
+      useEffectiveColumnOrder<TestRow>({
+        columns: baseColumns,
+        selectionEnabled: false,
+      })
+    );
+
+    expect(result.current).toEqual(['name', 'status']);
+  });
+
+  it('respects explicit column order and keeps select column pinned first', () => {
+    const { result } = renderHook(() =>
+      useEffectiveColumnOrder<TestRow>({
+        columns: baseColumns,
+        externalColumnOrder: ['status', 'select', 'name'],
+        selectionEnabled: true,
+      })
+    );
+
+    expect(result.current).toEqual(['select', 'status', 'name']);
+  });
+
+  it('injects selection column when not present in derived order', () => {
+    const { result } = renderHook(() =>
+      useEffectiveColumnOrder<TestRow>({
+        columns: baseColumns,
+        selectionEnabled: true,
+      })
+    );
+
+    expect(result.current).toEqual(['select', 'name', 'status']);
+  });
+});

package/src/components/DataTable/hooks/useColumnOrderPersistence.ts

@@ -31,7 +31,6 @@ export function useColumnOrderPersistence({
     }
 
     // Only load if we have a storage key (either via storageKey prop or tableId)
-    // This maintains backward compatibility with existing tests
     if (!storageKey && !tableId) {
       setIsLoaded(true);
       return;
@@ -57,7 +56,6 @@ export function useColumnOrderPersistence({
     if (!enablePersistence || typeof window === 'undefined') return;
     
     // Only save if we have a storage key (either via storageKey prop or tableId)
-    // This maintains backward compatibility with existing tests
     if (!storageKey && !tableId) return;
 
     try {

package/src/components/DataTable/hooks/useDataTablePermissions.ts

@@ -9,7 +9,7 @@
  */
 
 import { useMemo, useRef } from 'react';
-import { useUnifiedAuth } from '../../../providers/UnifiedAuthProvider';
+import { useUnifiedAuth } from '../../../providers/services/UnifiedAuthProvider';
 import { useCan, useResolvedScope } from '../../../rbac/hooks';
 import { useToast } from '../../../hooks/useToast';
 import { createLogger } from '../../../utils/core/logger';
@@ -18,6 +18,7 @@ import {
   type DataTableFeatureConfig,
   type DataTableRBACConfig,
   type NormalizedDataTableFeatureConfig,
+  type DataRecord,
 } from '../types';
 import type { Permission } from '../../../rbac/types';
 
@@ -34,7 +35,7 @@ export interface UseDataTablePermissionsReturn {
   effectivePageId: string | undefined;
 }
 
-export function useDataTablePermissions<TData extends Record<string, any>>(
+export function useDataTablePermissions<TData extends DataRecord>(
   rbac: DataTableRBACConfig,
   features: DataTableFeatureConfig = {}
 ): UseDataTablePermissionsReturn {
@@ -87,9 +88,9 @@ export function useDataTablePermissions<TData extends Record<string, any>>(
    * 2. Maintain performance
    * 3. Still ensure permissions check against the current scope
    */
-  const stableScopeRef = useRef<{ organisationId: string; appId: string; eventId: string | undefined }>({ 
-    organisationId: '', 
-    appId: '', 
+  const stableScopeRef = useRef<{ organisationId?: string; appId?: string; eventId?: string }>({ 
+    organisationId: undefined, 
+    appId: undefined, 
     eventId: undefined 
   });
 
@@ -108,13 +109,13 @@ export function useDataTablePermissions<TData extends Record<string, any>>(
         stableScopeRef.current.appId !== newScope.appId) {
       stableScopeRef.current = {
         organisationId: newScope.organisationId,
-        appId: newScope.appId || '',
+        appId: newScope.appId,
         eventId: newScope.eventId
       };
     }
   } else if (!rawResolvedScope) {
     // Reset to empty scope when no resolved scope (e.g., user logged out)
-    stableScopeRef.current = { organisationId: '', appId: '', eventId: undefined };
+    stableScopeRef.current = { organisationId: undefined, appId: undefined, eventId: undefined };
   }
 
   const stableScope = stableScopeRef.current;
@@ -136,7 +137,7 @@ export function useDataTablePermissions<TData extends Record<string, any>>(
 
   // Always use a consistent scope object to prevent hooks order violations
   // When scope is loading or invalid, use empty scope which will cause useCan to return false
-  const consistentScope = effectiveScope || { organisationId: '', eventId: undefined, appId: undefined };
+  const consistentScope = effectiveScope || { organisationId: undefined, eventId: undefined, appId: undefined };
 
   const permissions = {
     canRead: useCan(userId, consistentScope, readPermission, effectivePageId, true),

package/src/components/DataTable/types.ts

@@ -335,12 +335,12 @@ export interface DataTableColumn<TData extends DataRecord = DataRecord> extends
    * Receives all rows in the group and returns the aggregated value.
    * If not provided, grouped rows will show empty/undefined for this column.
    */
-  aggregateFn?: (rows: TData[], column: DataTableColumn<TData>) => any;
+  aggregateFn?: (rows: TData[], column: DataTableColumn<TData>) => unknown;
   /**
    * Optional: Custom cell renderer for aggregated values in grouped rows.
    * If not provided, uses the column's regular cell renderer.
    */
-  aggregateCell?: (value: any, rows: TData[], column: DataTableColumn<TData>) => React.ReactNode;
+  aggregateCell?: (value: unknown, rows: TData[], column: DataTableColumn<TData>) => React.ReactNode;
 }
 
 /**
@@ -646,7 +646,7 @@ export interface ExportOptions<TData extends DataRecord> {
   /** Filtered table rows with getValue() method for proper accessorFn evaluation */
   tableRows: Array<{
     original: TData;
-    getValue: (columnId: string) => any;
+    getValue: (columnId: string) => unknown;
     id: string;
   }>;
   /** All column definitions passed to the DataTable */
@@ -654,13 +654,13 @@ export interface ExportOptions<TData extends DataRecord> {
   /** Currently visible columns in the table */
   visibleColumns: DataTableColumn<TData>[];
   /** Mapping of column IDs to TanStack table column instances (for getValue() calls) */
-  columnIdToTableColumn: Map<string, any>;
+  columnIdToTableColumn: Map<string, unknown>;
   /** Raw data array (unfiltered) */
   data: TData[];
   /** Default filename generated from table title */
   filename: string;
   /** TanStack table instance for advanced operations */
-  table: any; // Using any to avoid tight coupling with TanStack types
+  table: unknown; // Using unknown to avoid tight coupling with TanStack types
 }
 
 // ============================================================================

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

@@ -28,7 +28,7 @@ import type { DataTableColumn, DataRecord } from '../types';
 export function sum<TData extends DataRecord = DataRecord>(accessorKey: keyof TData | string) {
   return <TRow extends DataRecord = TData>(rows: TRow[], column: DataTableColumn<TRow>): number => {
     return rows.reduce((total, row) => {
-      const value = (row as any)[accessorKey];
+      const value = row[accessorKey as keyof TRow];
       const numValue = typeof value === 'number' ? value : parseFloat(String(value || 0));
       return total + (isNaN(numValue) ? 0 : numValue);
     }, 0);
@@ -55,7 +55,7 @@ export function average<TData extends DataRecord = DataRecord>(accessorKey: keyo
     if (rows.length === 0) return 0;
     
     const validValues = rows
-      .map(row => (row as any)[accessorKey])
+      .map(row => row[accessorKey as keyof TRow])
       .filter(value => value != null && value !== '')
       .map(value => {
         const numValue = typeof value === 'number' ? value : parseFloat(String(value));
@@ -111,7 +111,7 @@ export function min<TData extends DataRecord = DataRecord>(accessorKey: keyof TD
     if (rows.length === 0) return null;
     
     const validValues = rows
-      .map(row => (row as any)[accessorKey])
+      .map(row => row[accessorKey as keyof TRow])
       .filter(value => value != null && value !== '')
       .map(value => {
         const numValue = typeof value === 'number' ? value : parseFloat(String(value));
@@ -145,7 +145,7 @@ export function max<TData extends DataRecord = DataRecord>(accessorKey: keyof TD
     if (rows.length === 0) return null;
     
     const validValues = rows
-      .map(row => (row as any)[accessorKey])
+      .map(row => row[accessorKey as keyof TRow])
       .filter(value => value != null && value !== '')
       .map(value => {
         const numValue = typeof value === 'number' ? value : parseFloat(String(value));

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

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { Column } from '@tanstack/react-table';
+import type { DataRecord } from '../types';
 
 /**
  * Extracts a human-readable header text from a column definition.
@@ -9,7 +10,7 @@ import type { Column } from '@tanstack/react-table';
  * @param column - The TanStack Table column object
  * @returns The header text as a string, or falls back to column.id
  */
-export function getColumnHeaderText(column: Column<any, unknown>): string {
+export function getColumnHeaderText<TData extends DataRecord = DataRecord>(column: Column<TData, unknown>): string {
   const header = column.columnDef.header;
   
   // If header is a string, use it directly
@@ -19,7 +20,7 @@ export function getColumnHeaderText(column: Column<any, unknown>): string {
   
   // Helper to get accessorKey safely
   const getAccessorKey = (): string | undefined => {
-    const def = column.columnDef as any;
+    const def = column.columnDef;
     return 'accessorKey' in def && def.accessorKey ? String(def.accessorKey) : undefined;
   };
   

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

@@ -11,7 +11,7 @@ import type {
   PaginationMode,
   ServerSideParams 
 } from '../types';
-import { createLogger } from '../../../utils/logger';
+import { createLogger } from '../../../utils/core/logger';
 
 /**
  * Debug levels for controlling verbosity

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

@@ -49,7 +49,7 @@ export interface ExportColumn {
   header?: string;
   id?: string;
   accessorKey?: string;
-  accessorFn?: (row: any) => any;
+  accessorFn?: (row: DataRecord) => unknown;
   editAccessorKey?: string;
   isIdColumn?: boolean; // Internal flag to mark ID columns for reference fields
 }
@@ -147,7 +147,7 @@ export function generateCSVContent<TData extends DataRecord>(
   // Format data into CSV rows
   const csvData = data.map(row => {
     return columns.map(col => {
-      let value: any;
+      let value: unknown;
       
       // Handle accessorFn (for computed/reference fields) first
       if (col.accessorFn) {
@@ -187,12 +187,12 @@ export function generateCSVContent<TData extends DataRecord>(
  */
 export async function exportToCSVWithTableRows(
   tableRows: Array<{ 
-    original: any;
-    getValue: (columnId: string) => any;
+    original: DataRecord;
+    getValue: (columnId: string) => unknown;
     id: string;
   }>,
   columns: ExportColumn[],
-  columnIdToTableColumn: Map<string, any>,
+  columnIdToTableColumn: Map<string, unknown>,
   filename: string = "download.csv",
   options: {
     locale?: string;
@@ -223,7 +223,7 @@ export async function exportToCSVWithTableRows(
       // Format data into CSV rows using table row getValue() for proper accessorFn evaluation
       const csvData = tableRows.map(tableRow => {
         return columns.map(col => {
-          let value: any;
+          let value: unknown;
           
           // For ID columns (reference field IDs), get directly from original data
           if (col.isIdColumn && col.accessorKey) {

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

@@ -119,14 +119,14 @@ export function sortHierarchicalDataWithSorting<TData extends HierarchicalDataRo
 function getSortValue<TData extends HierarchicalDataRow>(
   row: TData, 
   columnId: string
-): any {
+): unknown {
   // Handle nested property access (e.g., "user.name")
   const keys = columnId.split('.');
-  let value: any = row;
+  let value: unknown = row;
   
   for (const key of keys) {
     if (value && typeof value === 'object' && key in value) {
-      value = value[key];
+      value = (value as Record<string, unknown>)[key];
     } else {
       return null;
     }
@@ -138,7 +138,7 @@ function getSortValue<TData extends HierarchicalDataRow>(
 /**
  * Compares two values for sorting
  */
-function compareValues(a: any, b: any): number {
+function compareValues(a: unknown, b: unknown): number {
   // Handle null/undefined values
   if (a == null && b == null) return 0;
   if (a == null) return -1;
@@ -169,7 +169,7 @@ function compareValues(a: any, b: any): number {
  */
 export function isHierarchicalSortableColumn<TData extends HierarchicalDataRow>(
   columnId: string,
-  columns: any[]
+  columns: Array<{ id?: string; accessorKey?: string; hideForParent?: boolean }>
 ): boolean {
   const column = columns.find(col => col.id === columnId || col.accessorKey === columnId);
   
@@ -185,7 +185,7 @@ export function isHierarchicalSortableColumn<TData extends HierarchicalDataRow>(
  */
 export function getHierarchicalSortConfig(
   sorting: SortingState,
-  columns: any[]
+  columns: Array<{ id?: string; accessorKey?: string; hideForParent?: boolean }>
 ): SortingState {
   if (sorting.length === 0) return sorting;