@vuu-ui/vuu-filter-parser 3.0.0 → 3.1.0-beta.1

package/package.json

@@ -1,33 +1,37 @@
 {
-  "version": "3.0.0",
+  "version": "3.1.0-beta.1",
+  "main": "src/index.ts",
   "author": "heswell",
   "license": "Apache-2.0",
   "type": "module",
+  "scripts": {
+    "build:dev": "node ../../scripts/run-build.mjs",
+    "build": "node ../../scripts/run-build-rslib.ts",
+    "lezer-generate:filter": "lezer-generator --output ./src/generated/filter-parser.js ./src/grammar/filter.grammar",
+    "type-defs": "node ../../scripts/build-type-defs.mjs"
+  },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "3.0.0",
-    "@vuu-ui/vuu-filter-types": "3.0.0",
-    "@vuu-ui/vuu-table-types": "3.0.0"
+    "@vuu-ui/vuu-data-types": "3.1.0-beta.1",
+    "@vuu-ui/vuu-filter-types": "3.1.0-beta.1",
+    "@vuu-ui/vuu-table-types": "3.1.0-beta.1"
   },
   "dependencies": {
     "@lezer/common": "^1.0.2",
     "@lezer/lr": "1.4.2",
-    "@vuu-ui/vuu-utils": "3.0.0"
+    "@vuu-ui/vuu-utils": "3.1.0-beta.1"
   },
   "files": [
     "README.md",
-    "esm",
-    "cjs",
+    "src",
     "/types"
   ],
   "exports": {
     ".": {
-      "require": "./cjs/index.js",
-      "import": "./esm/index.js",
+      "import": "./src/index.js",
       "types": "./types/index.d.ts"
     }
   },
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
+  "module": "index.js",
   "name": "@vuu-ui/vuu-filter-parser",
   "types": "types/index.d.ts"
 }

package/src/FilterParser.js

@@ -0,0 +1,11 @@
+import { parser } from "./generated/filter-parser.js";
+import { walkTree } from "./FilterTreeWalker.js";
+const strictParser = parser.configure({
+    strict: true
+});
+const parseFilter = (filterQuery)=>{
+    const parseTree = strictParser.parse(filterQuery);
+    const filter = walkTree(parseTree, filterQuery);
+    return filter;
+};
+export { parseFilter };

package/src/FilterTreeWalker.js

