@vuu-ui/vuu-filter-parser 3.5.17 → 3.5.18-beta.1

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.17",
+  "version": "3.5.18-beta.1",
   "main": "./src/index.js",
   "author": "heswell",
   "license": "Apache-2.0",
@@ -12,14 +12,14 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "3.5.17",
-    "@vuu-ui/vuu-filter-types": "3.5.17",
-    "@vuu-ui/vuu-table-types": "3.5.17"
+    "@vuu-ui/vuu-data-types": "3.5.18-beta.1",
+    "@vuu-ui/vuu-filter-types": "3.5.18-beta.1",
+    "@vuu-ui/vuu-table-types": "3.5.18-beta.1"
   },
   "dependencies": {
     "@lezer/common": "^1.0.2",
     "@lezer/lr": "1.4.2",
-    "@vuu-ui/vuu-utils": "3.5.17"
+    "@vuu-ui/vuu-utils": "3.5.18-beta.1"
   },
   "files": [
     "README.md",

package/src/filter-evaluation-utils.js

@@ -1,4 +1,4 @@
-import { isFilter, isScaledDecimalFilterClause } from "@vuu-ui/vuu-utils";
+import { getScaledDecimalScale, isFilter, isScaledDecimalFilterClause, toDecimalString, toScaledInteger } from "@vuu-ui/vuu-utils";
 import { parseFilter } from "./FilterParser.js";
 const filterPredicateMap = new Map();
 const dataRowFilterPredicateMap = new Map();
@@ -32,7 +32,7 @@ function getFilterPredicate(columnMapOrFilter, filterQuery) {
     }
     throw Error("[getFilterPredicate] invalid params");
 }
