@vuu-ui/vuu-filter-parser 2.1.19-beta.2 → 2.1.19-beta.4

package/src/filter-evaluation-utils.js

@@ -1,177 +0,0 @@
-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

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