@teselagen/ui 0.8.6-beta.7 → 0.8.6-beta.9

package/index.cjs.js

@@ -19496,6 +19496,13 @@ function tableQueryParamsToHasuraClauses({
         case "isExactly":
           return { [filterOn]: { _eq: filterValue } };
         case "isEmpty":
+          if (filterOn.includes(".")) {
+            return {
+              _not: {
+                [filterOn.split(".")[0]]: {}
+              }
+            };
+          }
           return {
             _or: [
               { [filterOn]: { _eq: "" } },
@@ -22209,15 +22216,21 @@ __name(applyWhereClause, "applyWhereClause");
 function applyOrderBy(records, _order_by) {
   const order_by = isArray$2(_order_by) ? _order_by : isEmpty$1(_order_by) ? [] : [_order_by];
   if (order_by.length > 0) {
-    const fields = [];
     const directions = [];
+    const iteratees = [];
     order_by.forEach((item) => {
       const field = Object.keys(item)[0];
       const direction = item[field];
-      fields.push(field);
       directions.push(direction);
+      iteratees.push((record) => {
+        const value = record[field];
+        if (isString$1(value) && /\d/.test(value)) {
+          return value.replace(/(\d+)/g, (num) => num.padStart(10, "0"));
+        }
+        return value;
+      });
     });
-    records = orderBy$1(records, fields, directions);
+    records = orderBy$1(records, iteratees, directions);
   }
   return records;
 }

package/index.es.js

@@ -19478,6 +19478,13 @@ function tableQueryParamsToHasuraClauses({
         case "isExactly":
           return { [filterOn]: { _eq: filterValue } };
         case "isEmpty":
+          if (filterOn.includes(".")) {
+            return {
+              _not: {
+                [filterOn.split(".")[0]]: {}
+              }
+            };
+          }
           return {
             _or: [
               { [filterOn]: { _eq: "" } },
@@ -22191,15 +22198,21 @@ __name(applyWhereClause, "applyWhereClause");
 function applyOrderBy(records, _order_by) {
   const order_by = isArray$2(_order_by) ? _order_by : isEmpty$1(_order_by) ? [] : [_order_by];
   if (order_by.length > 0) {
-    const fields = [];
     const directions = [];
+    const iteratees = [];
     order_by.forEach((item) => {
       const field = Object.keys(item)[0];
       const direction = item[field];
-      fields.push(field);
       directions.push(direction);
+      iteratees.push((record) => {
+        const value = record[field];
+        if (isString$1(value) && /\d/.test(value)) {
+          return value.replace(/(\d+)/g, (num) => num.padStart(10, "0"));
+        }
+        return value;
+      });
     });
-    records = orderBy$1(records, fields, directions);
+    records = orderBy$1(records, iteratees, directions);
   }
   return records;
 }

package/package.json

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

package/src/DataTable/utils/filterLocalEntitiesToHasura.js

@@ -239,14 +239,30 @@ function applyOrderBy(records, _order_by) {
   if (order_by.length > 0) {
     const fields = [];
     const directions = [];
+    const iteratees = [];
+
     order_by.forEach(item => {
       // Hasura-style: { field: "asc" }
       const field = Object.keys(item)[0];
       const direction = item[field];
       fields.push(field);
       directions.push(direction);
+
+      // Create a custom iteratee function for natural sorting
+      iteratees.push(record => {
+        const value = record[field];
+        // 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
+          // This effectively creates a sort key that respects natural ordering
+          return value.replace(/(\d+)/g, num => num.padStart(10, "0"));
+        }
+        return value;
+      });
     });
-    records = orderBy(records, fields, directions);
+
+    // Use the custom iteratees for natural sorting
+    records = orderBy(records, iteratees, directions);
   }
   return records;
 }

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

@@ -536,6 +536,24 @@ describe("filterLocalEntitiesToHasura", () => {
     expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
     expect(result.entityCount).toBe(2);
   });
+  it("should order order well names properly, aka names a1, a11, a2, a3 should be sorted a1, a2, a3, a11", () => {
+    const recordsWithNames = [
+      { id: 1, name: "a1" },
+      { id: 2, name: "a11" },
+      { id: 3, name: "a2" },
+      { id: 4, name: "a3" }
+    ];
+    const result = filterLocalEntitiesToHasura(recordsWithNames, {
+      order_by: { name: "asc" }
+    });
+    expect(result.entities).toEqual([
+      recordsWithNames[0], // a1
+      recordsWithNames[2], // a2
+      recordsWithNames[3], // a3
+      recordsWithNames[1] // a11
+    ]);
+    expect(result.entityCount).toBe(4);
+  });
   it("should order by multiple fields (age asc, name desc)", () => {
     // Make two of the ages the same for testing secondary sort
     const modifiedRecords = [

package/src/DataTable/utils/tableQueryParamsToHasuraClauses.js

@@ -112,6 +112,15 @@ export function tableQueryParamsToHasuraClauses({
           case "isExactly":
             return { [filterOn]: { _eq: filterValue } };
           case "isEmpty":
+            if (filterOn.includes(".")) {
+              // if we're filtering on a nested field, like a sequence table with parts.name
+              // we really want to just query on the top level field's existence
+              return {
+                _not: {
+                  [filterOn.split(".")[0]]: {}
+                }
+              };
+            }
             return {
               _or: [
                 { [filterOn]: { _eq: "" } },