Update __table sorting to handle missing values (#338)

* Update __table sorting to handle missing values

* always move null values to the end

Author: Annie Zhang

src/table.js

@@ -1,4 +1,4 @@
-import {ascending, descending, reverse} from "d3-array";
+import {reverse} from "d3-array";
 import {FileAttachment} from "./fileAttachment.js";
 import {isArqueroTable} from "./arquero.js";
 import {isArrowTable, loadArrow} from "./arrow.js";
@@ -488,6 +488,24 @@ function likeOperand(operand) {
   return {...operand, value: `%${operand.value}%`};
 }
 
+// Comparator function that moves null values (undefined, null, NaN) to the
+// end of the array.
+function defined(a, b) {
+  return (a == null || !(a >= a)) - (b == null || !(b >= b));
+}
+
+// Comparator function that sorts values in ascending order, with null values at
+// the end.
+function ascendingDefined(a, b) {
+  return defined(a, b) || (a < b ? -1 : a > b ? 1 : 0);
+}
+
+// Comparator function that sorts values in descending order, with null values
+// at the end.
+function descendingDefined(a, b) {
+  return defined(a, b) || (a > b ? -1 : a < b ? 1 : 0);
+}
+
 // Functions for checking type validity
 const isValidNumber = (value) => typeof value === "number" && !Number.isNaN(value);
 const isValidString = (value) => typeof value === "string";
@@ -623,7 +641,7 @@ export function __table(source, operations) {
     }
   }
   for (const {column, direction} of reverse(operations.sort)) {
-    const compare = direction === "desc" ? descending : ascending;
+    const compare = direction === "desc" ? descendingDefined : ascendingDefined;
     if (source === input) source = source.slice(); // defensive copy
     source.sort((a, b) => compare(a[column], b[column]));
   }

test/table-test.js

@@ -495,22 +495,41 @@ describe("__table", () => {
   });
 
   it("__table sort", () => {
-    const operations1 = {...EMPTY_TABLE_DATA.operations, sort: [{column: "a", direction: "desc"}]};
+    const operationsDesc = {...EMPTY_TABLE_DATA.operations, sort: [{column: "a", direction: "desc"}]};
     assert.deepStrictEqual(
-      __table(source, operations1),
+      __table(source, operationsDesc),
       [{a: 3, b: 6, c: 9}, {a: 2, b: 4, c: 6}, {a: 1, b: 2, c: 3}]
     );
+    const operationsAsc = {...EMPTY_TABLE_DATA.operations, sort: [{column: "a", direction: "asc"}]};
+    assert.deepStrictEqual(
+      __table(source, operationsAsc),
+      [{a: 1, b: 2, c: 3}, {a: 2, b: 4, c: 6}, {a: 3, b: 6, c: 9}]
+    );
     const sourceExtended = [...source, {a: 1, b: 3, c: 3}, {a: 1, b: 5, c: 3}];
-    const operations2 = {
+    const operationsMulti = {
       ...EMPTY_TABLE_DATA.operations,
       sort: [{column: "a", direction: "desc"}, {column: "b", direction: "desc"}]
     };
     assert.deepStrictEqual(
-      __table(sourceExtended, operations2),
+      __table(sourceExtended, operationsMulti),
       [{a: 3, b: 6, c: 9}, {a: 2, b: 4, c: 6}, {a: 1, b: 5, c: 3}, {a: 1, b: 3, c: 3}, {a: 1, b: 2, c: 3}]
     );
   });
 
+  it("__table sort missing values", () => {
+    const sourceWithMissing = [{a: 1}, {a: null}, {a: undefined}, {a: 10}, {a: 5}, {a: NaN}, {a: null}, {a: 20}];
+    const operationsDesc = {...EMPTY_TABLE_DATA.operations, sort: [{column: "a", direction: "desc"}]};
+    assert.deepStrictEqual(
+      __table(sourceWithMissing, operationsDesc),
+      [{a: 20}, {a: 10}, {a: 5}, {a: 1}, {a: null}, {a: undefined}, {a: NaN}, {a: null}]
+    );
+    const operationsAsc = {...EMPTY_TABLE_DATA.operations, sort: [{column: "a", direction: "asc"}]};
+    assert.deepStrictEqual(
+      __table(sourceWithMissing, operationsAsc),
+      [{a: 1}, {a: 5}, {a: 10}, {a: 20}, {a: null}, {a: undefined}, {a: NaN}, {a: null}]
+    );
+  });
+
   it("__table sort does not mutate input", () => {
     const operations = {...EMPTY_TABLE_DATA.operations, sort: [{column: "a", direction: "desc"}]};
     assert.deepStrictEqual(