@teselagen/ui 0.8.6-beta.12 → 0.8.6-beta.13

package/index.cjs.js

@@ -22228,13 +22228,27 @@ function applyOrderBy(records, _order_by) {
       directions.push(direction);
       iteratees.push((record) => {
         const value = record[field];
+        if (isNull(value) || value === void 0) {
+          return direction === "asc" ? -Infinity : -Infinity;
+        }
         if (isString$1(value) && /\d/.test(value)) {
           return value.replace(/(\d+)/g, (num) => num.padStart(10, "0"));
         }
         return value;
       });
     });
-    records = orderBy$1(records, iteratees, directions);
+    let sortedRecords = orderBy$1(records, iteratees, directions);
+    order_by.forEach((item) => {
+      const field = Object.keys(item)[0];
+      const direction = item[field];
+      if (direction === "desc") {
+        sortedRecords = [
+          ...sortedRecords.filter((record) => !isNull(record[field]) && record[field] !== void 0),
+          ...sortedRecords.filter((record) => isNull(record[field]) || record[field] === void 0)
+        ];
+      }
+    });
+    records = sortedRecords;
   }
   return records;
 }

package/index.es.js

@@ -22210,13 +22210,27 @@ function applyOrderBy(records, _order_by) {
       directions.push(direction);
       iteratees.push((record) => {
         const value = record[field];
+        if (isNull(value) || value === void 0) {
+          return direction === "asc" ? -Infinity : -Infinity;
+        }
         if (isString$1(value) && /\d/.test(value)) {
           return value.replace(/(\d+)/g, (num) => num.padStart(10, "0"));
         }
         return value;
       });
     });
-    records = orderBy$1(records, iteratees, directions);
+    let sortedRecords = orderBy$1(records, iteratees, directions);
+    order_by.forEach((item) => {
+      const field = Object.keys(item)[0];
+      const direction = item[field];
+      if (direction === "desc") {
+        sortedRecords = [
+          ...sortedRecords.filter((record) => !isNull(record[field]) && record[field] !== void 0),
+          ...sortedRecords.filter((record) => isNull(record[field]) || record[field] === void 0)
+        ];
+      }
+    });
+    records = sortedRecords;
   }
   return records;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teselagen/ui",
-  "version": "0.8.6-beta.12",
+  "version": "0.8.6-beta.13",
   "main": "./src/index.js",
   "type": "module",
   "exports": {

package/src/DataTable/utils/filterLocalEntitiesToHasura.js

@@ -230,6 +230,8 @@ function applyWhereClause(records, where) {
 // order_by looks like this: [{ some_field: "asc" }, { some_other_field: "desc" }] or {some_field: "asc"}
 // returns the records sorted by the order_by clause
 function applyOrderBy(records, _order_by) {
+  // console.log('records start:', records)
+  // console.log('_order_by:', _order_by)
   const order_by = isArray(_order_by)
     ? _order_by
     : isEmpty(_order_by)
@@ -251,6 +253,10 @@ function applyOrderBy(records, _order_by) {
       // Create a custom iteratee function for natural sorting
       iteratees.push(record => {
         const value = record[field];
+        // Handle null values based on sort direction
+        if (isNull(value) || value === undefined) {
+          return direction === 'asc' ? -Infinity : -Infinity;
+        }
         // Use natural sorting only for strings that contain numbers
         if (isString(value) && /\d/.test(value)) {
           // Return the value in a format that can be naturally sorted
@@ -260,9 +266,26 @@ function applyOrderBy(records, _order_by) {
         return value;
       });
     });
-
-    // Use the custom iteratees for natural sorting
-    records = orderBy(records, iteratees, directions);
+    
+    // First sort normally
+    let sortedRecords = orderBy(records, iteratees, directions);
+    
+    // Then ensure entries with a value for the field come before entries without a value
+    // for any field sorted in descending order
+    order_by.forEach((item) => {
+      const field = Object.keys(item)[0];
+      const direction = item[field];
+      
+      if (direction === 'desc') {
+        // For descending sorts, we want entries with values to appear before entries without values
+        sortedRecords = [
+          ...sortedRecords.filter(record => !isNull(record[field]) && record[field] !== undefined),
+          ...sortedRecords.filter(record => isNull(record[field]) || record[field] === undefined)
+        ];
+      }
+    });
+    
+    records = sortedRecords;
   }
   return records;
 }

package/src/DataTable/utils/filterLocalEntitiesToHasura.test.js

@@ -379,42 +379,152 @@ describe("filterLocalEntitiesToHasura", () => {
     ]);
     expect(result.entityCount).toBe(3);
   });