-function filterPredicate(columnMapOrFilter, filter) {
+function filterPredicate(columnMapOrFilter, filter, columnsByName) {
     if (isFilter(columnMapOrFilter)) switch(columnMapOrFilter.op){
         case "in":
             return testDataRowInclude(columnMapOrFilter);
@@ -65,40 +65,72 @@ function filterPredicate(columnMapOrFilter, filter) {
                 return ()=>true;
             }
     }
-    if (filter) switch(filter.op){
-        case "in":
-            return testInclude(columnMapOrFilter, filter);
-        case "=":
-            return testEQ(columnMapOrFilter, filter);
-        case "!=":
-            return testNE(columnMapOrFilter, filter);
-        case ">":
-            return testGT(columnMapOrFilter, filter);
-        case ">=":
-            return testGE(columnMapOrFilter, filter);
-        case "<":
-            return testLT(columnMapOrFilter, filter);
-        case "<=":
-            return testLE(columnMapOrFilter, filter);
-        case "ends":
-            return testEW(columnMapOrFilter, filter);
-        case "starts":
-            return testSW(columnMapOrFilter, filter);
-        case "contains":
-            return testContains(columnMapOrFilter, filter);
-        case "and":
-            return testAND(columnMapOrFilter, filter);
-        case "or":
-            return testOR(columnMapOrFilter, filter);
-        default:
-            {
-                const unreachable = filter;
-                console.log('unrecognized filter type', unreachable);
-                return ()=>true;
-            }
+    if (filter) {
+        const scale = void 0 === filter.column ? void 0 : getScaledDecimalScale(columnsByName?.[filter.column]?.serverDataType);
+        if (void 0 !== scale && isComparisonOp(filter.op)) return testScaledDecimal(columnMapOrFilter, filter, scale);
+        switch(filter.op){
+            case "in":
+                return testInclude(columnMapOrFilter, filter);
+            case "=":
+                return testEQ(columnMapOrFilter, filter);
+            case "!=":
+                return testNE(columnMapOrFilter, filter);
+            case ">":
+                return testGT(columnMapOrFilter, filter);
+            case ">=":
+                return testGE(columnMapOrFilter, filter);
+            case "<":
+                return testLT(columnMapOrFilter, filter);
+            case "<=":
+                return testLE(columnMapOrFilter, filter);
+            case "ends":
+                return testEW(columnMapOrFilter, filter);
+            case "starts":
+                return testSW(columnMapOrFilter, filter);
+            case "contains":
+                return testContains(columnMapOrFilter, filter);
+            case "and":
+                return testAND(columnMapOrFilter, filter, columnsByName);
+            case "or":
+                return testOR(columnMapOrFilter, filter, columnsByName);
+            default:
+                {
+                    const unreachable = filter;
+                    console.log('unrecognized filter type', unreachable);
+                    return ()=>true;
+                }
+        }
     }
     throw Error("[filterPredicate] invalid params");
 }
+const comparisonOps = [
+    "=",
+    "!=",
+    ">",
+    ">=",
+    "<",
+    "<="
+];
+const isComparisonOp = (op)=>comparisonOps.includes(op);
+const compare = {
+    "=": (a, b)=>a === b,
+    "!=": (a, b)=>a !== b,
+    ">": (a, b)=>a > b,
+    ">=": (a, b)=>a >= b,
+    "<": (a, b)=>a < b,
+    "<=": (a, b)=>a <= b
+};
+const testScaledDecimal = (columnMap, filter, scale)=>{
+    const op = filter.op;
+    const test = compare[op];
+    const filterValue = toScaledInteger(toDecimalString(filter.value, scale), scale);
+    const index = columnMap[filter.column];
+    return (row)=>{
+        const value = row[index];
+        if ("" === value || null == value) return "!=" === op;
+        return test(BigInt(value), filterValue);
+    };
+};
 const testInclude = (columnMap, filter)=>(row)=>-1 !== filter.values.indexOf(row[columnMap[filter.column]]);
 const testDataRowInclude = (filter)=>(row)=>-1 !== filter.values.indexOf(row[filter.column]);
 const testEQ = (columnMap, filter)=>{
@@ -173,16 +205,16 @@ const testDataRowContains = (filter)=>{
         return rowValue.toLowerCase().includes(filterValue.toLowerCase());
     };
 };
-const testAND = (columnMap, filter)=>{
-    const filters = filter.filters.map((f1)=>filterPredicate(columnMap, f1));
+const testAND = (columnMap, filter, columnsByName)=>{
+    const filters = filter.filters.map((f1)=>filterPredicate(columnMap, f1, columnsByName));
     return (row)=>filters.every((fn)=>fn(row));
 };
 const testDataRowAND = (filter)=>{
     const filters = filter.filters.map((f1)=>filterPredicate(f1));
     return (row)=>filters.every((fn)=>fn(row));
 };
-function testOR(columnMap, filter) {
-    const filters = filter.filters.map((f1)=>filterPredicate(columnMap, f1));
+function testOR(columnMap, filter, columnsByName) {
+    const filters = filter.filters.map((f1)=>filterPredicate(columnMap, f1, columnsByName));
     return (row)=>filters.some((fn)=>fn(row));
 }
 function testDataRowOR(filter) {

package/types/filter-evaluation-utils.d.ts

@@ -1,5 +1,5 @@
 import { DataSourceRowWithBigint } from "@vuu-ui/vuu-data-types";
-import { Filter } from "@vuu-ui/vuu-filter-types";
+import { ColumnDescriptorsByName, Filter } from "@vuu-ui/vuu-filter-types";
 import { ColumnMap } from "@vuu-ui/vuu-utils";
 import { VuuDataRow } from "@vuu-ui/vuu-protocol-types";
 import { DataRow } from "@vuu-ui/vuu-table-types";
@@ -12,6 +12,8 @@ export declare function getFilterPredicate(filterQuery: string): DataRowFilterPr
  * Two row formats supported:
  * -  DataRow,  used by Tables, when evaluatingn a Menu filter.
  * - DataSourceRow, used by local data source, like ArrayDataSOurce
+ * For a DataSourceRow, columnsByName provides the column types, required to
+ * compare scaled decimal values, which are held as scaled integer strings.
  */
-export declare function filterPredicate(columnMap: ColumnMap, filter: Filter): FilterPredicate;
+export declare function filterPredicate(columnMap: ColumnMap, filter: Filter, columnsByName?: ColumnDescriptorsByName): FilterPredicate;
 export declare function filterPredicate(filter: Filter): DataRowFilterPredicate;