@@ -0,0 +1,92 @@
+import { isMultiClauseFilter, isMultiValueFilter, isSingleValueFilter } from "@vuu-ui/vuu-utils";
+class FilterExpression {
+    name;
+    #filter = void 0;
+    setFilterCombinatorOp(op, filter = this.#filter) {
+        if (isMultiClauseFilter(filter) && filter.op === op) return;
+        this.#filter = {
+            op: op,
+            filters: [
+                this.#filter
+            ]
+        };
+    }
+    add(filter) {
+        if (void 0 === this.#filter) this.#filter = filter;
+        else if (isMultiClauseFilter(this.#filter)) this.#filter.filters.push(filter);
+        else throw Error("Invalid filter passed to FilterExpression");
+    }
+    setColumn(column, filter = this.#filter) {
+        if (isMultiClauseFilter(filter)) {
+            const target = filter.filters.at(-1);
+            if (target) this.setColumn(column, target);
+        } else if (filter) filter.column = column;
+    }
+    setOp(value, filter = this.#filter) {
+        if (isMultiClauseFilter(filter)) {
+            const target = filter.filters.at(-1);
+            if (target) this.setOp(value, target);
+        } else if (filter) filter.op = value;
+    }
+    setValue(value, filter = this.#filter) {
+        if (isMultiClauseFilter(filter)) {
+            const target = filter.filters.at(-1);
+            if (target) this.setValue(value, target);
+        } else if (isMultiValueFilter(filter)) {
+            filter.values ??= [];
+            filter.values.push(value);
+        } else if (isSingleValueFilter(filter)) filter.value = value;
+    }
+    toJSON(filter = this.#filter) {
+        if (this.name) return {
+            ...filter,
+            name: this.name
+        };
+        return filter;
+    }
+}
+const walkTree = (tree, source)=>{
+    const filterExpression = new FilterExpression();
+    const cursor = tree.cursor();
+    do {
+        const { name, from, to } = cursor;
+        switch(name){
+            case "ColumnValueExpression":
+                filterExpression.add({});
+                break;
+            case "ColumnSetExpression":
+                filterExpression.add({
+                    op: "in"
+                });
+                break;
+            case "Or":
+            case "And":
+                filterExpression.setFilterCombinatorOp(source.substring(from, to));
+                break;
+            case "Column":
+                filterExpression.setColumn(source.substring(from, to));
+                break;
+            case "Operator":
+                filterExpression.setOp(source.substring(from, to));
+                break;
+            case "String":
+                filterExpression.setValue(source.substring(from + 1, to - 1));
+                break;
+            case "Number":
+                filterExpression.setValue(parseFloat(source.substring(from, to)));
+                break;
+            case "True":
+                filterExpression.setValue(true);
+                break;
+            case "False":
+                filterExpression.setValue(false);
+                break;
+            case "FilterName":
+                filterExpression.name = source.substring(from, to);
+                break;
+            default:
+        }
+    }while (cursor.next())
+    return filterExpression.toJSON();
+};
+export { walkTree };

package/src/filter-evaluation-utils.js

@@ -0,0 +1,177 @@
+import { isFilter, isScaledDecimalFilterClause } from "@vuu-ui/vuu-utils";
+import { parseFilter } from "./FilterParser.js";
+const filterPredicateMap = new Map();
+const dataRowFilterPredicateMap = new Map();
+const filterReject = ()=>false;
+function getFilterPredicate(columnMapOrFilter, filterQuery) {
+    if ("string" == typeof columnMapOrFilter) {
+        let predicate = dataRowFilterPredicateMap.get(columnMapOrFilter);
+        if (predicate) return predicate;
+        try {
+            const filter = parseFilter(columnMapOrFilter);
+            predicate = filterPredicate(filter);
+            dataRowFilterPredicateMap.set(columnMapOrFilter, predicate);
+            return predicate;
+        } catch (err) {
+            console.warn(`filter-evaluation-utils, failed to parse filter "${filterQuery}"`);
+            return filterReject;
+        }
+    }
+    if (filterQuery) {
+        let predicate = filterPredicateMap.get(filterQuery);
+        if (predicate) return predicate;
+        try {
+            const filter = parseFilter(filterQuery);
+            predicate = filterPredicate(columnMapOrFilter, filter);
+            filterPredicateMap.set(filterQuery, predicate);
+            return predicate;
+        } catch (err) {
+            console.warn(`filter-evaluation-utils, failed to parse filter "${filterQuery}"`);
+            return filterReject;
+        }
+    }
+    throw Error("[getFilterPredicate] invalid params");
+}
+function filterPredicate(columnMapOrFilter, filter) {
+    if (isFilter(columnMapOrFilter)) switch(columnMapOrFilter.op){
+        case "in":
+            return testDataRowInclude(columnMapOrFilter);
+        case "=":
+            return testDataRowEQ(columnMapOrFilter);
+        case ">":
+            return testDataRowGT(columnMapOrFilter);
+        case ">=":
+            return testDataRowGE(columnMapOrFilter);
+        case "<":
+            return testDataRowLT(columnMapOrFilter);
+        case "<=":
+            return testDataRowLE(columnMapOrFilter);
+        case "ends":
+            return testDataRowEW(columnMapOrFilter);
+        case "starts":
+            return testDataRowSW(columnMapOrFilter);
+        case "contains":
+            return testDataRowContains(columnMapOrFilter);
+        case "and":
+            return testDataRowAND(columnMapOrFilter);
+        case "or":
+            return testDataRowOR(columnMapOrFilter);
+        default:
+            console.log(`unrecognized filter type ${columnMapOrFilter.op}`);
+            return ()=>true;
+    }
+    if (filter) switch(filter.op){
+        case "in":
+            return testInclude(columnMapOrFilter, filter);
+        case "=":
+            return testEQ(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:
+            console.log(`unrecognized filter type ${filter.op}`);
+            return ()=>true;
+    }
+    throw Error("[filterPredicate] invalid params");
+}
+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)=>{
+    if (isScaledDecimalFilterClause(filter)) return (row)=>row[columnMap[filter.column]] === filter.value.asLong;
+    return (row)=>row[columnMap[filter.column]] === filter.value;
+};
+const testDataRowEQ = (filter)=>(row)=>row[filter.column] === filter.value;
+const testGT = (columnMap, filter)=>(row)=>row[columnMap[filter.column]] > filter.value;
+const testDataRowGT = (filter)=>(row)=>row[filter.column] > filter.value;
+const testGE = (columnMap, filter)=>(row)=>row[columnMap[filter.column]] >= filter.value;
+const testDataRowGE = (filter)=>(row)=>row[filter.column] >= filter.value;
+const testLT = (columnMap, filter)=>(row)=>row[columnMap[filter.column]] < filter.value;
+const testDataRowLT = (filter)=>(row)=>row[filter.column] < filter.value;
+const testLE = (columnMap, filter)=>(row)=>row[columnMap[filter.column]] <= filter.value;
+const testDataRowLE = (filter)=>(row)=>row[filter.column] <= filter.value;
+const testEW = (columnMap, filter)=>{
+    const filterValue = filter.value;
+    if ("string" != typeof filterValue) throw Error("string filter applied to value of wrong type");
+    return (row)=>{
+        const rowValue = row[columnMap[filter.column]];
+        if ("string" != typeof rowValue) throw Error("string filter applied to value of wrong type");
+        return rowValue.toLowerCase().endsWith(filterValue.toLowerCase());
+    };
+};
+const testDataRowEW = (filter)=>{
+    const filterValue = filter.value;
+    if ("string" != typeof filterValue) throw Error("string filter applied to value of wrong type");
+    return (row)=>{
+        const rowValue = row[filter.column];
+        if ("string" != typeof rowValue) throw Error("string filter applied to value of wrong type");
+        return rowValue.toLowerCase().endsWith(filterValue.toLowerCase());
+    };
+};
+const testSW = (columnMap, filter)=>{
+    const filterValue = filter.value;
+    if ("string" != typeof filterValue) throw Error("string filter applied to value of wrong type");
+    return (row)=>{
+        const rowValue = row[columnMap[filter.column]];
+        if ("string" != typeof rowValue) throw Error("string filter applied to value of wrong type");
+        return rowValue.toLowerCase().startsWith(filterValue.toLowerCase());
+    };
+};
+const testDataRowSW = (filter)=>{
+    const filterValue = filter.value;
+    if ("string" != typeof filterValue) throw Error("string filter applied to value of wrong type");
+    return (row)=>{
+        const rowValue = row[filter.column];
+        if ("string" != typeof rowValue) throw Error("string filter applied to value of wrong type");
+        return rowValue.toLowerCase().startsWith(filterValue.toLowerCase());
+    };
+};
+const testContains = (columnMap, filter)=>{
+    const filterValue = filter.value;
+    if ("string" != typeof filterValue) throw Error("string filter applied to value of wrong type");
+    return (row)=>{
+        const rowValue = row[columnMap[filter.column]];
+        if ("string" != typeof rowValue) throw Error("string filter applied to value of wrong type");
+        return rowValue.toLowerCase().includes(filterValue.toLowerCase());
+    };
+};
+const testDataRowContains = (filter)=>{
+    const filterValue = filter.value;
+    if ("string" != typeof filterValue) throw Error("string filter applied to value of wrong type");
+    return (row)=>{
+        const rowValue = row[filter.column];
+        if ("string" != typeof rowValue) throw Error("string filter applied to value of wrong type");
+        return rowValue.toLowerCase().includes(filterValue.toLowerCase());
+    };
+};
+const testAND = (columnMap, filter)=>{
+    const filters = filter.filters.map((f1)=>filterPredicate(columnMap, f1));
+    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));
+    return (row)=>filters.some((fn)=>fn(row));
+}
+function testDataRowOR(filter) {
+    const filters = filter.filters.map((f1)=>filterPredicate(f1));
+    return (row)=>filters.some((fn)=>fn(row));
+}
+export { filterPredicate, getFilterPredicate };