-  it("should order by age ascending", () => {
-    const result = filterLocalEntitiesToHasura(records, {
-      order_by: { age: "asc" }
-    });
+  it("should order by age ascending and put null vals last by default", () => {
+    const result = filterLocalEntitiesToHasura(
+      [{ id: 111, name: "Null Age", age: null, city: "Unknown" }, ...records],
+      {
+        order_by: { age: "asc" }
+      }
+    );
     expect(result.entities).toEqual([
       records[3],
       records[1],
       records[0],
-      records[2]
+      records[2],
+      { id: 111, name: "Null Age", age: null, city: "Unknown" }
     ]);
     expect(result.entitiesAcrossPages).toEqual([
       records[3],
       records[1],
       records[0],
-      records[2]
+      records[2],
+      { id: 111, name: "Null Age", age: null, city: "Unknown" }
     ]);
-    expect(result.entityCount).toBe(4);
+    expect(result.entityCount).toBe(5);
   });
-
-  it("should order by age descending", () => {
-    const result = filterLocalEntitiesToHasura(records, {
-      order_by: { age: "desc" }
-    });
+  it("should order by age desc and put null/undefined vals last by default", () => {
+    const result = filterLocalEntitiesToHasura(
+      [
+        { id: 111, name: "Null Age", age: null, city: "Unknown" },
+        { id: 1121, name: "Undefined Age", age: undefined, city: "Unknown" },
+        ...records
+      ],
+      {
+        order_by: { age: "desc" }
+      }
+    );
     expect(result.entities).toEqual([
       records[2],
       records[0],
       records[1],
-      records[3]
+      records[3],
+      { id: 111, name: "Null Age", age: null, city: "Unknown" },
+      { id: 1121, name: "Undefined Age", age: undefined, city: "Unknown" }
     ]);
-    expect(result.entitiesAcrossPages).toEqual([
+    expect(result.entityCount).toBe(6);
+  });
+
+  it.only("should order by updatedAt descending, putting null/undefined vals last ", () => {
+    const result = filterLocalEntitiesToHasura(
+      [
+        {
+          name: "-10_signal",
+          color: "#4ECDC4",
+          isGenbankStandardType: true,
+          __typename: "featureTypeOverride"
+        },
+        {
+          name: "-35_signal",
+          color: "#F7FFF7",
+          isGenbankStandardType: true,
+          __typename: "featureTypeOverride"
+        },
+        {
+          name: "3'clip",
+          color: "#FF6B6B",
+          isGenbankStandardType: true,
+          __typename: "featureTypeOverride"
+        },
+        {
+          name: "3'UTR",
+          color: "#FFE66D",
+          isGenbankStandardType: true,
+          __typename: "featureTypeOverride"
+        },
+
+        {
+          __typename: "featureTypeOverride",
+          id: "33a90fcb-fc26-406f-a6d5-41ac4ba8ea64",
+          name: "lalala",
+          description: null,
+          color: "#81bb41",
+          genbankEquivalentType: null,
+          updatedAt: "2025-06-03T01:02:24.737499+00:00",
+          isHidden: false,
+          isCustomType: true
+        }
+      ],
+      {
+        order_by: [{ updatedAt: "desc" }]
+      }
+    );
+    expect(result.entities).toEqual([
+      {
+        __typename: "featureTypeOverride",
+        id: "33a90fcb-fc26-406f-a6d5-41ac4ba8ea64",
+        name: "lalala",
+        description: null,
+        color: "#81bb41",
+        genbankEquivalentType: null,
+        updatedAt: "2025-06-03T01:02:24.737499+00:00",
+        isHidden: false,
+        isCustomType: true
+      },
+      {
+        name: "-10_signal",
+        color: "#4ECDC4",
+        isGenbankStandardType: true,
+        __typename: "featureTypeOverride"
+      },
+      {
+        name: "-35_signal",
+        color: "#F7FFF7",
+        isGenbankStandardType: true,
+        __typename: "featureTypeOverride"
+      },
+      {
+        name: "3'clip",
+        color: "#FF6B6B",
+        isGenbankStandardType: true,
+        __typename: "featureTypeOverride"
+      },
+      {
+        name: "3'UTR",
+        color: "#FFE66D",
+        isGenbankStandardType: true,
+        __typename: "featureTypeOverride"
+      }
+    ]);
+  });
+  it("should order by age descending, putting null/undefined vals last ", () => {
+    const result = filterLocalEntitiesToHasura(
+      [
+        { id: 111, name: "Null Age", age: null, city: "Unknown" },
+        { id: 1121, name: "Undefined Age", age: undefined, city: "Unknown" },
+        ...records
+      ],
+      {
+        order_by: { age: "desc" }
+      }
+    );
+    expect(result.entities).toEqual([
       records[2],
       records[0],
       records[1],
-      records[3]
+      records[3],
+      { id: 111, name: "Null Age", age: null, city: "Unknown" },
+      { id: 1121, name: "Undefined Age", age: undefined, city: "Unknown" }
     ]);
-    expect(result.entityCount).toBe(4);
   });
 
   it("should order by name ascending", () => {

package/src/DataTable/utils/tableQueryParamsToHasuraClauses.js

@@ -21,18 +21,18 @@ export function tableQueryParamsToHasuraClauses({
     const uniqueFieldsByPath = {};
 
     // Split the search term by comma to support multi-term searching
-    const searchTerms = searchTerm.split(',');
+    const searchTerms = searchTerm.split(",");
 
     schema.fields.forEach(field => {
       const { type, path, searchDisabled } = field;
       if (uniqueFieldsByPath[path]) return; // Skip if already added
       uniqueFieldsByPath[path] = true;
       if (searchDisabled || field.filterDisabled || type === "color") return;
-      
+
       // Process each search term
       searchTerms.forEach(term => {
         const filterValue = term.trim(); // Trim the term to handle spaces after commas
-        
+
         if (type === "string" || type === "lookup") {
           const o = set({}, path, { _ilike: `%${filterValue}%` });
           searchTermFilters.push(o);