@xcelsior/ui-spreadsheets 1.2.2 → 1.3.0

package/src/hooks/useSpreadsheetDuplicates.ts

@@ -0,0 +1,149 @@
+import { useCallback, useMemo, useState } from 'react';
+import type { SpreadsheetColumn } from '../types';
+
+export interface UseSpreadsheetDuplicatesOptions<T> {
+    data: T[];
+    columns: SpreadsheetColumn<T>[];
+    duplicateCheckColumns: string[];
+    getRowId: (row: T) => string | number;
+}
+
+export interface UseSpreadsheetDuplicatesReturn {
+    /** Check if a specific cell value is a duplicate in its column */
+    isCellDuplicate: (rowId: string | number, columnId: string) => boolean;
+    /** Get the duplicate count for a value in a column */
+    getDuplicateCount: (columnId: string, value: any) => number;
+    /** Get the number of rows with duplicate values for a column */
+    getDuplicateColumnCount: (columnId: string) => number;
+    /** Map of columnId -> Set of rowIds that have duplicate values */
+    duplicateRowIds: Map<string, Set<string | number>>;
+    /** Set of column IDs with duplicate checking enabled */
+    duplicateCheckColumns: Set<string>;
+    /** Toggle duplicate check for a column */
+    toggleDuplicateCheck: (columnId: string) => void;
+}
+
+/** Normalize a cell value for duplicate comparison */
+function normalizeValue(value: any): string {
+    if (value === null || value === undefined || value === '') {
+        return '__blank__';
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    return String(value).trim().toLowerCase();
+}
+
+export function useSpreadsheetDuplicates<T>({
+    data,
+    columns,
+    duplicateCheckColumns,
+    getRowId,
+}: UseSpreadsheetDuplicatesOptions<T>): UseSpreadsheetDuplicatesReturn {
+    const [localDuplicateCheckColumns, setLocalDuplicateCheckColumns] = useState<Set<string>>(
+        () => new Set(duplicateCheckColumns)
+    );
+
+    // Sync external prop changes into local state
+    const duplicateCheckColumnsSet = useMemo(() => {
+        return new Set(duplicateCheckColumns);
+    }, [duplicateCheckColumns]);
+
+    // Build Maps for O(1) lookup: columnId -> normalizedValue -> rowId[]
+    const { duplicateRowIds, valueCounts } = useMemo(() => {
+        const duplicateRowIds = new Map<string, Set<string | number>>();
+        const valueCounts = new Map<string, Map<string, number>>();
+
+        const activeColumns = duplicateCheckColumnsSet.size > 0
+            ? duplicateCheckColumnsSet
+            : localDuplicateCheckColumns;
+
+        for (const columnId of activeColumns) {
+            const column = columns.find((c) => c.id === columnId);
+            if (!column) continue;
+
+            // Single O(n) pass: build value -> rowId[] map
+            const valueToRowIds = new Map<string, (string | number)[]>();
+
+            for (const row of data) {
+                const rawValue = column.getValue ? column.getValue(row) : (row as any)[columnId];
+                // Skip empty/null/undefined values — they're not duplicates
+                if (rawValue === null || rawValue === undefined || rawValue === '') continue;
+                const normalized = normalizeValue(rawValue);
+                const rowId = getRowId(row);
+
+                const existing = valueToRowIds.get(normalized);
+                if (existing) {
+                    existing.push(rowId);
+                } else {
+                    valueToRowIds.set(normalized, [rowId]);
+                }
+            }
+
+            // Build duplicateRowIds set for this column
+            const dupSet = new Set<string | number>();
+            const countMap = new Map<string, number>();
+
+            for (const [normalizedVal, rowIds] of valueToRowIds) {
+                countMap.set(normalizedVal, rowIds.length);
+                if (rowIds.length >= 2) {
+                    for (const rowId of rowIds) {
+                        dupSet.add(rowId);
+                    }
+                }
+            }
+
+            duplicateRowIds.set(columnId, dupSet);
+            valueCounts.set(columnId, countMap);
+        }
+
+        return { duplicateRowIds, valueCounts };
+    }, [data, columns, duplicateCheckColumnsSet, localDuplicateCheckColumns, getRowId]);
+
+    const isCellDuplicate = useCallback(
+        (rowId: string | number, columnId: string): boolean => {
+            return duplicateRowIds.get(columnId)?.has(rowId) ?? false;
+        },
+        [duplicateRowIds]
+    );
+
+    const getDuplicateCount = useCallback(
+        (columnId: string, value: any): number => {
+            const normalized = normalizeValue(value);
+            return valueCounts.get(columnId)?.get(normalized) ?? 0;
+        },
+        [valueCounts]
+    );
+
+    const getDuplicateColumnCount = useCallback(
+        (columnId: string): number => {
+            return duplicateRowIds.get(columnId)?.size ?? 0;
+        },
+        [duplicateRowIds]
+    );
+
+    const toggleDuplicateCheck = useCallback((columnId: string) => {
+        setLocalDuplicateCheckColumns((prev) => {
+            const next = new Set(prev);
+            if (next.has(columnId)) {
+                next.delete(columnId);
+            } else {
+                next.add(columnId);
+            }
+            return next;
+        });
+    }, []);
+
+    // Expose the effective set (external prop wins when non-empty, else local state)
+    const effectiveDuplicateCheckColumns =
+        duplicateCheckColumnsSet.size > 0 ? duplicateCheckColumnsSet : localDuplicateCheckColumns;
+
+    return {
+        isCellDuplicate,
+        getDuplicateCount,
+        getDuplicateColumnCount,
+        duplicateRowIds,
+        duplicateCheckColumns: effectiveDuplicateCheckColumns,
+        toggleDuplicateCheck,
+    };
+}

package/src/hooks/useSpreadsheetFiltering.ts

@@ -25,6 +25,13 @@ export interface UseSpreadsheetFilteringOptions<T> {
      * Use with serverSide mode for server-side sorting.
      */
     controlledSortConfig?: SpreadsheetSortConfig | null;
+    /**
+     * Map of columnId -> Set of rowIds that have duplicate values.
+     * Used for showDuplicatesOnly filter option.
+     */
+    duplicateRowIds?: Map<string, Set<string | number>>;
+    /** Row ID accessor, required when using showDuplicatesOnly filter */
+    getRowId?: (row: T) => string | number;
 }
 
 export interface UseSpreadsheetFilteringReturn<T> {
@@ -54,6 +61,8 @@ export function useSpreadsheetFiltering<T extends Record<string, any>>({
     controlledFilters,
     controlledSortConfig,
     defaultSortConfig,
+    duplicateRowIds,
+    getRowId,
 }: UseSpreadsheetFilteringOptions<T>): UseSpreadsheetFilteringReturn<T> {
     // Internal state for uncontrolled mode
     const [internalFilters, setInternalFilters] = useState<Record<string, SpreadsheetColumnFilter>>(
@@ -337,6 +346,14 @@ export function useSpreadsheetFiltering<T extends Record<string, any>>({
             if (!column) continue;
 
             filterChain.add(buildFilterPredicate(column, filter));
+
+            // Handle showDuplicatesOnly as an additional predicate
+            if (filter.showDuplicatesOnly && duplicateRowIds && getRowId) {
+                const dupSet = duplicateRowIds.get(columnId);
+                if (dupSet) {
+                    filterChain.add((row: T) => dupSet.has(getRowId(row)));
+                }
+            }
         }
 
         // Apply combined filter if any filters are active
@@ -351,7 +368,7 @@ export function useSpreadsheetFiltering<T extends Record<string, any>>({
         }
 
         return lazyResult;
-    }, [data, filters, sortConfig, columns, serverSide, buildFilterPredicate, buildSortComparator]);
+    }, [data, filters, sortConfig, columns, serverSide, buildFilterPredicate, buildSortComparator, duplicateRowIds, getRowId]);
 
     const handleFilterChange = useCallback(
         (columnId: string, filter: SpreadsheetColumnFilter | undefined) => {

package/src/hooks/useSpreadsheetHighlighting.ts

@@ -72,6 +72,9 @@ export interface UseSpreadsheetHighlightingReturn {
     highlightPickerCell: { rowId: string | number; columnId: string } | null;
     setHighlightPickerCell: (cell: { rowId: string | number; columnId: string } | null) => void;
 
+    // Recent colors
+    recentColors: string[];
+
     // Utility
     clearAllHighlights: () => void;
 }
@@ -95,6 +98,17 @@ export function useSpreadsheetHighlighting({
         Record<string, string>
     >({});
 
+    // Recent colors (track last 8 used colors)
+    const [recentColors, setRecentColors] = useState<string[]>([]);
+
+    const addRecentColor = useCallback((color: string | null) => {
+        if (!color) return;
+        setRecentColors((prev) => {
+            const filtered = prev.filter((c) => c !== color);
+            return [color, ...filtered].slice(0, 8);
+        });
+    }, []);
+
     // Picker states
     const [highlightPickerRow, setHighlightPickerRow] = useState<string | number | null>(null);
     const [highlightPickerColumn, setHighlightPickerColumn] = useState<string | null>(null);
@@ -144,9 +158,10 @@ export function useSpreadsheetHighlighting({
                     return prev;
                 });
             }
+            addRecentColor(color);
             setHighlightPickerCell(null);
         },
-        [onCellHighlight]
+        [onCellHighlight, addRecentColor]
     );
 
     // Get row-level highlight
@@ -181,9 +196,10 @@ export function useSpreadsheetHighlighting({
                     return prev;
                 });
             }
+            addRecentColor(color);
             setHighlightPickerRow(null);
         },
-        [onRowHighlight]
+        [onRowHighlight, addRecentColor]
     );
 
     // Get column highlight (works for both regular columns and row index)