package/src/index.js

@@ -0,0 +1,4 @@
+export * from "./filter-evaluation-utils.js";
+export { parseFilter } from "./FilterParser.js";
+export { parser } from "./generated/filter-parser.js";
+export { walkTree } from "./FilterTreeWalker.js";

package/cjs/FilterParser.js

@@ -1,14 +0,0 @@
-'use strict';
-
-var filterParser = require('./generated/filter-parser.js');
-var FilterTreeWalker = require('./FilterTreeWalker.js');
-
-const strictParser = filterParser.parser.configure({ strict: true });
-const parseFilter = (filterQuery) => {
-  const parseTree = strictParser.parse(filterQuery);
-  const filter = FilterTreeWalker.walkTree(parseTree, filterQuery);
-  return filter;
-};
-
-exports.parseFilter = parseFilter;
-//# sourceMappingURL=FilterParser.js.map

package/cjs/FilterParser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FilterParser.js","sources":["../../../packages/vuu-filter-parser/src/FilterParser.ts"],"sourcesContent":["import { Filter } from \"@vuu-ui/vuu-filter-types\";\nimport { parser } from \"./generated/filter-parser\";\nimport { walkTree } from \"./FilterTreeWalker\";\n\nconst strictParser = parser.configure({ strict: true });\n\nexport const parseFilter = (filterQuery: string): Filter => {\n  const parseTree = strictParser.parse(filterQuery);\n  const filter = walkTree(parseTree, filterQuery) as Filter;\n  return filter;\n};\n"],"names":["parser","walkTree"],"mappings":";;;;;AAIA,MAAM,eAAeA,mBAAO,CAAA,SAAA,CAAU,EAAE,MAAA,EAAQ,MAAM,CAAA;AAEzC,MAAA,WAAA,GAAc,CAAC,WAAgC,KAAA;AAC1D,EAAM,MAAA,SAAA,GAAY,YAAa,CAAA,KAAA,CAAM,WAAW,CAAA;AAChD,EAAM,MAAA,MAAA,GAASC,yBAAS,CAAA,SAAA,EAAW,WAAW,CAAA;AAC9C,EAAO,OAAA,MAAA;AACT;;;;"}

