@versini/ui-datagrid 4.2.12 → 4.2.13

package/dist/DataGridSorting/index.js

@@ -1,224 +1,80 @@
 /*!
-  @versini/ui-datagrid v4.2.12
+  @versini/ui-datagrid v4.2.13
   © 2026 gizmette.com
 */
 
 import { SortDirections } from "../7.js";
-
-
-/**
- * Gets the opposite sort direction.
- */ function getOppositeSortDirection(direction) {
+function getOppositeSortDirection(direction) {
     return direction === SortDirections.ASC ? SortDirections.DESC : SortDirections.ASC;
 }
-/**
- * Toggles the sort direction or returns default if no current direction.
- */ function toggleSortDirection(currentDirection, defaultDirection = SortDirections.ASC) {
-    if (!currentDirection) {
-        return defaultDirection;
-    }
+function toggleSortDirection(currentDirection, defaultDirection = SortDirections.ASC) {
+    if (!currentDirection) return defaultDirection;
     return getOppositeSortDirection(currentDirection);
 }
-/**
- * Creates a sort comparator for dates. Handles Date objects, ISO strings, and
- * timestamps.
- *
- * @param direction - Sort direction (asc or desc)
- * @param nullPosition - Where to place null/undefined values ('start' or 'end')
- *
- * @example
- * ```ts
- * const items = [{ date: '2024-01-15' }, { date: '2024-01-10' }];
- * const sorted = items.sort((a, b) =>
- *   sortByDate('asc')(a.date, b.date)
- * );
- * ```
- *
- */ function sortByDate(direction, nullPosition = "end") {
+function sortByDate(direction, nullPosition = "end") {
     return (a, b)=>{
-        const aIsNull = a === null || a === undefined;
-        const bIsNull = b === null || b === undefined;
-        // Handle null values.
-        if (aIsNull && bIsNull) {
-            return 0;
-        }
-        if (aIsNull) {
-            return nullPosition === "start" ? -1 : 1;
-        }
-        if (bIsNull) {
-            return nullPosition === "start" ? 1 : -1;
-        }
+        const aIsNull = null == a;
+        const bIsNull = null == b;
+        if (aIsNull && bIsNull) return 0;
+        if (aIsNull) return "start" === nullPosition ? -1 : 1;
+        if (bIsNull) return "start" === nullPosition ? 1 : -1;
         const aTime = a instanceof Date ? a.getTime() : new Date(a).getTime();
         const bTime = b instanceof Date ? b.getTime() : new Date(b).getTime();
-        // Handle invalid dates.
-        if (Number.isNaN(aTime) && Number.isNaN(bTime)) {
-            return 0;
-        }
-        if (Number.isNaN(aTime)) {
-            return nullPosition === "start" ? -1 : 1;
-        }
-        if (Number.isNaN(bTime)) {
-            return nullPosition === "start" ? 1 : -1;
-        }
+        if (Number.isNaN(aTime) && Number.isNaN(bTime)) return 0;
+        if (Number.isNaN(aTime)) return "start" === nullPosition ? -1 : 1;
+        if (Number.isNaN(bTime)) return "start" === nullPosition ? 1 : -1;
         return direction === SortDirections.ASC ? aTime - bTime : bTime - aTime;
     };
 }
-/**
- * Creates a sort comparator for numbers.
- *
- * @param direction - Sort direction (asc or desc)
- * @param nullPosition - Where to place null/undefined values ('start' or 'end')
- *
- * @example
- * ```ts
- * const items = [{ count: 5 }, { count: 2 }, { count: 10 }];
- * const sorted = items.sort((a, b) =>
- *   sortByNumber('desc')(a.count, b.count)
- * );
- * ```
- *
- */ function sortByNumber(direction, nullPosition = "end") {
+function sortByNumber(direction, nullPosition = "end") {
     return (a, b)=>{
-        const aIsNull = a === null || a === undefined;
-        const bIsNull = b === null || b === undefined;
-        // Handle null values.
-        if (aIsNull && bIsNull) {
-            return 0;
-        }
-        if (aIsNull) {
-            return nullPosition === "start" ? -1 : 1;
-        }
-        if (bIsNull) {
-            return nullPosition === "start" ? 1 : -1;
-        }
-        // Handle NaN.
+        const aIsNull = null == a;
+        const bIsNull = null == b;
+        if (aIsNull && bIsNull) return 0;
+        if (aIsNull) return "start" === nullPosition ? -1 : 1;
+        if (bIsNull) return "start" === nullPosition ? 1 : -1;
         const aIsNaN = Number.isNaN(a);
         const bIsNaN = Number.isNaN(b);
-        if (aIsNaN && bIsNaN) {
-            return 0;
-        }
-        if (aIsNaN) {
-            return nullPosition === "start" ? -1 : 1;
-        }
-        if (bIsNaN) {
-            return nullPosition === "start" ? 1 : -1;
-        }
+        if (aIsNaN && bIsNaN) return 0;
+        if (aIsNaN) return "start" === nullPosition ? -1 : 1;
+        if (bIsNaN) return "start" === nullPosition ? 1 : -1;
         return direction === SortDirections.ASC ? a - b : b - a;
     };
 }
-/**
- * Creates a sort comparator for strings. Uses localeCompare for proper Unicode
- * sorting.
- *
- * @param direction - Sort direction (asc or desc)
- * @param options - Options for string comparison
- *
- * @example
- * ```ts
- * const items = [{ name: 'Zebra' }, { name: 'apple' }];
- * const sorted = items.sort((a, b) =>
- *   sortByString('asc', { caseInsensitive: true })(a.name, b.name)
- * );
- * ```
- *
- */ function sortByString(direction, options) {
+function sortByString(direction, options) {
     const { nullPosition = "end", caseInsensitive = true, locale } = options ?? {};
     return (a, b)=>{
-        const aIsNull = a === null || a === undefined || a === "";
-        const bIsNull = b === null || b === undefined || b === "";
-        // Handle null/empty values.
-        if (aIsNull && bIsNull) {
-            return 0;
-        }
-        if (aIsNull) {
-            return nullPosition === "start" ? -1 : 1;
-        }
-        if (bIsNull) {
-            return nullPosition === "start" ? 1 : -1;
-        }
+        const aIsNull = null == a || "" === a;
+        const bIsNull = null == b || "" === b;
+        if (aIsNull && bIsNull) return 0;
+        if (aIsNull) return "start" === nullPosition ? -1 : 1;
+        if (bIsNull) return "start" === nullPosition ? 1 : -1;
         const compareOptions = {
             sensitivity: caseInsensitive ? "base" : "variant"
         };
-        const comparison = locale ? a.localeCompare(b, locale, compareOptions) : a.localeCompare(b, undefined, compareOptions);
+        const comparison = locale ? a.localeCompare(b, locale, compareOptions) : a.localeCompare(b, void 0, compareOptions);
         return direction === SortDirections.ASC ? comparison : -comparison;
     };
 }
-/**
- * Creates a sort comparator for booleans.
- *
- * @param direction - Sort direction (asc = false first, desc = true first)
- *
- * @example
- * ```ts
- * const items = [{ active: true }, { active: false }];
- * const sorted = items.sort((a, b) =>
- *   sortByBoolean('desc')(a.active, b.active)
- * );
- * // Result: [{ active: true }, { active: false }]
- * ```
- *
- */ function sortByBoolean(direction) {
+function sortByBoolean(direction) {
     return (a, b)=>{
-        // Treat null/undefined as false for comparison.
-        const aVal = a === true ? 1 : 0;
-        const bVal = b === true ? 1 : 0;
+        const aVal = true === a ? 1 : 0;
+        const bVal = true === b ? 1 : 0;
         return direction === SortDirections.ASC ? aVal - bVal : bVal - aVal;
     };
 }
-/**
- * Helper to create a sort handler function. Returns the new sort config when a
- * column header is clicked.
- *
- * @param currentConfig - Current sort configuration
- * @param cellId - ID of the clicked cell
- * @param defaultDirection - Default direction when clicking a new column
- *
- * @example
- * ```tsx
- * const [sortConfig, setSortConfig] = useState<SortConfig>({
- *   sortedCell: 'date',
- *   sortDirection: 'desc',
- * });
- *
- * const handleSort = (cellId: string) => {
- *   setSortConfig(getNextSortConfig(sortConfig, cellId));
- * };
- * ```
- *
- */ function getNextSortConfig(currentConfig, cellId, defaultDirection = SortDirections.DESC) {
-    if (currentConfig.sortedCell === cellId) {
-        // Toggle direction on same column.
-        return {
-            sortedCell: cellId,
-            sortDirection: getOppositeSortDirection(currentConfig.sortDirection)
-        };
-    }
-    // New column, use default direction.
+function getNextSortConfig(currentConfig, cellId, defaultDirection = SortDirections.DESC) {
+    if (currentConfig.sortedCell === cellId) return {
+        sortedCell: cellId,
+        sortDirection: getOppositeSortDirection(currentConfig.sortDirection)
+    };
     return {
         sortedCell: cellId,
         sortDirection: defaultDirection
     };
 }
-/**
- * Generic sort function that sorts an array by a specified key.
- *
- * @param items - Array to sort
- * @param key - Key to sort by
- * @param direction - Sort direction
- * @param sortType - Type of sorting ('date', 'number', 'string', 'boolean')
- *
- * @example
- * ```ts
- * const items = [
- *   { id: 1, name: 'Alice', createdAt: '2024-01-01' },
- *   { id: 2, name: 'Bob', createdAt: '2024-01-15' },
- * ];
- *
- * const sorted = sortItems(items, 'createdAt', 'desc', 'date');
- * ```
- *
- */ function sortItems(items, key, direction, sortType = "string") {
-    const comparator = sortType === "date" ? sortByDate(direction) : sortType === "number" ? sortByNumber(direction) : sortType === "boolean" ? sortByBoolean(direction) : sortByString(direction);
+function sortItems(items, key, direction, sortType = "string") {
+    const comparator = "date" === sortType ? sortByDate(direction) : "number" === sortType ? sortByNumber(direction) : "boolean" === sortType ? sortByBoolean(direction) : sortByString(direction);
     return [
         ...items
     ].sort((a, b)=>{
@@ -227,10 +83,5 @@ import { SortDirections } from "../7.js";
         return comparator(aVal, bVal);
     });
 }
-
-// Re-export sort directions from constants for convenience.
-
-
-
-export { getNextSortConfig, getOppositeSortDirection, sortByBoolean, sortByDate, sortByNumber, sortByString, sortItems, toggleSortDirection };
 export { SortDirections } from "../7.js";
+export { getNextSortConfig, getOppositeSortDirection, sortByBoolean, sortByDate, sortByNumber, sortByString, sortItems, toggleSortDirection };

package/dist/u.js

@@ -1,88 +1,35 @@
 /*!
-  @versini/ui-datagrid v4.2.12
+  @versini/ui-datagrid v4.2.13
   © 2026 gizmette.com
 */
 
 import clsx from "clsx";
 import { useContext, useEffect, useLayoutEffect, useRef } from "react";
 import { DataGridContext } from "./8.js";
-
-
-
-/**
- * Get the CSS class for a DataGrid body element. Uses display:contents so the
- * body doesn't interfere with the grid flow. Rows will use subgrid when columns
- * are provided, or define their own grid otherwise.
- *
- * @param className - Additional class name to merge
- *
- */ function getBodyClass(className) {
+function getBodyClass(className) {
     return clsx("contents", className);
 }
-
-
-
-
-/**
- * Snap a CSS pixel value to the nearest device pixel.
- *
- * `getBoundingClientRect()` can produce sub-pixel widths that fluctuate
- * slightly across renders (font rasterization, fractional transforms, zoom).
- * For sticky header/footer alignment we don't need infinite precision — we need
- * stability.
- *
- * By quantizing to the device pixel grid we reduce "width jitter" that would
- * otherwise cause repeated state updates and re-renders.
- *
- * @internal
- *
- */ function quantizeWidthToDevicePixels(width, devicePixelRatio = 1) {
-    // Guard against invalid DPR values.
+function quantizeWidthToDevicePixels(width, devicePixelRatio = 1) {
     const dpr = Number.isFinite(devicePixelRatio) && devicePixelRatio > 0 ? devicePixelRatio : 1;
-    /**
-	 * NOTE: `window.devicePixelRatio` can be < 1 in some zoom/scaling scenarios.
-	 * We intentionally accept any DPR > 0 rather than clamping to 1 so that we
-	 * still snap to the real device pixel grid.
-	 */ const quantum = 1 / dpr;
+    const quantum = 1 / dpr;
     const snapped = Math.round(width / quantum) * quantum;
-    // Clamp floating error (e.g. 33.50000000004).
     return Number(snapped.toFixed(4));
 }
-/**
- * Hook to measure column widths from the first body row's cells. This is needed
- * because sticky header/footer are absolutely positioned and can't use CSS
- * subgrid. We measure the body cells (which ARE in the grid flow) and report
- * the widths so header/footer can use the same pixel values.
- *
- * @param bodyRef - Ref to the body element containing the rows
- * @param contentDependency - Dependency that changes when content changes (children or renderedContent)
- *
- */ function useColumnMeasurement(bodyRef, contentDependency, noData = false) {
+function useColumnMeasurement(bodyRef, contentDependency, noData = false) {
     const ctx = useContext(DataGridContext);
     const prevWidthsRef = useRef([]);
     const observerRef = useRef(null);
     const needsMeasurement = Boolean(ctx.columns && (ctx.stickyHeader || ctx.stickyFooter));
-    /**
-	 * Re-query the current first row's cells, report any changed widths, and
-	 * return the cells. Held in a ref so the persistent ResizeObserver always runs
-	 * the latest logic without being recreated as the window slides.
-	 */ const measureRef = useRef(()=>[]);
+    const measureRef = useRef(()=>[]);
     measureRef.current = ()=>{
         const element = bodyRef.current;
-        if (noData || !element || !needsMeasurement || !ctx.setMeasuredColumnWidths) {
-            return [];
-        }
+        if (noData || !element || !needsMeasurement || !ctx.setMeasuredColumnWidths) return [];
         const firstRow = element.querySelector('[role="row"]');
         const cells = firstRow ? Array.from(firstRow.querySelectorAll('[role="cell"], [role="columnheader"], [role="gridcell"]')) : [];
-        if (cells.length === 0) {
-            return [];
-        }
-        const dpr = typeof window !== "undefined" ? window.devicePixelRatio ?? 1 : 1;
+        if (0 === cells.length) return [];
+        const dpr = "u" > typeof window ? window.devicePixelRatio ?? 1 : 1;
         const widths = cells.map((cell)=>quantizeWidthToDevicePixels(cell.getBoundingClientRect().width, dpr));
-        /**
-		 * Only update state if widths have actually changed to prevent infinite
-		 * loops.
-		 */ const prevWidths = prevWidthsRef.current;
+        const prevWidths = prevWidthsRef.current;
         const hasChanged = widths.length !== prevWidths.length || widths.some((w, i)=>w !== prevWidths[i]);
         if (hasChanged) {
             prevWidthsRef.current = widths;
@@ -90,30 +37,15 @@ import { DataGridContext } from "./8.js";
         }
         return cells;
     };
-    /**
-	 * Keep a single ResizeObserver for the hook's lifetime and re-point it at the
-	 * current first row's cells whenever the rendered content changes (e.g. a
-	 * virtualized window sliding). The cells are the observed targets because the
-	 * body is `display: contents` (it has no box of its own); re-pointing the same
-	 * observer avoids tearing one down and allocating a new one on every scroll
-	 * shift.
-	 */ // biome-ignore lint/correctness/useExhaustiveDependencies: measureRef is stable; contentDependency re-points the observer when the rendered rows change
     useLayoutEffect(()=>{
-        if (!needsMeasurement) {
-            observerRef.current?.disconnect();
-            return;
-        }
-        if (!observerRef.current) {
-            observerRef.current = new ResizeObserver(()=>{
-                measureRef.current();
-            });
-        }
+        if (!needsMeasurement) return void observerRef.current?.disconnect();
+        if (!observerRef.current) observerRef.current = new ResizeObserver(()=>{
+            measureRef.current();
+        });
         const observer = observerRef.current;
         observer.disconnect();
         const cells = measureRef.current();
-        for (const cell of cells){
-            observer.observe(cell);
-        }
+        for (const cell of cells)observer.observe(cell);
     }, [
         ctx.columns,
         ctx.stickyHeader,
@@ -123,13 +55,9 @@ import { DataGridContext } from "./8.js";
         needsMeasurement,
         noData
     ]);
-    // Disconnect on unmount.
-    useEffect(()=>{
-        return ()=>{
+    useEffect(()=>()=>{
             observerRef.current?.disconnect();
             observerRef.current = null;
-        };
-    }, []);
+        }, []);
 }
-
 export { getBodyClass, useColumnMeasurement };

package/dist/y.js

@@ -1,34 +1,24 @@
 /*!
-  @versini/ui-datagrid v4.2.12
+  @versini/ui-datagrid v4.2.13
   © 2026 gizmette.com
 */
 
 import clsx from "clsx";
 import { BlurEffects, CellWrapper } from "./7.js";
-
-
-
-
-/**
- * Theme mode helpers - reused across many functions.
- */ const isDark = (m)=>m === "dark";
-const isLight = (m)=>m === "light";
-const isSys = (m)=>m === "system";
-const isAlt = (m)=>m === "alt-system";
+const isDark = (m)=>"dark" === m;
+const isLight = (m)=>"light" === m;
+const isSys = (m)=>"system" === m;
+const isAlt = (m)=>"alt-system" === m;
 const isDarkish = (m)=>isDark(m) || isSys(m);
 const isLightish = (m)=>isLight(m) || isAlt(m);
 const hasBlurEffect = (b)=>Boolean(b && b !== BlurEffects.NONE);
 const isHeaderCell = (c)=>c === CellWrapper.HEADER;
 const isFooterCell = (c)=>c === CellWrapper.FOOTER;
-/**
- * Text color classes - reused in multiple functions.
- */ const TXT_LIGHT = "text-copy-light";
+const TXT_LIGHT = "text-copy-light";
 const TXT_DARK = "text-copy-dark";
 const TXT_SYS = "text-copy-light dark:text-copy-dark";
 const TXT_ALT = "text-copy-dark dark:text-copy-light";
-/**
- * Text color classes based on theme mode.
- */ const getTextColorClasses = ({ mode })=>clsx({
+const getTextColorClasses = ({ mode })=>clsx({
         [TXT_LIGHT]: isDark(mode),
         [TXT_DARK]: isLight(mode),
         [TXT_SYS]: isSys(mode),
@@ -39,82 +29,41 @@ const getTextColorClassesForHeaderFooter = ({ mode, hasBlur })=>clsx({
         [TXT_SYS]: isSys(mode) && hasBlur,
         "text-copy-dark dark:text-copy-dark": (isSys(mode) || isAlt(mode)) && !hasBlur
     });
-/**
- * Surface background classes (main container backgrounds).
- */ const getSurfaceBackgroundClasses = ({ mode })=>clsx({
+const getSurfaceBackgroundClasses = ({ mode })=>clsx({
         "bg-surface-darker": isDarkish(mode),
         "bg-surface-light": isLightish(mode),
         "dark:bg-surface-light": isSys(mode),
         "dark:bg-surface-darker": isAlt(mode)
     });
-/**
- * Header/footer background classes (with optional blur transparency).
- */ const getHeaderFooterBackgroundClasses = ({ hasBlur, sticky })=>clsx({
+const getHeaderFooterBackgroundClasses = ({ hasBlur, sticky })=>clsx({
         "bg-surface-medium/50 dark:bg-surface-medium/50": hasBlur && sticky,
         "bg-surface-medium-light dark:bg-surface-medium-light": !hasBlur
     });
-/**
- * Border color classes for rows.
- */ const getBorderClasses = ({ mode })=>clsx({
+const getBorderClasses = ({ mode })=>clsx({
         "border-table-dark": isDarkish(mode),
         "border-table-light": isLightish(mode),
         "dark:border-table-light": isSys(mode),
         "dark:border-table-dark": isAlt(mode)
     });
-/**
- * Hover classes for body rows.
- *
- * The hover lifts both the background and the text color so the highlighted row
- * reads as a single, cohesive change (mirroring the light-mode behavior where
- * the font color shifts too).
- *
- * The shade is tuned per surface so the lift stays proportional:
- * - Dark surfaces (slate-900 base) only step up to `table-dark-hover`
- *   (slate-700) instead of the much brighter `surface-medium` (slate-500),
- *   which felt harsh against very dark tables, and brighten the text to
- *   `copy-lighter` (white).
- * - Light surfaces (slate-300 base) keep the established `surface-medium`
- *   (slate-500) background with `copy-light` (slate-200) text.
- *
- * Pairing matches `getBorderClasses`/`getSurfaceBackgroundClasses` so the hover
- * always tracks the active surface, including the OS-driven `dark:` flips that
- * `system` and `alt-system` perform.
- *
- */ const getRowHoverClasses = ({ mode })=>clsx(/**
-		 * Smooth the hover so quick mouse sweeps fade rather than flash. Animating
-		 * the row's background- and (inherited) text-color is enough; cells stay
-		 * transparent and follow the row's transitioning color.
-		 */ "transition-colors duration-300 ease-in-out motion-reduce:transition-none", {
+const getRowHoverClasses = ({ mode })=>clsx("transition-colors duration-300 ease-in-out motion-reduce:transition-none", {
         "hover:bg-table-dark-hover hover:text-copy-lighter": isDarkish(mode),
         "hover:bg-surface-medium hover:text-copy-light": isLightish(mode),
         "dark:hover:bg-surface-medium dark:hover:text-copy-light": isSys(mode),
         "dark:hover:bg-table-dark-hover dark:hover:text-copy-lighter": isAlt(mode)
     });
-/**
- * Blur effect classes for sticky elements.
- */ const getBlurClasses = ({ blurEffect })=>clsx({
+const getBlurClasses = ({ blurEffect })=>clsx({
         "backdrop-blur-sm": blurEffect === BlurEffects.SMALL,
         "backdrop-blur-md": blurEffect === BlurEffects.MEDIUM,
         "backdrop-blur-lg": blurEffect === BlurEffects.LARGE
     });
-/**
- * Loading text classes for loading state. Rendered as a high-contrast pill with
- * a fixed dark background and light text so the message stays legible against
- * the blurred content behind it regardless of the grid mode.
- */ const getLoadingTextClasses = ()=>"px-5 py-2 rounded-full shadow-lg text-sm font-semibold bg-surface-darker text-copy-light";
-/**
- * Overlay classes for loading state. Uses z-30/z-40 to layer above the sticky
- * header/footer (z-20), which sit later in the DOM within the same stacking
- * context and would otherwise paint on top of an equal-z overlay.
- */ const getOverlayClasses = ()=>({
+const getLoadingTextClasses = ()=>"px-5 py-2 rounded-full shadow-lg text-sm font-semibold bg-surface-darker text-copy-light";
+const getOverlayClasses = ()=>({
         inner: "relative",
         overlay: clsx("absolute inset-0 z-30 cursor-not-allowed rounded-lg", "backdrop-blur-xs bg-white/30 dark:bg-black/30"),
         loadingWrapper: clsx("absolute z-40 top-0 left-0 right-0 h-[min(100%,100vh)]", "flex items-center justify-center", "pointer-events-none"),
         loadingText: getLoadingTextClasses()
     });
-/**
- * Generates classes for the main DataGrid wrapper and grid.
- */ const getDataGridClasses = ({ mode, className, wrapperClassName, stickyHeader, stickyFooter, loading })=>{
+const getDataGridClasses = ({ mode, className, wrapperClassName, stickyHeader, stickyFooter, loading })=>{
     const overlayClasses = loading ? getOverlayClasses() : null;
     const hasSticky = stickyHeader || stickyFooter;
     return {
@@ -136,20 +85,16 @@ const getTextColorClassesForHeaderFooter = ({ mode, hasBlur })=>clsx({
         }))
     };
 };
-/**
- * Generates classes for the DataGridHeader wrapper.
- */ const getHeaderClasses = ({ className, stickyHeader, mode, blurEffect })=>{
+const getHeaderClasses = ({ className, stickyHeader, mode, blurEffect })=>{
     const hasBlur = hasBlurEffect(blurEffect);
     const textClasses = getTextColorClassesForHeaderFooter({
         mode,
         hasBlur
     });
-    if (!stickyHeader) {
-        return clsx("contents", getHeaderFooterBackgroundClasses({
-            hasBlur,
-            sticky: false
-        }), textClasses, className);
-    }
+    if (!stickyHeader) return clsx("contents", getHeaderFooterBackgroundClasses({
+        hasBlur,
+        sticky: false
+    }), textClasses, className);
     return clsx("flex flex-col border-b border-table-medium shadow-md", "absolute left-0 right-0 z-20 top-0 rounded-t-lg", getHeaderFooterBackgroundClasses({
         hasBlur,
         sticky: true
@@ -157,26 +102,20 @@ const getTextColorClassesForHeaderFooter = ({ mode, hasBlur })=>clsx({
         blurEffect
     }), className);
 };
-/**
- * Generates classes for the caption element inside DataGridHeader.
- */ const getCaptionClasses = ({ captionClassName, mode, hasBlur, stickyHeader })=>clsx("py-2 text-sm text-center font-bold col-span-full", getTextColorClassesForHeaderFooter({
+const getCaptionClasses = ({ captionClassName, mode, hasBlur, stickyHeader })=>clsx("py-2 text-sm text-center font-bold col-span-full", getTextColorClassesForHeaderFooter({
         mode,
         hasBlur
     }), !stickyHeader && getHeaderFooterBackgroundClasses({
         hasBlur,
         sticky: false
     }), captionClassName);
-/**
- * Generates classes for the DataGridFooter.
- */ const getFooterClasses = ({ className, stickyFooter, mode, blurEffect })=>{
+const getFooterClasses = ({ className, stickyFooter, mode, blurEffect })=>{
     const hasBlur = hasBlurEffect(blurEffect);
     const textClasses = getTextColorClassesForHeaderFooter({
         mode,
         hasBlur
     });
-    if (!stickyFooter) {
-        return clsx("contents", textClasses, className);
-    }
+    if (!stickyFooter) return clsx("contents", textClasses, className);
     return clsx("flex flex-col border-t border-table-medium", "absolute left-0 right-0 z-20 bottom-0 rounded-b-lg", "shadow-[0_-10px_15px_-3px_rgba(0,0,0,0.1)]", getHeaderFooterBackgroundClasses({
         hasBlur,
         sticky: true
@@ -185,37 +124,30 @@ const getTextColorClassesForHeaderFooter = ({ mode, hasBlur })=>clsx({
     }), textClasses, className);
 };
 const ROW_LAYOUT = "group grid items-center";
-/**
- * Generates classes for DataGridRow.
- */ const getRowClasses = ({ mode, className, cellWrapper, isLastRow, stickyHeader, stickyFooter })=>{
+const getRowClasses = ({ mode, className, cellWrapper, isLastRow, stickyHeader, stickyFooter })=>{
     if (isHeaderCell(cellWrapper) || isFooterCell(cellWrapper)) {
         const isHeader = isHeaderCell(cellWrapper);
         const parentUsesContents = isHeader ? !stickyHeader : !stickyFooter;
-        if (parentUsesContents) {
-            return clsx(ROW_LAYOUT, getHeaderFooterBackgroundClasses({
-                hasBlur: false,
-                sticky: false
-            }), isHeader ? "border-b border-table-medium shadow-md" : "border-t border-table-medium", className);
-        }
+        if (parentUsesContents) return clsx(ROW_LAYOUT, getHeaderFooterBackgroundClasses({
+            hasBlur: false,
+            sticky: false
+        }), isHeader ? "border-b border-table-medium shadow-md" : "border-t border-table-medium", className);
         return clsx(ROW_LAYOUT, className);
     }
-    const borderClasses = isLastRow !== undefined ? isLastRow ? "border-b border-b-transparent dark:border-b-transparent" : "border-b" : "border-b last:border-0";
+    const borderClasses = void 0 !== isLastRow ? isLastRow ? "border-b border-b-transparent dark:border-b-transparent" : "border-b" : "border-b last:border-0";
     return clsx(ROW_LAYOUT, borderClasses, getRowHoverClasses({
         mode
     }), getBorderClasses({
         mode
     }), className);
 };
-/**
- * Generates classes for DataGridCell.
- */ const getCellClasses = ({ cellWrapper, className, compact, align, mode, borderLeft, borderRight })=>{
-    return clsx({
+const getCellClasses = ({ cellWrapper, className, compact, align, mode, borderLeft, borderRight })=>clsx({
         "px-2 py-1": compact,
         "px-4 py-3": !compact
     }, {
-        "text-left justify-start": align === "left" || !align,
-        "text-center justify-center": align === "center",
-        "text-right justify-end": align === "right"
+        "text-left justify-start": "left" === align || !align,
+        "text-center justify-center": "center" === align,
+        "text-right justify-end": "right" === align
     }, {
         "font-bold": isHeaderCell(cellWrapper) || isFooterCell(cellWrapper)
     }, "first:group-data-active:relative", "first:group-data-active:before:absolute first:group-data-active:before:left-0 first:group-data-active:before:top-0 first:group-data-active:before:bottom-0 first:group-data-active:before:w-1", "first:group-data-active:self-stretch first:group-data-active:flex first:group-data-active:items-center", {
@@ -234,10 +166,5 @@ const ROW_LAYOUT = "group grid items-center";
         "border-r border-r-table-dark dark:border-r-table-light": borderRight && isSys(mode),
         "border-r border-r-table-light dark:border-r-table-dark": borderRight && isAlt(mode)
     }, className);
-};
-/**
- * Returns the appropriate ARIA role for the cell based on the cell wrapper
- * type.
- */ const getCellRole = (cellWrapper)=>isHeaderCell(cellWrapper) ? "columnheader" : "gridcell";
-
+const getCellRole = (cellWrapper)=>isHeaderCell(cellWrapper) ? "columnheader" : "gridcell";
 export { getCaptionClasses, getCellClasses, getCellRole, getDataGridClasses, getFooterClasses, getHeaderClasses, getRowClasses, getTextColorClassesForHeaderFooter };