@@ -212,9 +228,10 @@ export function useSpreadsheetHighlighting({
                     return newHighlights;
                 });
             }
+            addRecentColor(color);
             setHighlightPickerColumn(null);
         },
-        [onColumnHighlight]
+        [onColumnHighlight, addRecentColor]
     );
 
     // Clear all highlights
@@ -240,6 +257,9 @@ export function useSpreadsheetHighlighting({
         getColumnHighlight,
         handleColumnHighlightToggle,
 
+        // Recent colors
+        recentColors,
+
         // Picker state
         highlightPickerRow,
         setHighlightPickerRow,

package/src/hooks/useSpreadsheetKeyboardShortcuts.ts

@@ -29,6 +29,8 @@ export interface UseSpreadsheetKeyboardShortcutsOptions {
     onCopy?: () => void;
     /** Handler for paste (Ctrl/Cmd+V) */
     onPaste?: () => void;
+    /** Handler for select all (Ctrl/Cmd+A) */
+    onSelectAll?: () => void;
     /** Whether there is a focused cell */
     hasFocusedCell?: boolean;
     /** Whether a cell is currently being edited */
@@ -69,6 +71,7 @@ export function useSpreadsheetKeyboardShortcuts({
     onTabNavigation,
     onCopy,
     onPaste,
+    onSelectAll,
     hasFocusedCell = false,
     isEditing = false,
     customShortcuts = [],
@@ -119,6 +122,17 @@ export function useSpreadsheetKeyboardShortcuts({
                 return;
             }
 
+            // Cmd/Ctrl+A: Select all (only when not editing)
+            if (
+                (event.metaKey || event.ctrlKey) &&
+                (event.key === 'a' || event.key === 'A') &&
+                !isEditing
+            ) {
+                event.preventDefault();
+                onSelectAll?.();
+                return;
+            }
+
             // Cmd/Ctrl+C: Copy (only when not editing and has focused cell)
             if (
                 (event.metaKey || event.ctrlKey) &&
@@ -211,6 +225,7 @@ export function useSpreadsheetKeyboardShortcuts({
         onTabNavigation,
         onCopy,
         onPaste,
+        onSelectAll,
         hasFocusedCell,
         isEditing,
         customShortcuts,
@@ -230,6 +245,7 @@ export function useSpreadsheetKeyboardShortcuts({
         editing: [
             { label: 'Undo', keys: [modifierKey, 'Z'] },
             { label: 'Redo', keys: [modifierKey, 'Shift', 'Z'] },
+            { label: 'Select all', keys: [modifierKey, 'A'] },
             { label: 'Copy cells', keys: [modifierKey, 'C'] },
             { label: 'Paste cells', keys: [modifierKey, 'V'] },
             { label: 'Confirm cell edit', keys: ['Enter'] },