@jmruthers/pace-core 0.5.135 → 0.5.137

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

@@ -0,0 +1,161 @@
+/**
+ * @file Aggregation Utility Functions
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Utils
+ * @since 0.6.0
+ * 
+ * Utility functions for common aggregation operations in grouped DataTable rows.
+ * These functions can be used as the `aggregateFn` property in column definitions.
+ */
+
+import type { DataTableColumn, DataRecord } from '../types';
+
+/**
+ * Creates a sum aggregation function for a specific field.
+ * 
+ * @param accessorKey - The field key to sum (e.g., 'cost', 'quantity')
+ * @returns An aggregation function that sums the specified field across all rows
+ * 
+ * @example
+ * ```tsx
+ * {
+ *   accessorKey: 'cost',
+ *   header: 'Total Cost',
+ *   aggregateFn: sum('cost'),
+ * }
+ * ```
+ */
+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 numValue = typeof value === 'number' ? value : parseFloat(String(value || 0));
+      return total + (isNaN(numValue) ? 0 : numValue);
+    }, 0);
+  };
+}
+
+/**
+ * Creates an average aggregation function for a specific field.
+ * 
+ * @param accessorKey - The field key to average (e.g., 'price', 'rating')
+ * @returns An aggregation function that calculates the average of the specified field across all rows
+ * 
+ * @example
+ * ```tsx
+ * {
+ *   accessorKey: 'price',
+ *   header: 'Avg Price',
+ *   aggregateFn: average('price'),
+ * }
+ * ```
+ */
+export function average<TData extends DataRecord = DataRecord>(accessorKey: keyof TData | string) {
+  return <TRow extends DataRecord = TData>(rows: TRow[], column: DataTableColumn<TRow>): number => {
+    if (rows.length === 0) return 0;
+    
+    const validValues = rows
+      .map(row => (row as any)[accessorKey])
+      .filter(value => value != null && value !== '')
+      .map(value => {
+        const numValue = typeof value === 'number' ? value : parseFloat(String(value));
+        return isNaN(numValue) ? null : numValue;
+      })
+      .filter((value): value is number => value !== null);
+    
+    if (validValues.length === 0) return 0;
+    
+    const sum = validValues.reduce((total, value) => total + value, 0);
+    return sum / validValues.length;
+  };
+}
+
+/**
+ * Creates a count aggregation function.
+ * Returns the number of rows in the group.
+ * 
+ * @returns An aggregation function that counts the number of rows
+ * 
+ * @example
+ * ```tsx
+ * {
+ *   accessorKey: 'id',
+ *   header: 'Count',
+ *   aggregateFn: count(),
+ * }
+ * ```
+ */
+export function count<TData extends DataRecord = DataRecord>() {
+  return <TRow extends DataRecord = TData>(rows: TRow[], column: DataTableColumn<TRow>): number => {
+    return rows.length;
+  };
+}
+
+/**
+ * Creates a minimum aggregation function for a specific field.
+ * 
+ * @param accessorKey - The field key to find the minimum of (e.g., 'price', 'date')
+ * @returns An aggregation function that returns the minimum value of the specified field
+ * 
+ * @example
+ * ```tsx
+ * {
+ *   accessorKey: 'price',
+ *   header: 'Min Price',
+ *   aggregateFn: min('price'),
+ * }
+ * ```
+ */
+export function min<TData extends DataRecord = DataRecord>(accessorKey: keyof TData | string) {
+  return <TRow extends DataRecord = TData>(rows: TRow[], column: DataTableColumn<TRow>): number | null => {
+    if (rows.length === 0) return null;
+    
+    const validValues = rows
+      .map(row => (row as any)[accessorKey])
+      .filter(value => value != null && value !== '')
+      .map(value => {
+        const numValue = typeof value === 'number' ? value : parseFloat(String(value));
+        return isNaN(numValue) ? null : numValue;
+      })
+      .filter((value): value is number => value !== null);
+    
+    if (validValues.length === 0) return null;
+    
+    return Math.min(...validValues);
+  };
+}
+
+/**
+ * Creates a maximum aggregation function for a specific field.
+ * 
+ * @param accessorKey - The field key to find the maximum of (e.g., 'price', 'date')
+ * @returns An aggregation function that returns the maximum value of the specified field
+ * 
+ * @example
+ * ```tsx
+ * {
+ *   accessorKey: 'price',
+ *   header: 'Max Price',
+ *   aggregateFn: max('price'),
+ * }
+ * ```
+ */
+export function max<TData extends DataRecord = DataRecord>(accessorKey: keyof TData | string) {
+  return <TRow extends DataRecord = TData>(rows: TRow[], column: DataTableColumn<TRow>): number | null => {
+    if (rows.length === 0) return null;
+    
+    const validValues = rows
+      .map(row => (row as any)[accessorKey])
+      .filter(value => value != null && value !== '')
+      .map(value => {
+        const numValue = typeof value === 'number' ? value : parseFloat(String(value));
+        return isNaN(numValue) ? null : numValue;
+      })
+      .filter((value): value is number => value !== null);
+    
+    if (validValues.length === 0) return null;
+    
+    return Math.max(...validValues);
+  };
+}
+

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

@@ -0,0 +1,40 @@
+import React from 'react';
+import type { Column } from '@tanstack/react-table';
+
+/**
+ * Extracts a human-readable header text from a column definition.
+ * Used for generating filter placeholders and other UI text that should
+ * display the column header instead of the technical field name.
+ * 
+ * @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 {
+  const header = column.columnDef.header;
+  
+  // If header is a string, use it directly
+  if (typeof header === 'string') {
+    return header;
+  }
+  
+  // Helper to get accessorKey safely
+  const getAccessorKey = (): string | undefined => {
+    const def = column.columnDef as any;
+    return 'accessorKey' in def && def.accessorKey ? String(def.accessorKey) : undefined;
+  };
+  
+  // If header is a function, we can't easily extract the text without calling it
+  // with a context, so we fall back to accessorKey or id
+  if (typeof header === 'function') {
+    return getAccessorKey() || column.id;
+  }
+  
+  // If header is a React component, fall back to accessorKey or id
+  if (React.isValidElement(header)) {
+    return getAccessorKey() || column.id;
+  }
+  
+  // Final fallback to accessorKey or id
+  return getAccessorKey() || column.id;
+}
+