@tanstack/react-table 8.2.1 → 8.2.2

package/build/esm/index.js

@@ -2361,7 +2361,12 @@ const textCaseSensitive = (rowA, rowB, columnId) => {
 };
 
 const datetime = (rowA, rowB, columnId) => {
-  return compareBasic(rowA.getValue(columnId).getTime(), rowB.getValue(columnId).getTime());
+  const a = rowA.getValue(columnId);
+  const b = rowB.getValue(columnId); // Can handle nullish values
+  // Use > and < because == (and ===) doesn't work with
+  // Date objects (would require calling getTime()).
+
+  return a > b ? 1 : a < b ? -1 : 0;
 };
 
 const basic = (rowA, rowB, columnId) => {
@@ -2522,18 +2527,17 @@ const Sorting = {
         // }
         // this needs to be outside of table.setSorting to be in sync with rerender
         const nextSortingOrder = column.getNextSortingOrder();
+        const hasManualValue = typeof desc !== 'undefined' && desc !== null;
         table.setSorting(old => {
-          var _table$options$enable, _table$options$enable2;
-
           // Find any existing sorting for this column
           const existingSorting = old == null ? void 0 : old.find(d => d.id === column.id);
           const existingIndex = old == null ? void 0 : old.findIndex(d => d.id === column.id);
-          const hasDescDefined = typeof desc !== 'undefined' && desc !== null;
           let newSorting = []; // What should we do with this sort action?
 
           let sortAction;
+          let nextDesc = hasManualValue ? desc : nextSortingOrder === 'desc'; // Multi-mode
 
-          if (column.getCanMultiSort() && multi) {
+          if (old != null && old.length && column.getCanMultiSort() && multi) {
             if (existingSorting) {
               sortAction = 'toggle';
             } else {
@@ -2551,63 +2555,71 @@ const Sorting = {
           } // Handle toggle states that will remove the sorting
 
 
-          if (sortAction === 'toggle' && ( // Must be toggling
-          (_table$options$enable = table.options.enableSortingRemoval) != null ? _table$options$enable : true) && // If enableSortRemove, enable in general
-          !hasDescDefined && ( // Must not be setting desc
-          multi ? (_table$options$enable2 = table.options.enableMultiRemove) != null ? _table$options$enable2 : true : true) && // If multi, don't allow if enableMultiRemove
-          !nextSortingOrder // Finally, detect if it should indeed be removed
-          ) {
-            sortAction = 'remove';
+          if (sortAction === 'toggle') {
+            // If we are "actually" toggling (not a manual set value), should we remove the sorting?
+            if (!hasManualValue) {
+              // Is our intention to remove?
+              if (!nextSortingOrder) {
+                sortAction = 'remove';
+              }
+            }
           }
 
-          if (sortAction === 'replace') {
-            newSorting = [{
-              id: column.id,
-              desc: hasDescDefined ? desc : nextSortingOrder === 'desc'
-            }];
-          } else if (sortAction === 'add' && old != null && old.length) {
+          if (sortAction === 'add') {
             var _table$options$maxMul;
 
             newSorting = [...old, {
               id: column.id,
-              desc: hasDescDefined ? desc : nextSortingOrder === 'desc'
+              desc: nextDesc
             }]; // Take latest n columns
 
             newSorting.splice(0, newSorting.length - ((_table$options$maxMul = table.options.maxMultiSortColCount) != null ? _table$options$maxMul : Number.MAX_SAFE_INTEGER));
-          } else if (sortAction === 'toggle' && old != null && old.length) {
+          } else if (sortAction === 'toggle') {
             // This flips (or sets) the
             newSorting = old.map(d => {
               if (d.id === column.id) {
                 return { ...d,
-                  desc: hasDescDefined ? desc : nextSortingOrder === 'desc'
+                  desc: nextDesc
                 };
               }
 
               return d;
             });
-          } else if (sortAction === 'remove' && old != null && old.length) {
+          } else if (sortAction === 'remove') {
             newSorting = old.filter(d => d.id !== column.id);
+          } else {
+            newSorting = [{
+              id: column.id,
+              desc: nextDesc
+            }];
           }
 
           return newSorting;
         });
       },
-      getNextSortingOrder: () => {
+      getFirstSortDir: () => {
         var _ref, _column$columnDef$sor;
 
         const sortDescFirst = (_ref = (_column$columnDef$sor = column.columnDef.sortDescFirst) != null ? _column$columnDef$sor : table.options.sortDescFirst) != null ? _ref : column.getAutoSortDir() === 'desc';
-        const firstSortDirection = sortDescFirst ? 'desc' : 'asc';
+        return sortDescFirst ? 'desc' : 'asc';
+      },
+      getNextSortingOrder: multi => {
+        var _table$options$enable, _table$options$enable2;
+
+        const firstSortDirection = column.getFirstSortDir();
         const isSorted = column.getIsSorted();
 
         if (!isSorted) {
           return firstSortDirection;
         }
 
-        if (isSorted === firstSortDirection) {
-          return isSorted === 'desc' ? 'asc' : 'desc';
-        } else {
+        if (isSorted !== firstSortDirection && ((_table$options$enable = table.options.enableSortingRemoval) != null ? _table$options$enable : true) && ( // If enableSortRemove, enable in general
+        multi ? (_table$options$enable2 = table.options.enableMultiRemove) != null ? _table$options$enable2 : true : true) // If multi, don't allow if enableMultiRemove))
+        ) {
           return false;
         }
+
+        return isSorted === 'desc' ? 'asc' : 'desc';
       },
       getCanSort: () => {
         var _column$columnDef$ena, _table$options$enable3;