package/cjs/FilterTreeWalker.js

@@ -1,128 +0,0 @@
-'use strict';
-
-var vuuUtils = require('@vuu-ui/vuu-utils');
-
-var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
-var _filter;
-class FilterExpression {
-  constructor() {
-    __publicField(this, "name");
-    __privateAdd(this, _filter);
-  }
-  setFilterCombinatorOp(op, filter = __privateGet(this, _filter)) {
-    if (vuuUtils.isMultiClauseFilter(filter) && filter.op === op) {
-      return;
-    } else {
-      __privateSet(this, _filter, {
-        op,
-        filters: [__privateGet(this, _filter)]
-      });
-    }
-  }
-  add(filter) {
-    if (__privateGet(this, _filter) === void 0) {
-      __privateSet(this, _filter, filter);
-    } else if (vuuUtils.isMultiClauseFilter(__privateGet(this, _filter))) {
-      __privateGet(this, _filter).filters.push(filter);
-    } else {
-      throw Error(`Invalid filter passed to FilterExpression`);
-    }
-  }
-  setColumn(column, filter = __privateGet(this, _filter)) {
-    if (vuuUtils.isMultiClauseFilter(filter)) {
-      const target = filter.filters.at(-1);
-      if (target) {
-        this.setColumn(column, target);
-      }
-    } else if (filter) {
-      filter.column = column;
-    }
-  }
-  setOp(value, filter = __privateGet(this, _filter)) {
-    if (vuuUtils.isMultiClauseFilter(filter)) {
-      const target = filter.filters.at(-1);
-      if (target) {
-        this.setOp(value, target);
-      }
-    } else if (filter) {
-      filter.op = value;
-    }
-  }
-  setValue(value, filter = __privateGet(this, _filter)) {
-    if (vuuUtils.isMultiClauseFilter(filter)) {
-      const target = filter.filters.at(-1);
-      if (target) {
-        this.setValue(value, target);
-      }
-    } else if (vuuUtils.isMultiValueFilter(filter)) {
-      filter.values ?? (filter.values = []);
-      filter.values.push(value);
-    } else if (vuuUtils.isSingleValueFilter(filter)) {
-      filter.value = value;
-    }
-  }
-  toJSON(filter = __privateGet(this, _filter)) {
-    if (this.name) {
-      return {
-        ...filter,
-        name: this.name
-      };
-    } else {
-      return filter;
-    }
-  }
-}
-_filter = new WeakMap();
-const walkTree = (tree, source) => {
-  const filterExpression = new FilterExpression();
-  const cursor = tree.cursor();
-  do {
-    const { name, from, to } = cursor;
-    switch (name) {
-      case "ColumnValueExpression":
-        filterExpression.add({});
-        break;
-      case "ColumnSetExpression":
-        filterExpression.add({ op: "in" });
-        break;
-      case "Or":
-      case "And":
-        filterExpression.setFilterCombinatorOp(source.substring(from, to));
-        break;
-      case "Column":
-        filterExpression.setColumn(source.substring(from, to));
-        break;
-      case "Operator":
-        filterExpression.setOp(source.substring(from, to));
-        break;
-      case "String":
-        filterExpression.setValue(source.substring(from + 1, to - 1));
-        break;
-      case "Number":
-        filterExpression.setValue(parseFloat(source.substring(from, to)));
-        break;
-      case "True":
-        filterExpression.setValue(true);
-        break;
-      case "False":
-        filterExpression.setValue(false);
-        break;
-      case "FilterName":
-        filterExpression.name = source.substring(from, to);
-        break;
-    }
-  } while (cursor.next());
-  return filterExpression.toJSON();
-};
-
-exports.walkTree = walkTree;
-//# sourceMappingURL=FilterTreeWalker.js.map

