@shohojdhara/atomix 0.3.14 → 0.4.0

package/src/lib/composables/useAtomixGlass.ts

@@ -1,10 +1,4 @@
-import React, {
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from 'react';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import type {
   AtomixGlassProps,
   DisplacementMode,
@@ -41,10 +35,7 @@ const backgroundDetectionCache = new WeakMap<HTMLElement, BackgroundDetectionCac
  * Compare two OverLightConfig values for equality
  * Handles primitives (boolean, 'auto') and objects with deep comparison
  */
-const compareOverLightConfig = (
-  config1: OverLightConfig,
-  config2: OverLightConfig
-): boolean => {
+const compareOverLightConfig = (config1: OverLightConfig, config2: OverLightConfig): boolean => {
   // Primitive comparison for boolean and 'auto'
   if (typeof config1 !== 'object' || config1 === null) {
     return config1 === config2;
@@ -235,18 +226,12 @@ export function useAtomixGlass({
   const effectiveCornerRadius = useMemo(() => {
     if (cornerRadius !== undefined) {
       const result = Math.max(0, cornerRadius);
-      // if (process.env.NODE_ENV !== 'production' && debugCornerRadius) {
-      //   console.log('[AtomixGlass] Using manual cornerRadius prop:', result);
-      // }
       return result;
     }
 
     const result = Math.max(0, dynamicCornerRadius);
-    // if (process.env.NODE_ENV !== 'production' && debugCornerRadius) {
-    //   console.log('[AtomixGlass] Using dynamic cornerRadius:', result);
-    // }
     return result;
-  }, [cornerRadius, dynamicCornerRadius, debugCornerRadius]);
+  }, [cornerRadius, dynamicCornerRadius]);
 
   const effectiveReducedMotion = useMemo(
     () => reducedMotion || userPrefersReducedMotion,
@@ -278,7 +263,6 @@ export function useAtomixGlass({
     const extractRadius = () => {
       try {
         let extractedRadius: number | null = null;
-        let extractionSource = 'default';
 
         if (contentRef.current) {
           const firstChild = contentRef.current.firstElementChild as HTMLElement;
@@ -286,7 +270,6 @@ export function useAtomixGlass({
             const domRadius = extractBorderRadiusFromDOMElement(firstChild);
             if (domRadius !== null && domRadius > 0) {
               extractedRadius = domRadius;
-              extractionSource = 'DOM element';
             }
           }
         }
@@ -295,28 +278,17 @@ export function useAtomixGlass({
           const childRadius = extractBorderRadiusFromChildren(children);
           if (childRadius > 0 && childRadius !== CONSTANTS.DEFAULT_CORNER_RADIUS) {
             extractedRadius = childRadius;
-            extractionSource = 'React children';
           }
         }
 
         if (extractedRadius !== null && extractedRadius > 0) {
           setDynamicCornerRadius(extractedRadius);
-
-          // if (process.env.NODE_ENV !== 'production' && debugCornerRadius) {
-          //   console.log('[AtomixGlass] Corner radius extracted:', {
-          //     value: extractedRadius,
-          //     source: extractionSource,
-          //     timestamp: new Date().toISOString(),
-          //   });
-          // }
-        } else if ((typeof process === 'undefined' || process.env?.NODE_ENV !== 'production') && debugCornerRadius) {
-          //   console.log(
-          //     '[AtomixGlass] No corner radius found, using default:',
-          //     CONSTANTS.DEFAULT_CORNER_RADIUS
-          //   );
         }
       } catch (error) {
-        if ((typeof process === 'undefined' || process.env?.NODE_ENV !== 'production') && debugCornerRadius) {
+        if (
+          (typeof process === 'undefined' || process.env?.NODE_ENV !== 'production') &&
+          debugCornerRadius
+        ) {
           console.error('[AtomixGlass] Error extracting corner radius:', error);
         }
       }
@@ -330,7 +302,8 @@ export function useAtomixGlass({
   // Media query handlers and background detection
   useEffect(() => {
     // Only run auto-detection for 'auto' mode or object config (which uses auto-detection)
-    const shouldDetect = (overLight === 'auto' || (typeof overLight === 'object' && overLight !== null));
+    const shouldDetect =
+      overLight === 'auto' || (typeof overLight === 'object' && overLight !== null);
 
     if (shouldDetect && glassRef.current) {
       const element = glassRef.current;
@@ -379,7 +352,13 @@ export function useAtomixGlass({
               const bgImage = computedStyle.backgroundImage;
 
               // Check for solid color backgrounds
-              if (bgColor && bgColor !== 'rgba(0, 0, 0, 0)' && bgColor !== 'transparent' && bgColor !== 'initial' && bgColor !== 'none') {
+              if (
+                bgColor &&
+                bgColor !== 'rgba(0, 0, 0, 0)' &&
+                bgColor !== 'transparent' &&
+                bgColor !== 'initial' &&
+                bgColor !== 'none'
+              ) {
                 const rgb = bgColor.match(/\d+/g);
                 if (rgb && rgb.length >= 3) {
                   const r = Number(rgb[0]);
@@ -387,9 +366,20 @@ export function useAtomixGlass({
                   const b = Number(rgb[2]);
 
                   // Validate RGB values are valid numbers
-                  if (!isNaN(r) && !isNaN(g) && !isNaN(b) &&
-                    isFinite(r) && isFinite(g) && isFinite(b) &&
-                    r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255) {
+                  if (
+                    !isNaN(r) &&
+                    !isNaN(g) &&
+                    !isNaN(b) &&
+                    isFinite(r) &&
+                    isFinite(g) &&
+                    isFinite(b) &&
+                    r >= 0 &&
+                    r <= 255 &&
+                    g >= 0 &&
+                    g <= 255 &&
+                    b >= 0 &&
+                    b <= 255
+                  ) {
                     // Only consider if it's not pure black or very dark
                     if (r > 10 || g > 10 || b > 10) {
                       const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
@@ -436,11 +426,12 @@ export function useAtomixGlass({
               if (typeof overLight === 'object' && overLight !== null) {
                 const objConfig = overLight as OverLightObjectConfig;
                 if (objConfig.threshold !== undefined) {
-                  const configThreshold = typeof objConfig.threshold === 'number' &&
+                  const configThreshold =
+                    typeof objConfig.threshold === 'number' &&
                     !isNaN(objConfig.threshold) &&
                     isFinite(objConfig.threshold)
-                    ? objConfig.threshold
-                    : 0.7;
+                      ? objConfig.threshold
+                      : 0.7;
                   threshold = Math.min(0.9, Math.max(0.1, configThreshold));
                 }
               }
@@ -448,37 +439,31 @@ export function useAtomixGlass({
               const isOverLightDetected = avgLuminance > threshold;
 
               // Cache the result in shared cache
-              setCachedBackgroundDetection(element.parentElement, overLight, isOverLightDetected, threshold);
+              setCachedBackgroundDetection(
+                element.parentElement,
+                overLight,
+                isOverLightDetected,
+                threshold
+              );
 
               setDetectedOverLight(isOverLightDetected);
-
-              // Debug logging
-              // if (process.env.NODE_ENV !== 'production' && debugOverLight) {
-              //   console.log('[AtomixGlass] OverLight Detection:', {
-              //     avgLuminance: avgLuminance.toFixed(3),
-              //     threshold: threshold.toFixed(3),
-              //     detected: isOverLightDetected,
-              //     validSamples,
-              //     totalLuminance: totalLuminance.toFixed(3),
-              //     configType: typeof overLight === 'object' ? 'object' : typeof overLight,
-              //     timestamp: new Date().toISOString(),
-              //   });
-              // }
             } else {
               // Invalid luminance calculation, default to false
               const result = false;
-              const threshold = typeof overLight === 'object' && overLight !== null
-                ? (overLight as OverLightObjectConfig).threshold || 0.7
-                : 0.7;
+              const threshold =
+                typeof overLight === 'object' && overLight !== null
+                  ? (overLight as OverLightObjectConfig).threshold || 0.7
+                  : 0.7;
               setCachedBackgroundDetection(element.parentElement, overLight, result, threshold);
               setDetectedOverLight(result);
             }
           } else {
             // Default to false if no valid background found
             const result = false;
-            const threshold = typeof overLight === 'object' && overLight !== null
-              ? (overLight as OverLightObjectConfig).threshold || 0.7
-              : 0.7;
+            const threshold =
+              typeof overLight === 'object' && overLight !== null
+                ? (overLight as OverLightObjectConfig).threshold || 0.7
+                : 0.7;
             setCachedBackgroundDetection(element.parentElement, overLight, result, threshold);
             setDetectedOverLight(result);
           }
@@ -489,9 +474,10 @@ export function useAtomixGlass({
           }
           const result = false;
           if (element && element.parentElement) {
-            const threshold = typeof overLight === 'object' && overLight !== null
-              ? (overLight as OverLightObjectConfig).threshold || 0.7
-              : 0.7;
+            const threshold =
+              typeof overLight === 'object' && overLight !== null
+                ? (overLight as OverLightObjectConfig).threshold || 0.7
+                : 0.7;
             setCachedBackgroundDetection(element.parentElement, overLight, result, threshold);
           }
           setDetectedOverLight(result);
@@ -501,17 +487,7 @@ export function useAtomixGlass({
       return () => clearTimeout(timeoutId);
     } else if (typeof overLight === 'boolean') {
       // For boolean values, disable auto-detection
-      // Cache is automatically managed by WeakMap (no manual clearing needed)
       setDetectedOverLight(false);
-
-      // Debug logging for boolean mode
-      // if (process.env.NODE_ENV !== 'production' && debugOverLight) {
-      //   console.log('[AtomixGlass] OverLight Mode: boolean', {
-      //     value: overLight,
-      //     autoDetection: false,
-      //     timestamp: new Date().toISOString(),
-      //   });
-      // }
     }
 
     if (typeof window.matchMedia !== 'function') {
@@ -607,9 +583,12 @@ export function useAtomixGlass({
       setInternalMouseOffset(newOffset);
       setInternalGlobalMousePosition(globalPos);
 
-      if ((typeof process === 'undefined' || process.env?.NODE_ENV !== 'production') && enablePerformanceMonitoring) {
+      if (
+        (typeof process === 'undefined' || process.env?.NODE_ENV !== 'production') &&
+        enablePerformanceMonitoring
+      ) {
         const endTime = performance.now();
-        const duration = endTime - startTime;
+        // const duration = endTime - startTime;
         // if (duration > 5) {
         //   console.warn(`AtomixGlass: Mouse tracking took ${duration.toFixed(2)}ms`);
         // }
@@ -684,6 +663,16 @@ export function useAtomixGlass({
 
   // Transform calculations
   const calculateDirectionalScale = useCallback(() => {
+    // Disable directional scaling if overLight is active (to prevent zooming/distorting the premium glass effect)
+    const isOverLightActive =
+      overLight === true ||
+      (overLight === 'auto' && detectedOverLight) ||
+      (typeof overLight === 'object' && overLight !== null && detectedOverLight);
+
+    if (isOverLightActive) {
+      return 'scale(1)';
+    }
+
     if (
       !globalMousePosition.x ||
       !globalMousePosition.y ||
@@ -727,7 +716,7 @@ export function useAtomixGlass({
       Math.abs(normalizedX) * stretchIntensity * 0.15;
 
     return `scaleX(${Math.max(0.8, scaleX)}) scaleY(${Math.max(0.8, scaleY)})`;
-  }, [globalMousePosition, elasticity, glassSize, glassRef]);
+  }, [globalMousePosition, elasticity, glassSize, glassRef, overLight, detectedOverLight]);
 
   const calculateFadeInFactor = useCallback(() => {
     if (
@@ -752,7 +741,9 @@ export function useAtomixGlass({
     );
     const edgeDistance = calculateDistance({ x: edgeDistanceX, y: edgeDistanceY }, { x: 0, y: 0 });
 
-    return edgeDistance > CONSTANTS.ACTIVATION_ZONE ? 0 : 1 - edgeDistance / CONSTANTS.ACTIVATION_ZONE;
+    return edgeDistance > CONSTANTS.ACTIVATION_ZONE
+      ? 0
+      : 1 - edgeDistance / CONSTANTS.ACTIVATION_ZONE;
   }, [globalMousePosition, glassSize, glassRef]);
 
   const calculateElasticTranslation = useCallback(() => {
@@ -797,7 +788,9 @@ export function useAtomixGlass({
       element !== null && element instanceof HTMLElement && element.isConnected;
 
     const validateSize = (size: GlassSize): boolean =>
-      validateGlassSize(size) && size.width <= CONSTANTS.MAX_SIZE && size.height <= CONSTANTS.MAX_SIZE;
+      validateGlassSize(size) &&
+      size.width <= CONSTANTS.MAX_SIZE &&
+      size.height <= CONSTANTS.MAX_SIZE;
 
     let rafId: number | null = null;
     let lastSize = { width: 0, height: 0 };
@@ -931,40 +924,65 @@ export function useAtomixGlass({
     const activeIntensity = isActive ? 1.6 : 1;
 
     // More robust overlight configuration with better defaults and clamping
-    const baseOpacity = isOverLight ? Math.min(0.6, Math.max(0.2, 0.5 * hoverIntensity * activeIntensity)) : 0;
+    const baseOpacity = isOverLight
+      ? Math.min(0.6, Math.max(0.2, 0.5 * hoverIntensity * activeIntensity))
+      : 0;
 
     const baseConfig = {
       isOverLight,
       threshold: 0.7,
       opacity: baseOpacity,
-      contrast: Math.min(1.8, Math.max(1.0, 1.4 + mouseInfluence * 0.3)),
-      brightness: Math.min(1.2, Math.max(0.7, 0.85 + mouseInfluence * 0.15)),
-      saturationBoost: Math.min(2.0, Math.max(1.0, 1.3 + mouseInfluence * 0.4)),
-      shadowIntensity: Math.min(1.5, Math.max(0.5, 0.9 + mouseInfluence * 0.5)),
-      borderOpacity: Math.min(1.0, Math.max(0.3, 0.7 + mouseInfluence * 0.3)),
+      contrast: Math.min(1.6, Math.max(1.0, 1.4 + mouseInfluence * 0.1)),
+      brightness: Math.min(1.1, Math.max(0.8, 0.9 + mouseInfluence * 0.05)),
+      saturationBoost: 1.3, // Fixed value — dynamic saturation amplifies perceived displacement
+      shadowIntensity: Math.min(1.2, Math.max(0.5, 0.9 + mouseInfluence * 0.2)),
+      borderOpacity: Math.min(1.0, Math.max(0.3, 0.7 + mouseInfluence * 0.1)),
     };
 
     if (typeof overLight === 'object' && overLight !== null) {
       const objConfig = overLight as OverLightObjectConfig;
 
       // Validate and apply object config values with proper clamping
-      const validatedThreshold = validateConfigValue(objConfig.threshold, 0.1, 1.0, baseConfig.threshold);
+      const validatedThreshold = validateConfigValue(
+        objConfig.threshold,
+        0.1,
+        1.0,
+        baseConfig.threshold
+      );
       const validatedOpacity = validateConfigValue(objConfig.opacity, 0.1, 1.0, baseConfig.opacity);
-      const validatedContrast = validateConfigValue(objConfig.contrast, 0.5, 2.5, baseConfig.contrast);
-      const validatedBrightness = validateConfigValue(objConfig.brightness, 0.5, 2.0, baseConfig.brightness);
-      const validatedSaturationBoost = validateConfigValue(objConfig.saturationBoost, 0.5, 3.0, baseConfig.saturationBoost);
+      const validatedContrast = validateConfigValue(
+        objConfig.contrast,
+        0.5,
+        2.5,
+        baseConfig.contrast
+      );
+      const validatedBrightness = validateConfigValue(
+        objConfig.brightness,
+        0.5,
+        2.0,
+        baseConfig.brightness
+      );
+      const validatedSaturationBoost = validateConfigValue(
+        objConfig.saturationBoost,
+        0.5,
+        3.0,
+        baseConfig.saturationBoost
+      );
 
       const finalConfig = {
         ...baseConfig,
         threshold: validatedThreshold,
         opacity: validatedOpacity * hoverIntensity * activeIntensity,
-        contrast: validatedContrast + mouseInfluence * 0.3,
-        brightness: validatedBrightness + mouseInfluence * 0.15,
-        saturationBoost: validatedSaturationBoost + mouseInfluence * 0.4,
+        contrast: Math.min(1.6, validatedContrast + mouseInfluence * 0.1),
+        brightness: Math.min(1.1, validatedBrightness + mouseInfluence * 0.05),
+        saturationBoost: validatedSaturationBoost, // Use validated value directly, no mouse influence
       };
 
       // Debug logging
-      if ((typeof process === 'undefined' || process.env?.NODE_ENV !== 'production') && debugOverLight) {
+      if (
+        (typeof process === 'undefined' || process.env?.NODE_ENV !== 'production') &&
+        debugOverLight
+      ) {
         console.log('[AtomixGlass] OverLight Config:', {
           isOverLight,
           config: {
@@ -996,7 +1014,10 @@ export function useAtomixGlass({
     }
 
     // Debug logging for non-object configs
-    if ((typeof process === 'undefined' || process.env?.NODE_ENV !== 'production') && debugOverLight) {
+    if (
+      (typeof process === 'undefined' || process.env?.NODE_ENV !== 'production') &&
+      debugOverLight
+    ) {
       console.log('[AtomixGlass] OverLight Config:', {
         isOverLight,
         configType: typeof overLight === 'boolean' ? (overLight ? 'true' : 'false') : overLight,
@@ -1019,7 +1040,15 @@ export function useAtomixGlass({
     }
 
     return baseConfig;
-  }, [overLight, getEffectiveOverLight, mouseOffset, isHovered, isActive, validateConfigValue, debugOverLight]);
+  }, [
+    overLight,
+    getEffectiveOverLight,
+    mouseOffset,
+    isHovered,
+    isActive,
+    validateConfigValue,
+    debugOverLight,
+  ]);
 
   // Event handlers
   const handleMouseEnter = useCallback(() => setIsHovered(true), []);

package/src/lib/composables/useChartExport.ts

@@ -1,4 +1,5 @@
 import { useCallback, useRef } from 'react';
+import { sanitizeCSVCell } from '../utils/csv';
 
 export interface ExportOptions {
   /**
@@ -180,13 +181,7 @@ export function useChartExport() {
 
     // Convert to CSV string with sanitization
     const csvContent = rows
-      .map(row => row.map(cell => {
-        // Sanitize cell content to prevent CSV injection
-        const sanitized = String(cell).replace(/[\r\n\t]/g, ' ').replace(/"/g, '""');
-        // Prevent formula injection by prefixing dangerous characters
-        const dangerous = /^[=+\-@]/;
-        return `"${dangerous.test(sanitized) ? `'${sanitized}` : sanitized}"`;
-      }).join(','))
+      .map(row => row.map(cell => `"${sanitizeCSVCell(cell)}"`).join(','))
       .join('\n');
 
     // Download
@@ -330,4 +325,4 @@ export function useChartExport() {
     exportChart,
     shareChart,
   };
-}
+}

package/src/lib/composables/useDataTable.ts

@@ -274,7 +274,9 @@ export function useDataTable({
   const visibleColumns = useMemo(() => {
     return columnOrder
       .map(key => columns.find(col => col.key === key))
-      .filter((col): col is DataTableColumn => col !== undefined && columnVisibility[col.key] !== false);
+      .filter(
+        (col): col is DataTableColumn => col !== undefined && columnVisibility[col.key] !== false
+      );
   }, [columns, columnOrder, columnVisibility]);
 
   // Handle sorting
@@ -299,13 +301,10 @@ export function useDataTable({
   );
 
   // Handle page change
-  const handlePageChange = useCallback(
-    (page: number) => {
-      if (page < 1) return;
-      setCurrentPage(page);
-    },
-    []
-  );
+  const handlePageChange = useCallback((page: number) => {
+    if (page < 1) return;
+    setCurrentPage(page);
+  }, []);
 
   // Handle search
   const handleSearch = useCallback((query: string) => {
@@ -328,47 +327,73 @@ export function useDataTable({
     setCurrentPage(1);
   }, []);
 
+  // Pre-process column filters to avoid redundant lookups and transformations
+  const activeColumnFilters = useMemo(() => {
+    if (!columnFilters)
+      return [] as Array<{
+        key: string;
+        value: string;
+        lowercaseValue: string;
+        column: DataTableColumn;
+      }>;
+
+    return Object.entries(columnFilterValues)
+      .filter(([, value]) => value !== undefined && value !== null && value !== '')
+      .map(([columnKey, value]) => {
+        const column = columns.find(col => col.key === columnKey);
+        if (!column || !column.filterable) return null;
+
+        return {
+          key: columnKey,
+          value,
+          lowercaseValue:
+            typeof value === 'string' ? value.toLowerCase() : String(value).toLowerCase(),
+          column,
+        };
+      })
+      .filter((f): f is NonNullable<typeof f> => f !== null);
+  }, [columnFilters, columnFilterValues, columns]);
+
   // Filter data based on search query and column filters
   const filteredData = useMemo(() => {
-    let result = data;
+    if (!searchQuery && activeColumnFilters.length === 0) {
+      return data;
+    }
 
-    // Apply global search
-    if (searchQuery) {
-      const lowercaseQuery = searchQuery.toLowerCase();
-      result = result.filter(row => {
-        return visibleColumns.some(column => {
+    const lowercaseQuery = searchQuery ? searchQuery.toLowerCase() : '';
+
+    return data.filter(row => {
+      // Apply global search
+      if (searchQuery) {
+        const matchesGlobal = visibleColumns.some(column => {
           const value = row[column.key];
           if (value == null) return false;
           return String(value).toLowerCase().includes(lowercaseQuery);
         });
-      });
-    }
-
-    // Apply column-specific filters
-    if (columnFilters) {
-      result = result.filter(row => {
-        return Object.entries(columnFilterValues).every(([columnKey, filterValue]) => {
-          if (!filterValue) return true;
-
-          const column = columns.find(col => col.key === columnKey);
-          if (!column || !column.filterable) return true;
+        if (!matchesGlobal) return false;
+      }
 
-          const cellValue = row[columnKey];
-          if (cellValue == null) return false;
+      // Apply column-specific filters
+      for (let i = 0; i < activeColumnFilters.length; i++) {
+        const filter = activeColumnFilters[i];
+        if (!filter) continue;
+        const { key, value, lowercaseValue, column } = filter;
+        const cellValue = row[key];
 
-          // Use custom filter function if provided
-          if (column.filterFunction) {
-            return column.filterFunction(cellValue, filterValue);
-          }
+        if (cellValue == null) return false;
 
+        // Use custom filter function if provided
+        if (column.filterFunction) {
+          if (!column.filterFunction(cellValue, value)) return false;
+        } else {
           // Default text filter
-          return String(cellValue).toLowerCase().includes(filterValue.toLowerCase());
-        });
-      });
-    }
+          if (!String(cellValue).toLowerCase().includes(lowercaseValue)) return false;
+        }
+      }
 
-    return result;
-  }, [data, visibleColumns, searchQuery, columnFilterValues, columnFilters, columns]);
+      return true;
+    });
+  }, [data, visibleColumns, searchQuery, activeColumnFilters]);
 
   // Sort data
   const sortedData = useMemo(() => {
@@ -434,7 +459,9 @@ export function useDataTable({
       }
 
       if (onSelectionChange) {
-        const selectedRowsData = sortedData.filter(row => newSelectedIds.includes(getRowId(row, rowKey)));
+        const selectedRowsData = sortedData.filter(row =>
+          newSelectedIds.includes(getRowId(row, rowKey))
+        );
         onSelectionChange(selectedRowsData, newSelectedIds);
       }
     },
@@ -446,16 +473,16 @@ export function useDataTable({
     (selected: boolean) => {
       if (selectionMode !== 'multiple') return;
 
-      const newSelectedIds = selected
-        ? paginatedData.map(row => getRowId(row, rowKey))
-        : [];
+      const newSelectedIds = selected ? paginatedData.map(row => getRowId(row, rowKey)) : [];
 
       if (!controlledSelectedRowIds) {
         setInternalSelectedRowIds(newSelectedIds);
       }
 
       if (onSelectionChange) {
-        const selectedRowsData = sortedData.filter(row => newSelectedIds.includes(getRowId(row, rowKey)));
+        const selectedRowsData = sortedData.filter(row =>
+          newSelectedIds.includes(getRowId(row, rowKey))
+        );
         onSelectionChange(selectedRowsData, newSelectedIds);
       }
     },
@@ -471,7 +498,9 @@ export function useDataTable({
   // Check if some rows are selected (indeterminate)
   const isIndeterminate = useMemo(() => {
     if (selectionMode !== 'multiple' || paginatedData.length === 0) return false;
-    const selectedCount = paginatedData.filter(row => selectedRowIds.includes(getRowId(row, rowKey))).length;
+    const selectedCount = paginatedData.filter(row =>
+      selectedRowIds.includes(getRowId(row, rowKey))
+    ).length;
     return selectedCount > 0 && selectedCount < paginatedData.length;
   }, [selectionMode, paginatedData, selectedRowIds, rowKey]);