@homebound/beam 2.130.0 → 2.131.0

package/dist/components/Table/GridTable.d.ts

@@ -121,6 +121,7 @@ export declare type GridSortConfig<S> = {
     on: "client";
     /** The optional initial column (index in columns) and direction to sort. */
     initial?: [S | GridColumn<any>, Direction] | undefined;
+    caseSensitive?: boolean;
 } | {
     on: "server";
     /** The current sort by value + direction (if server-side sorting). */

package/dist/components/Table/GridTable.js

@@ -113,14 +113,14 @@ function GridTable(props) {
     const columnSizes = (0, columnSizes_1.useSetupColumnSizes)(style, columns, tableRef, resizeTarget);
     // Make a single copy of our current collapsed state, so we'll have a single observer.
     const collapsedIds = (0, hooks_1.useComputed)(() => rowState.collapsedIds, [rowState]);
-    const [sortState, setSortKey, sortOn] = (0, useSortState_1.useSortState)(columns, props.sorting);
+    const [sortState, setSortKey, sortOn, caseSensitive] = (0, useSortState_1.useSortState)(columns, props.sorting);
     const maybeSorted = (0, react_1.useMemo)(() => {
         if (sortOn === "client" && sortState) {
             // If using client-side sort, the sortState use S = number
-            return (0, sortRows_1.sortRows)(columns, rows, sortState);
+            return (0, sortRows_1.sortRows)(columns, rows, sortState, caseSensitive);
         }
         return rows;
-    }, [columns, rows, sortOn, sortState]);
+    }, [columns, rows, sortOn, sortState, caseSensitive]);
     let hasTotalsRow = false;
     // Filter rows - ensures parent rows remain in the list if any children match the filter.
     const filterRows = (0, react_1.useCallback)((acc, row) => {

package/dist/components/Table/sortRows.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from "react";
 import { GridCellContent, GridColumn, GridDataRow, Kinded } from "./GridTable";
 import { SortOn, SortState } from "./useSortState";
-export declare function sortRows<R extends Kinded>(columns: GridColumn<R>[], rows: GridDataRow<R>[], sortState: SortState<number>): GridDataRow<R>[];
+export declare function sortRows<R extends Kinded>(columns: GridColumn<R>[], rows: GridDataRow<R>[], sortState: SortState<number>, caseSensitive: boolean): GridDataRow<R>[];
 export declare function ensureClientSideSortValueIsSortable(sortOn: SortOn, isHeader: boolean, column: GridColumn<any>, idx: number, maybeContent: ReactNode | GridCellContent): void;

package/dist/components/Table/sortRows.js

@@ -3,26 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureClientSideSortValueIsSortable = exports.sortRows = void 0;
 const GridTable_1 = require("./GridTable");
 // Returns a shallow copy of the `rows` parameter sorted based on `sortState`
-function sortRows(columns, rows, sortState) {
-    const sorted = sortBatch(columns, rows, sortState);
+function sortRows(columns, rows, sortState, caseSensitive) {
+    const sorted = sortBatch(columns, rows, sortState, caseSensitive);
     // Recursively sort child rows
     sorted.forEach((row, i) => {
         if (row.children) {
-            sorted[i].children = sortRows(columns, row.children, sortState);
+            sorted[i].children = sortRows(columns, row.children, sortState, caseSensitive);
         }
     });
     return sorted;
 }
 exports.sortRows = sortRows;
-function sortBatch(columns, batch, sortState) {
+function sortBatch(columns, batch, sortState, caseSensitive) {
     // When client-side sort, the sort value is the column index
     const [value, direction] = sortState;
     const column = columns[value];
     const invert = direction === "DESC";
     // Make a shallow copy for sorting to avoid mutating the original list
     return [...batch].sort((a, b) => {
-        const v1 = sortValue((0, GridTable_1.applyRowFn)(column, a, {}, 0));
-        const v2 = sortValue((0, GridTable_1.applyRowFn)(column, b, {}, 0));
+        const v1 = sortValue((0, GridTable_1.applyRowFn)(column, a, {}, 0), caseSensitive);
+        const v2 = sortValue((0, GridTable_1.applyRowFn)(column, b, {}, 0), caseSensitive);
         const v1e = v1 === null || v1 === undefined;
         const v2e = v2 === null || v2 === undefined;
         if (a.pin || b.pin) {
@@ -43,7 +43,7 @@ function sortBatch(columns, batch, sortState) {
     });
 }
 /** Look at a row and get its sort value. */
-function sortValue(value) {
+function sortValue(value, caseSensitive) {
     // Check sortValue and then fallback on value
     let maybeFn = value;
     if (value && typeof value === "object") {
@@ -60,13 +60,14 @@ function sortValue(value) {
     }
     // Watch for functions that need to read from a potentially-changing proxy
     if (maybeFn instanceof Function) {
-        return maybeFn();
+        maybeFn = maybeFn();
     }
-    return maybeFn;
+    // If it is a string, then always lower case it for comparisons
+    return typeof maybeFn === "string" && !caseSensitive ? maybeFn.toLowerCase() : maybeFn;
 }
 function ensureClientSideSortValueIsSortable(sortOn, isHeader, column, idx, maybeContent) {
     if (process.env.NODE_ENV !== "production" && !isHeader && sortOn === "client" && column.clientSideSort !== false) {
-        const value = sortValue(maybeContent);
+        const value = sortValue(maybeContent, false);
         if (!canClientSideSort(value)) {
             throw new Error(`Column ${idx} passed an unsortable value, use GridCellContent or clientSideSort=false`);
         }

package/dist/components/Table/useSortState.d.ts

@@ -10,5 +10,5 @@ import { Direction, GridColumn, GridSortConfig, Kinded } from "./GridTable";
 export declare type SortState<S> = readonly [S, Direction];
 export declare type SortOn = "client" | "server" | undefined;
 /** Small custom hook that wraps the "setSortColumn inverts the current sort" logic. */
-export declare function useSortState<R extends Kinded, S>(columns: GridColumn<R, S>[], sorting?: GridSortConfig<S>): [SortState<S> | undefined, (value: S) => void, SortOn];
+export declare function useSortState<R extends Kinded, S>(columns: GridColumn<R, S>[], sorting?: GridSortConfig<S>): [SortState<S> | undefined, (value: S) => void, SortOn, boolean];
 export declare function deriveSortState<S>(currentSortState: SortState<S> | undefined, clickedKey: S, initialSortState: SortState<S> | undefined): SortState<S> | undefined;

package/dist/components/Table/useSortState.js

@@ -47,7 +47,9 @@ function useSortState(columns, sorting) {
     }, 
     // Note that sorting.onSort is not listed here, so we bind to whatever the 1st sorting.onSort was
     [initialSortState, sortState, onSort]);
-    return [sortState, setSortKey, sorting === null || sorting === void 0 ? void 0 : sorting.on];
+    // If sorting is done on the client, the by default the sort will NOT be case sensitive
+    const caseSensitive = (sorting === null || sorting === void 0 ? void 0 : sorting.on) === "client" ? !!sorting.caseSensitive : false;
+    return [sortState, setSortKey, sorting === null || sorting === void 0 ? void 0 : sorting.on, caseSensitive];
 }
 exports.useSortState = useSortState;
 // Exported for testing purposes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homebound/beam",
-  "version": "2.130.0",
+  "version": "2.131.0",
   "author": "Homebound",
   "license": "MIT",
   "main": "dist/index.js",