package/cjs/FilterTreeWalker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FilterTreeWalker.js","sources":["../../../packages/vuu-filter-parser/src/FilterTreeWalker.ts"],"sourcesContent":["import { Tree } from \"@lezer/common\";\nimport {\n  Filter,\n  FilterCombinatorOp,\n  MultipleValueFilterClauseOp,\n  SingleValueFilterClauseOp,\n} from \"@vuu-ui/vuu-filter-types\";\nimport {\n  isMultiClauseFilter,\n  isMultiValueFilter,\n  isSingleValueFilter,\n} from \"@vuu-ui/vuu-utils\";\n\nclass FilterExpression {\n  public name: string | undefined;\n  #filter: Partial<Filter> | undefined = undefined;\n\n  setFilterCombinatorOp(op: string, filter = this.#filter) {\n    if (isMultiClauseFilter(filter) && filter.op === op) {\n      return;\n    } else {\n      this.#filter = {\n        op: op as FilterCombinatorOp,\n        filters: [this.#filter as Filter],\n      };\n    }\n  }\n\n  add(filter: Partial<Filter>) {\n    if (this.#filter === undefined) {\n      this.#filter = filter;\n    } else if (isMultiClauseFilter(this.#filter)) {\n      this.#filter.filters.push(filter as Filter);\n    } else {\n      throw Error(`Invalid filter passed to FilterExpression`);\n    }\n  }\n\n  setColumn(column: string, filter = this.#filter) {\n    if (isMultiClauseFilter(filter)) {\n      const target = filter.filters.at(-1);\n      if (target) {\n        this.setColumn(column, target);\n      }\n    } else if (filter) {\n      filter.column = column;\n    }\n  }\n  setOp(value: string, filter = this.#filter) {\n    if (isMultiClauseFilter(filter)) {\n      const target = filter.filters.at(-1);\n      if (target) {\n        this.setOp(value, target);\n      }\n    } else if (filter) {\n      filter.op = value as\n        | SingleValueFilterClauseOp\n        | MultipleValueFilterClauseOp;\n    }\n  }\n  setValue(value: string | number | boolean, filter = this.#filter) {\n    if (isMultiClauseFilter(filter)) {\n      const target = filter.filters.at(-1);\n      if (target) {\n        this.setValue(value, target);\n      }\n    } else if (isMultiValueFilter(filter)) {\n      filter.values ??= [];\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      filter.values.push(value);\n    } else if (isSingleValueFilter(filter)) {\n      filter.value = value;\n    }\n  }\n\n  toJSON(filter = this.#filter) {\n    if (this.name) {\n      return {\n        ...filter,\n        name: this.name,\n      };\n    } else {\n      return filter;\n    }\n  }\n}\n\nexport const walkTree = (tree: Tree, source: string) => {\n  const filterExpression = new FilterExpression();\n  const cursor = tree.cursor();\n  do {\n    const { name, from, to } = cursor;\n    switch (name) {\n      case \"ColumnValueExpression\":\n        filterExpression.add({});\n        break;\n      case \"ColumnSetExpression\":\n        filterExpression.add({ op: \"in\" });\n        break;\n\n      case \"Or\":\n      case \"And\":\n        filterExpression.setFilterCombinatorOp(source.substring(from, to));\n        break;\n\n      case \"Column\":\n        filterExpression.setColumn(source.substring(from, to));\n        break;\n\n      case \"Operator\":\n        filterExpression.setOp(source.substring(from, to));\n        break;\n\n      case \"String\":\n        filterExpression.setValue(source.substring(from + 1, to - 1));\n        break;\n\n      case \"Number\":\n        filterExpression.setValue(parseFloat(source.substring(from, to)));\n        break;\n\n      case \"True\":\n        filterExpression.setValue(true);\n        break;\n\n      case \"False\":\n        filterExpression.setValue(false);\n        break;\n\n      case \"FilterName\":\n        filterExpression.name = source.substring(from, to);\n        break;\n\n      default:\n    }\n  } while (cursor.next());\n\n  return filterExpression.toJSON();\n};\n"],"names":["isMultiClauseFilter","isMultiValueFilter","isSingleValueFilter"],"mappings":"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"}