igniteui-angular 18.3.0-beta.0 → 18.3.0-beta.1

package/esm2022/lib/data-operations/expressions-tree-util.mjs

@@ -1,3 +1,6 @@
+import { DateTimeUtil } from '../date-common/util/date-time.util';
+import { GridColumnDataType } from './data-util';
+import { IgxBooleanFilteringOperand, IgxDateFilteringOperand, IgxDateTimeFilteringOperand, IgxNumberFilteringOperand, IgxStringFilteringOperand, IgxTimeFilteringOperand } from './filtering-condition';
 export class ExpressionsTreeUtil {
     /**
      * Returns the filtering expression for a column with the provided tree and fieldName.
@@ -47,4 +50,148 @@ export class ExpressionsTreeUtil {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Recreates the search value for a given expression.
+ * @param searchValue The search value to recreate.
+ * @param dataType The data type of the field.
+ * @returns The recreated search value.
+ */
+function recreateSearchValue(searchValue, dataType) {
+    if (!dataType) {
+        return searchValue;
+    }
+    // In ESF, values are stored as a Set.
+    // Those values are converted to an array before returning string in the stringifyCallback
+    // now we need to convert those back to Set
+    if (Array.isArray(searchValue)) {
+        return new Set(searchValue);
+    }
+    else if ((dataType.toLowerCase().includes('date') || dataType.toLowerCase().includes('time')) && !(searchValue instanceof Date)) {
+        return DateTimeUtil.parseIsoDate(searchValue) ?? searchValue;
+    }
+    return searchValue;
+}
+/**
+ * Returns the filtering logic function for a given dataType and condition (contains, greaterThan, etc.)
+ * @param dataType The data type of the field.
+ * @param name The name of the filtering condition.
+ * @returns The filtering logic function.
+ */
+function getFilteringCondition(dataType, name) {
+    let filters;
+    switch (dataType) {
+        case GridColumnDataType.Boolean:
+            filters = IgxBooleanFilteringOperand.instance();
+            break;
+        case GridColumnDataType.Number:
+        case GridColumnDataType.Currency:
+        case GridColumnDataType.Percent:
+            filters = IgxNumberFilteringOperand.instance();
+            break;
+        case GridColumnDataType.Date:
+            filters = IgxDateFilteringOperand.instance();
+            break;
+        case GridColumnDataType.Time:
+            filters = IgxTimeFilteringOperand.instance();
+            break;
+        case GridColumnDataType.DateTime:
+            filters = IgxDateTimeFilteringOperand.instance();
+            break;
+        case GridColumnDataType.String:
+        default:
+            filters = IgxStringFilteringOperand.instance();
+            break;
+    }
+    return filters.condition(name);
+}
+/**
+ * Recreates the IFilteringOperation for a given expression.
+ * If the `logic` is already populated - it will return the original IFilteringOperation
+ * of the expression.
+ * @param expression The expression for which to resolve the IFilteringOperation.
+ * @param dataType The data type of the field.
+ * @returns The IFilteringOperation for the given expression.
+ */
+function recreateOperatorFromDataType(expression, dataType) {
+    if (!expression.condition?.logic) {
+        return getFilteringCondition(dataType, expression.conditionName || expression.condition?.name);
+    }
+    return expression.condition;
+}
+/**
+ * Recreates an expression from the given fields by applying the correct operands
+ * and adjusting the search value to be the correct type.
+ * @param expression The expression to recreate.
+ * @param fields An array of fields to use for recreating the expression.
+ * @returns The recreated expression.
+ */
+function recreateExpression(expression, fields) {
+    const field = fields?.find(f => f.field === expression.fieldName);
+    if (field && !expression.condition?.logic) {
+        if (!field.filters) {
+            expression.condition = recreateOperatorFromDataType(expression, field.dataType);
+        }
+        else {
+            expression.condition = field.filters.condition(expression.conditionName || expression.condition?.name);
+        }
+    }
+    if (!expression.conditionName) {
+        expression.conditionName = expression.condition?.name;
+    }
+    expression.searchVal = recreateSearchValue(expression.searchVal, field?.dataType);
+    return expression;
+}
+/**
+ * Checks if the given entry is an IExpressionTree.
+ * @param entry The entry to check.
+ * @returns True if the entry is an IExpressionTree, false otherwise.
+ */
+export function isTree(entry) {
+    return 'operator' in entry;
+}
+/**
+ * Recreates the tree from a given array of entities by applying the correct operands
+ * for each expression and adjusting the search values to be the correct type.
+ * @param tree The expression tree to recreate.
+ * @param entities An array of entities to use for recreating the tree.
+ * @returns The recreated expression tree.
+ */
+export function recreateTree(tree, entities) {
+    const entity = entities.find(e => e.name === tree.entity);
+    for (let i = 0; i < tree.filteringOperands.length; i++) {
+        const operand = tree.filteringOperands[i];
+        if (isTree(operand)) {
+            tree.filteringOperands[i] = recreateTree(operand, entities);
+        }
+        else {
+            if (operand.searchTree) {
+                operand.searchTree = recreateTree(operand.searchTree, entities);
+            }
+            tree.filteringOperands[i] = recreateExpression(operand, entity?.fields);
+        }
+    }
+    return tree;
+}
+/**
+ * Recreates the tree from a given array of fields by applying the correct operands.
+ * It is recommended to use `recreateTree` if there will be multiple entities in the tree
+ * with potentially colliding field names.
+ * @param tree The expression tree to recreate.
+ * @param fields An array of fields to use for recreating the tree.
+ */
+export function recreateTreeFromFields(tree, fields) {
+    for (let i = 0; i < tree.filteringOperands.length; i++) {
+        const operand = tree.filteringOperands[i];
+        if (isTree(operand)) {
+            tree.filteringOperands[i] = recreateTreeFromFields(operand, fields);
+        }
+        else {
+            if (operand.searchTree) {
+                operand.searchTree = recreateTreeFromFields(operand.searchTree, fields);
+            }
+            tree.filteringOperands[i] = recreateExpression(operand, fields);
+        }
+    }
+    return tree;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"expressions-tree-util.js","sourceRoot":"","sources":["../../../../../projects/igniteui-angular/src/lib/data-operations/expressions-tree-util.ts"],"names":[],"mappings":"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","sourcesContent":["import { DateTimeUtil } from '../date-common/util/date-time.util';\nimport { EntityType, FieldType } from '../grids/common/grid.interface';\nimport { GridColumnDataType } from './data-util';\nimport { IFilteringOperation, IgxBooleanFilteringOperand, IgxDateFilteringOperand, IgxDateTimeFilteringOperand, IgxFilteringOperand, IgxNumberFilteringOperand, IgxStringFilteringOperand, IgxTimeFilteringOperand } from './filtering-condition';\nimport { IFilteringExpression } from './filtering-expression.interface';\nimport { IExpressionTree, IFilteringExpressionsTree } from './filtering-expressions-tree';\n\nexport class ExpressionsTreeUtil {\n    /**\n     * Returns the filtering expression for a column with the provided tree and fieldName.\n     * ```typescript\n     * let filteringExpression = ExpressionsTreeUtil.find(gridExpressionTree, 'Column Field');\n     * ```\n     */\n    public static find(tree: IFilteringExpressionsTree, fieldName: string): IFilteringExpressionsTree | IFilteringExpression {\n        const index = this.findIndex(tree, fieldName);\n\n        if (index > -1) {\n            return tree.filteringOperands[index];\n        }\n\n        return null;\n    }\n\n    /**\n     * Returns the index of the filtering expression for a column with the provided tree and fieldName.\n     * ```typescript\n     * let filteringExpressionIndex = ExpressionsTreeUtil.findIndex(gridExpressionTree, 'Column Field');\n     * ```\n     */\n    public static findIndex(tree: IFilteringExpressionsTree, fieldName: string): number {\n        for (let i = 0; i < tree.filteringOperands.length; i++) {\n            const expr = tree.filteringOperands[i];\n            if ((expr as IFilteringExpressionsTree).operator !== undefined) {\n                if (this.isFilteringExpressionsTreeForColumn(expr as IFilteringExpressionsTree, fieldName)) {\n                    return i;\n                }\n            } else if ((expr as IFilteringExpression).fieldName === fieldName) {\n                return i;\n            }\n        }\n\n        return -1;\n    }\n\n    protected static isFilteringExpressionsTreeForColumn(expressionsTree: IFilteringExpressionsTree, fieldName: string): boolean {\n        if (expressionsTree.fieldName === fieldName) {\n            return true;\n        }\n\n        for (const expr of expressionsTree.filteringOperands) {\n            if ((expr as IFilteringExpressionsTree).operator !== undefined) {\n                return this.isFilteringExpressionsTreeForColumn(expr as IFilteringExpressionsTree, fieldName);\n            } else if ((expr as IFilteringExpression).fieldName === fieldName) {\n                return true;\n            }\n        }\n        return false;\n    }\n}\n\n/**\n * Recreates the search value for a given expression.\n * @param searchValue The search value to recreate.\n * @param dataType The data type of the field.\n * @returns The recreated search value.\n */\nfunction recreateSearchValue(searchValue: any, dataType: string): any {\n    if (!dataType) {\n        return searchValue;\n    }\n    // In ESF, values are stored as a Set.\n    // Those values are converted to an array before returning string in the stringifyCallback\n    // now we need to convert those back to Set\n    if (Array.isArray(searchValue)) {\n        return new Set(searchValue);\n    } else if ((dataType.toLowerCase().includes('date') || dataType.toLowerCase().includes('time')) && !(searchValue instanceof Date)) {\n        return DateTimeUtil.parseIsoDate(searchValue) ?? searchValue;\n    }\n\n    return searchValue;\n}\n\n/**\n * Returns the filtering logic function for a given dataType and condition (contains, greaterThan, etc.)\n * @param dataType The data type of the field.\n * @param name The name of the filtering condition.\n * @returns The filtering logic function.\n */\nfunction getFilteringCondition(dataType: string, name: string): IFilteringOperation {\n    let filters: IgxFilteringOperand;\n    switch (dataType) {\n        case GridColumnDataType.Boolean:\n            filters = IgxBooleanFilteringOperand.instance();\n            break;\n        case GridColumnDataType.Number:\n        case GridColumnDataType.Currency:\n        case GridColumnDataType.Percent:\n            filters = IgxNumberFilteringOperand.instance();\n            break;\n        case GridColumnDataType.Date:\n            filters = IgxDateFilteringOperand.instance();\n            break;\n        case GridColumnDataType.Time:\n            filters = IgxTimeFilteringOperand.instance();\n            break;\n        case GridColumnDataType.DateTime:\n            filters = IgxDateTimeFilteringOperand.instance();\n            break;\n        case GridColumnDataType.String:\n        default:\n            filters = IgxStringFilteringOperand.instance();\n            break;\n    }\n    return filters.condition(name);\n}\n\n/**\n * Recreates the IFilteringOperation for a given expression.\n * If the `logic` is already populated - it will return the original IFilteringOperation\n * of the expression.\n * @param expression The expression for which to resolve the IFilteringOperation.\n * @param dataType The data type of the field.\n * @returns The IFilteringOperation for the given expression.\n */\nfunction recreateOperatorFromDataType(expression: IFilteringExpression, dataType: string): IFilteringOperation {\n    if (!expression.condition?.logic) {\n        return getFilteringCondition(dataType, expression.conditionName || expression.condition?.name);\n    }\n\n    return expression.condition;\n}\n\n/**\n * Recreates an expression from the given fields by applying the correct operands\n * and adjusting the search value to be the correct type.\n * @param expression The expression to recreate.\n * @param fields An array of fields to use for recreating the expression.\n * @returns The recreated expression.\n */\nfunction recreateExpression(expression: IFilteringExpression, fields: FieldType[]): IFilteringExpression {\n    const field = fields?.find(f => f.field === expression.fieldName);\n\n    if (field && !expression.condition?.logic) {\n        if (!field.filters) {\n            expression.condition = recreateOperatorFromDataType(expression, field.dataType);\n        } else {\n            expression.condition = field.filters.condition(expression.conditionName || expression.condition?.name);\n        }\n    }\n\n    if (!expression.conditionName) {\n        expression.conditionName = expression.condition?.name;\n    }\n\n    expression.searchVal = recreateSearchValue(expression.searchVal, field?.dataType);\n\n    return expression;\n}\n\n/**\n * Checks if the given entry is an IExpressionTree.\n * @param entry The entry to check.\n * @returns True if the entry is an IExpressionTree, false otherwise.\n */\nexport function isTree(entry: IExpressionTree | IFilteringExpression): entry is IExpressionTree {\n    return 'operator' in entry;\n}\n\n/**\n * Recreates the tree from a given array of entities by applying the correct operands\n * for each expression and adjusting the search values to be the correct type.\n * @param tree The expression tree to recreate.\n * @param entities An array of entities to use for recreating the tree.\n * @returns The recreated expression tree.\n */\nexport function recreateTree(tree: IExpressionTree, entities: EntityType[]): IExpressionTree {\n    const entity = entities.find(e => e.name === tree.entity);\n\n    for (let i = 0; i < tree.filteringOperands.length; i++) {\n        const operand = tree.filteringOperands[i];\n        if (isTree(operand)) {\n            tree.filteringOperands[i] = recreateTree(operand, entities);\n        } else {\n            if (operand.searchTree) {\n                operand.searchTree = recreateTree(operand.searchTree, entities);\n            }\n            tree.filteringOperands[i] = recreateExpression(operand, entity?.fields);\n        }\n    }\n\n    return tree;\n}\n\n/**\n * Recreates the tree from a given array of fields by applying the correct operands.\n * It is recommended to use `recreateTree` if there will be multiple entities in the tree\n * with potentially colliding field names.\n * @param tree The expression tree to recreate.\n * @param fields An array of fields to use for recreating the tree.\n */\nexport function recreateTreeFromFields(tree: IExpressionTree, fields: FieldType[]): IExpressionTree {\n    for (let i = 0; i < tree.filteringOperands.length; i++) {\n        const operand = tree.filteringOperands[i];\n        if (isTree(operand)) {\n            tree.filteringOperands[i] = recreateTreeFromFields(operand, fields);\n        } else {\n            if (operand.searchTree) {\n                operand.searchTree = recreateTreeFromFields(operand.searchTree, fields);\n            }\n            tree.filteringOperands[i] = recreateExpression(operand, fields);\n        }\n    }\n\n    return tree;\n}\n"]}

package/esm2022/lib/data-operations/filtering-expressions-tree.mjs

@@ -68,4 +68,4 @@ export class FilteringExpressionsTree {
         return ExpressionsTreeUtil.findIndex(this, fieldName);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filtering-expressions-tree.js","sourceRoot":"","sources":["../../../../../projects/igniteui-angular/src/lib/data-operations/filtering-expressions-tree.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,qBAAqB;AACrB,MAAM,CAAN,IAAY,4BAGX;AAHD,WAAY,4BAA4B;IACpC,qFAAO,CAAA;IACP,uFAAQ,CAAA;AACZ,CAAC,EAHW,4BAA4B,KAA5B,4BAA4B,QAGvC;AA2BD,oBAAoB;AACpB,wBAAwB;AACxB,MAAM,OAAO,wBAAwB;IA0FjC,YAAY,QAAwB,EAAE,SAAkB,EAAE,MAAe,EAAE,YAAuB;QAxFlG;;;;;;;;;;;;;;;;;;;WAmBG;QACI,sBAAiB,GAAyD,EAAE,CAAC;QAqEhF,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC/B,CAAC;IAGD;;;;OAIG;IACI,MAAM,CAAC,KAAK,CAAC,cAAyC;QACzD,OAAO,CAAC,cAAc,IAAI,CAAC,cAAc,CAAC,iBAAiB,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,MAAM,CAAC;IAC5G,CAAC;IAED;;;;;;;;OAQG;IACI,IAAI,CAAC,SAAiB;QACzB,OAAO,mBAAmB,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IACrD,CAAC;IAED;;;;;;;;OAQG;IACI,SAAS,CAAC,SAAiB;QAC9B,OAAO,mBAAmB,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAC1D,CAAC;CACJ","sourcesContent":["import { FilteringLogic, IFilteringExpression } from './filtering-expression.interface';\nimport { IBaseEventArgs } from '../core/utils';\nimport { ExpressionsTreeUtil } from './expressions-tree-util';\n\n/* mustCoerceToInt */\nexport enum FilteringExpressionsTreeType {\n    Regular,\n    Advanced\n}\n\nexport declare interface IExpressionTree {\n    filteringOperands: (IExpressionTree | IFilteringExpression)[];\n    operator: FilteringLogic;\n    fieldName?: string;\n    entity?: string;\n    returnFields?: string[];\n}\n\n/* marshalByValue */\nexport declare interface IFilteringExpressionsTree extends IBaseEventArgs, IExpressionTree {\n    filteringOperands: (IFilteringExpressionsTree | IFilteringExpression)[];\n    /* alternateName: treeType */\n    type?: FilteringExpressionsTreeType;\n\n    /**\n     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.find` instead.\n     */\n    find(fieldName: string): IFilteringExpressionsTree | IFilteringExpression;\n\n    /**\n     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.findIndex` instead.\n     */\n    findIndex(fieldName: string): number;\n}\n\n/* marshalByValue */\n/* jsonAPIPlainObject */\nexport class FilteringExpressionsTree implements IFilteringExpressionsTree {\n\n    /**\n     * Sets/gets the filtering operands.\n     * ```typescript\n     * const gridExpressionsTree = new FilteringExpressionsTree(FilteringLogic.And);\n     * const expression = [\n     * {\n     *   condition: IgxStringFilteringOperand.instance().condition('contains'),\n     *   fieldName: 'Column Field',\n     *   searchVal: 'Value',\n     *   ignoreCase: false\n     * }];\n     * gridExpressionsTree.filteringOperands.push(expression);\n     * this.grid.filteringExpressionsTree = gridExpressionsTree;\n     * ```\n     * ```typescript\n     * let filteringOperands = gridExpressionsTree.filteringOperands;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public filteringOperands: (IFilteringExpressionsTree | IFilteringExpression)[] = [];\n\n    /**\n     * Sets/gets the operator.\n     * ```typescript\n     * gridExpressionsTree.operator = FilteringLogic.And;\n     * ```\n     * ```typescript\n     * let operator = gridExpressionsTree.operator;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public operator: FilteringLogic;\n\n    /**\n     * Sets/gets the field name of the column where the filtering expression is placed.\n     * ```typescript\n     * gridExpressionTree.fieldName = 'Column Field';\n     * ```\n     * ```typescript\n     * let columnField = expressionTree.fieldName;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public fieldName?: string;\n\n    /* alternateName: treeType */\n    /**\n     * Sets/gets the type of the filtering expressions tree.\n     * ```typescript\n     * gridExpressionTree.type = FilteringExpressionsTree.Advanced;\n     * ```\n     * ```typescript\n     * let type = expressionTree.type;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public type?: FilteringExpressionsTreeType;\n\n    /**\n     * Sets/gets the entity.\n     * ```typescript\n     * gridExpressionsTree.entity = 'Entity A';\n     * ```\n     * ```typescript\n     * let entity = gridExpressionsTree.entity;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public entity?: string;\n\n    /**\n     * Sets/gets the return fields.\n     * ```typescript\n     * gridExpressionsTree.returnFields = ['Column Field 1', 'Column Field 2'];\n     * ```\n     * ```typescript\n     * let returnFields = gridExpressionsTree.returnFields;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public returnFields?: string[];\n\n    constructor(operator: FilteringLogic, fieldName?: string, entity?: string, returnFields?: string[]) {\n        this.operator = operator;\n        this.entity = entity;\n        this.returnFields = returnFields;\n        this.fieldName = fieldName;\n    }\n\n\n    /**\n     * Checks if filtering expressions tree is empty.\n     *\n     * @param expressionTree filtering expressions tree.\n     */\n    public static empty(expressionTree: IFilteringExpressionsTree): boolean {\n        return !expressionTree || !expressionTree.filteringOperands || !expressionTree.filteringOperands.length;\n    }\n\n    /**\n     * Returns the filtering expression for a column with the provided fieldName.\n     * ```typescript\n     * let filteringExpression = gridExpressionTree.find('Column Field');\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.find` instead.\n     */\n    public find(fieldName: string): IFilteringExpressionsTree | IFilteringExpression {\n        return ExpressionsTreeUtil.find(this, fieldName);\n    }\n\n    /**\n     * Returns the index of the filtering expression for a column with the provided fieldName.\n     * ```typescript\n     * let filteringExpressionIndex = gridExpressionTree.findIndex('Column Field');\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.findIndex` instead.\n     */\n    public findIndex(fieldName: string): number {\n        return ExpressionsTreeUtil.findIndex(this, fieldName);\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filtering-expressions-tree.js","sourceRoot":"","sources":["../../../../../projects/igniteui-angular/src/lib/data-operations/filtering-expressions-tree.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,qBAAqB;AACrB,MAAM,CAAN,IAAY,4BAGX;AAHD,WAAY,4BAA4B;IACpC,qFAAO,CAAA;IACP,uFAAQ,CAAA;AACZ,CAAC,EAHW,4BAA4B,KAA5B,4BAA4B,QAGvC;AA2BD,oBAAoB;AACpB,wBAAwB;AACxB,MAAM,OAAO,wBAAwB;IA0FjC,YAAY,QAAwB,EAAE,SAAkB,EAAE,MAAe,EAAE,YAAuB;QAxFlG;;;;;;;;;;;;;;;;;;;WAmBG;QACI,sBAAiB,GAAyD,EAAE,CAAC;QAqEhF,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC/B,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,KAAK,CAAC,cAAyC;QACzD,OAAO,CAAC,cAAc,IAAI,CAAC,cAAc,CAAC,iBAAiB,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,MAAM,CAAC;IAC5G,CAAC;IAED;;;;;;;;OAQG;IACI,IAAI,CAAC,SAAiB;QACzB,OAAO,mBAAmB,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IACrD,CAAC;IAED;;;;;;;;OAQG;IACI,SAAS,CAAC,SAAiB;QAC9B,OAAO,mBAAmB,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAC1D,CAAC;CACJ","sourcesContent":["import { FilteringLogic, IFilteringExpression } from './filtering-expression.interface';\nimport { IBaseEventArgs } from '../core/utils';\nimport { ExpressionsTreeUtil } from './expressions-tree-util';\n\n/* mustCoerceToInt */\nexport enum FilteringExpressionsTreeType {\n    Regular,\n    Advanced\n}\n\nexport declare interface IExpressionTree {\n    filteringOperands: (IExpressionTree | IFilteringExpression)[];\n    operator: FilteringLogic;\n    fieldName?: string;\n    entity?: string;\n    returnFields?: string[];\n}\n\n/* marshalByValue */\nexport declare interface IFilteringExpressionsTree extends IBaseEventArgs, IExpressionTree {\n    filteringOperands: (IFilteringExpressionsTree | IFilteringExpression)[];\n    /* alternateName: treeType */\n    type?: FilteringExpressionsTreeType;\n\n    /**\n     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.find` instead.\n     */\n    find(fieldName: string): IFilteringExpressionsTree | IFilteringExpression;\n\n    /**\n     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.findIndex` instead.\n     */\n    findIndex(fieldName: string): number;\n}\n\n/* marshalByValue */\n/* jsonAPIPlainObject */\nexport class FilteringExpressionsTree implements IFilteringExpressionsTree {\n\n    /**\n     * Sets/gets the filtering operands.\n     * ```typescript\n     * const gridExpressionsTree = new FilteringExpressionsTree(FilteringLogic.And);\n     * const expression = [\n     * {\n     *   condition: IgxStringFilteringOperand.instance().condition('contains'),\n     *   fieldName: 'Column Field',\n     *   searchVal: 'Value',\n     *   ignoreCase: false\n     * }];\n     * gridExpressionsTree.filteringOperands.push(expression);\n     * this.grid.filteringExpressionsTree = gridExpressionsTree;\n     * ```\n     * ```typescript\n     * let filteringOperands = gridExpressionsTree.filteringOperands;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public filteringOperands: (IFilteringExpressionsTree | IFilteringExpression)[] = [];\n\n    /**\n     * Sets/gets the operator.\n     * ```typescript\n     * gridExpressionsTree.operator = FilteringLogic.And;\n     * ```\n     * ```typescript\n     * let operator = gridExpressionsTree.operator;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public operator: FilteringLogic;\n\n    /**\n     * Sets/gets the field name of the column where the filtering expression is placed.\n     * ```typescript\n     * gridExpressionTree.fieldName = 'Column Field';\n     * ```\n     * ```typescript\n     * let columnField = expressionTree.fieldName;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public fieldName?: string;\n\n    /* alternateName: treeType */\n    /**\n     * Sets/gets the type of the filtering expressions tree.\n     * ```typescript\n     * gridExpressionTree.type = FilteringExpressionsTree.Advanced;\n     * ```\n     * ```typescript\n     * let type = expressionTree.type;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public type?: FilteringExpressionsTreeType;\n\n    /**\n     * Sets/gets the entity.\n     * ```typescript\n     * gridExpressionsTree.entity = 'Entity A';\n     * ```\n     * ```typescript\n     * let entity = gridExpressionsTree.entity;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public entity?: string;\n\n    /**\n     * Sets/gets the return fields.\n     * ```typescript\n     * gridExpressionsTree.returnFields = ['Column Field 1', 'Column Field 2'];\n     * ```\n     * ```typescript\n     * let returnFields = gridExpressionsTree.returnFields;\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     */\n    public returnFields?: string[];\n\n    constructor(operator: FilteringLogic, fieldName?: string, entity?: string, returnFields?: string[]) {\n        this.operator = operator;\n        this.entity = entity;\n        this.returnFields = returnFields;\n        this.fieldName = fieldName;\n    }\n\n    /**\n     * Checks if filtering expressions tree is empty.\n     *\n     * @param expressionTree filtering expressions tree.\n     */\n    public static empty(expressionTree: IFilteringExpressionsTree): boolean {\n        return !expressionTree || !expressionTree.filteringOperands || !expressionTree.filteringOperands.length;\n    }\n\n    /**\n     * Returns the filtering expression for a column with the provided fieldName.\n     * ```typescript\n     * let filteringExpression = gridExpressionTree.find('Column Field');\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.find` instead.\n     */\n    public find(fieldName: string): IFilteringExpressionsTree | IFilteringExpression {\n        return ExpressionsTreeUtil.find(this, fieldName);\n    }\n\n    /**\n     * Returns the index of the filtering expression for a column with the provided fieldName.\n     * ```typescript\n     * let filteringExpressionIndex = gridExpressionTree.findIndex('Column Field');\n     * ```\n     *\n     * @memberof FilteringExpressionsTree\n     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.findIndex` instead.\n     */\n    public findIndex(fieldName: string): number {\n        return ExpressionsTreeUtil.findIndex(this, fieldName);\n    }\n}\n"]}

package/esm2022/lib/data-operations/filtering-strategy.mjs

@@ -4,6 +4,7 @@ import { resolveNestedPath, parseDate, formatDate, formatCurrency } from '../cor
 import { GridColumnDataType } from './data-util';
 import { SortingDirection } from './sorting-strategy';
 import { formatNumber, formatPercent, getLocaleCurrencyCode } from '@angular/common';
+import { isTree } from './expressions-tree-util';
 const DateType = 'date';
 const DateTimeType = 'dateTime';
 const TimeType = 'time';
@@ -26,7 +27,7 @@ export class BaseFilteringStrategy {
     // protected
     matchRecord(rec, expressions, grid) {
         if (expressions) {
-            if (expressions instanceof FilteringExpressionsTree) {
+            if (isTree(expressions)) {
                 const expressionsTree = expressions;
                 const operator = expressionsTree.operator;
                 let matchOperand;
@@ -188,4 +189,4 @@ export class FormattedValuesFilteringStrategy extends FilteringStrategy {
         return !this.fields || this.fields.length === 0 || this.fields.some(f => f === column.field);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filtering-strategy.js","sourceRoot":"","sources":["../../../../../projects/igniteui-angular/src/lib/data-operations/filtering-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["import { FilteringLogic, IFilteringExpression } from './filtering-expression.interface';\nimport { FilteringExpressionsTree, IFilteringExpressionsTree } from './filtering-expressions-tree';\nimport { resolveNestedPath, parseDate, formatDate, formatCurrency } from '../core/utils';\nimport { ColumnType, GridType } from '../grids/common/grid.interface';\nimport { GridColumnDataType } from './data-util';\nimport { SortingDirection } from './sorting-strategy';\nimport { formatNumber, formatPercent, getLocaleCurrencyCode } from '@angular/common';\nimport { IFilteringState } from './filtering-state.interface';\n\nconst DateType = 'date';\nconst DateTimeType = 'dateTime';\nconst TimeType = 'time';\n\nexport class FilterUtil {\n    public static filter<T>(data: T[], state: IFilteringState, grid?: GridType): T[] {\n        if (!state.strategy) {\n            state.strategy = new FilteringStrategy();\n        }\n        return state.strategy.filter(data, state.expressionsTree, state.advancedExpressionsTree, grid);\n    }\n}\n\nexport interface IFilteringStrategy {\n    filter(data: any[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree,\n        grid?: GridType): any[];\n    /* csSuppress */\n    getFilterItems(column: ColumnType, tree: IFilteringExpressionsTree) : Promise<IgxFilterItem[]>;\n}\n\n/* csSuppress */\nexport interface IgxFilterItem {\n    value: any;\n    label?: string;\n    children?: IgxFilterItem[];\n}\n\n/* csSuppress */\nexport abstract class BaseFilteringStrategy implements IFilteringStrategy  {\n    // protected\n    public findMatchByExpression(rec: any, expr: IFilteringExpression, isDate?: boolean, isTime?: boolean, grid?: GridType): boolean {\n        const cond = expr.condition;\n        const val = this.getFieldValue(rec, expr.fieldName, isDate, isTime, grid);\n        return cond.logic(val, expr.searchVal, expr.ignoreCase);\n    }\n\n    // protected\n    public matchRecord(rec: any, expressions: IFilteringExpressionsTree | IFilteringExpression, grid?: GridType): boolean {\n        if (expressions) {\n            if (expressions instanceof FilteringExpressionsTree) {\n                const expressionsTree = expressions as IFilteringExpressionsTree;\n                const operator = expressionsTree.operator as FilteringLogic;\n                let matchOperand;\n\n                if (expressionsTree.filteringOperands && expressionsTree.filteringOperands.length) {\n                    for (const operand of expressionsTree.filteringOperands) {\n                        matchOperand = this.matchRecord(rec, operand, grid);\n\n                        // Return false if at least one operand does not match and the filtering logic is And\n                        if (!matchOperand && operator === FilteringLogic.And) {\n                            return false;\n                        }\n\n                        // Return true if at least one operand matches and the filtering logic is Or\n                        if (matchOperand && operator === FilteringLogic.Or) {\n                            return true;\n                        }\n                    }\n\n                    return matchOperand;\n                }\n\n                return true;\n            } else {\n                const expression = expressions as IFilteringExpression;\n                const column = grid && grid.getColumnByName(expression.fieldName);\n                const isDate = column ? column.dataType === DateType || column.dataType === DateTimeType : false;\n                const isTime = column ? column.dataType === TimeType : false;\n                return this.findMatchByExpression(rec, expression, isDate, isTime, grid);\n            }\n        }\n\n        return true;\n    }\n\n    public getFilterItems(column: ColumnType, tree: IFilteringExpressionsTree): Promise<IgxFilterItem[]> {\n\n        let data = column.grid.gridAPI.filterDataByExpressions(tree);\n        data = column.grid.gridAPI.sortDataByExpressions(data,\n            [{ fieldName: column.field, dir: SortingDirection.Asc, ignoreCase: column.sortingIgnoreCase }]);\n\n        const columnField = column.field;\n        let filterItems: IgxFilterItem[] = data.map(record => {\n            let value = resolveNestedPath(record, columnField);\n            const applyFormatter = column.formatter && this.shouldFormatFilterValues(column);\n\n            value = applyFormatter ?\n                column.formatter(value, record) :\n                value;\n\n            return {\n                value,\n                label: this.getFilterItemLabel(column, value, !applyFormatter, record)\n            };\n        });\n        filterItems = this.getUniqueFilterItems(column, filterItems);\n\n        return Promise.resolve(filterItems);\n    }\n\n    protected getFilterItemLabel(column: ColumnType, value: any, applyFormatter: boolean, data: any) {\n        if (column.formatter) {\n            if (applyFormatter) {\n                return column.formatter(value, data);\n            }\n            return value;\n        }\n\n        const { display, format, digitsInfo, currencyCode, timezone } = column.pipeArgs;\n        const locale = column.grid.locale;\n\n        switch (column.dataType) {\n            case GridColumnDataType.Date:\n            case GridColumnDataType.DateTime:\n            case GridColumnDataType.Time:\n                return formatDate(value, format, locale, timezone);\n            case GridColumnDataType.Currency:\n                return formatCurrency(value, currencyCode || getLocaleCurrencyCode(locale), display, digitsInfo, locale);\n            case GridColumnDataType.Number:\n                return formatNumber(value, locale, digitsInfo);\n            case GridColumnDataType.Percent:\n                return formatPercent(value, locale, digitsInfo);\n            default:\n                return value;\n        }\n    }\n\n    protected getUniqueFilterItems(column: ColumnType, filterItems: IgxFilterItem[]) {\n        const filteredUniqueValues = filterItems.reduce((map, item) => {\n            let key = item.value;\n\n            if (column.dataType === GridColumnDataType.String && column.filteringIgnoreCase) {\n                key = key?.toString().toLowerCase();\n            } else if (column.dataType === GridColumnDataType.DateTime) {\n                key = item.value?.toString();\n                item.value = key ? new Date(key) : key;\n            } else if (column.dataType === GridColumnDataType.Time) {\n                const date = key ? new Date(key) : key;\n                key = date ? new Date().setHours(date.getHours(), date.getMinutes(), date.getSeconds()) : key;\n                item.value = key ? new Date(key) : key;\n            } else if (column.dataType === GridColumnDataType.Date) {\n                const date = key ? new Date(key) : key;\n                key = date ? new Date(date.getFullYear(), date.getMonth(), date.getDate()).toISOString() : key;\n                item.value = date;\n            }\n\n            return map.has(key) ? map : map.set(key, item)\n        }, new Map());\n        const uniqueValues = Array.from(filteredUniqueValues.values());\n\n        return uniqueValues;\n    }\n\n    protected shouldFormatFilterValues(_column: ColumnType): boolean {\n        return false;\n    }\n\n    public abstract filter(data: any[], expressionsTree: IFilteringExpressionsTree,\n        advancedExpressionsTree?: IFilteringExpressionsTree, grid?: GridType): any[];\n\n    protected abstract getFieldValue(rec: any, fieldName: string, isDate?: boolean, isTime?: boolean, grid?: GridType): any;\n}\n\n/* csSuppress */\nexport class NoopFilteringStrategy extends BaseFilteringStrategy {\n    protected getFieldValue(rec: any, _fieldName: string) {\n        return rec;\n    }\n    private static _instance: NoopFilteringStrategy = null;\n\n    public static instance() {\n        return this._instance || (this._instance = new NoopFilteringStrategy());\n    }\n\n    public filter(data: any[], _: IFilteringExpressionsTree, __?: IFilteringExpressionsTree): any[] {\n        return data;\n    }\n}\n\n\nexport class FilteringStrategy extends BaseFilteringStrategy {\n    private static _instance: FilteringStrategy = null;\n\n    constructor() {\n        super();\n    }\n\n    public static instance() {\n        return this._instance || (this._instance = new this());\n    }\n\n    public filter<T>(data: T[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree: IFilteringExpressionsTree,\n        grid: GridType): T[] {\n        let i;\n        let rec;\n        const len = data.length;\n        const res: T[] = [];\n\n        if ((FilteringExpressionsTree.empty(expressionsTree) && FilteringExpressionsTree.empty(advancedExpressionsTree)) || !len) {\n            return data;\n        }\n        for (i = 0; i < len; i++) {\n            rec = data[i];\n            if (this.matchRecord(rec, expressionsTree, grid) && this.matchRecord(rec, advancedExpressionsTree, grid)) {\n                res.push(rec);\n            }\n        }\n        return res;\n    }\n\n    protected getFieldValue(rec: any, fieldName: string, isDate = false, isTime = false, grid?: GridType): any {\n        const column = grid?.getColumnByName(fieldName);\n        let value = resolveNestedPath(rec, fieldName);\n\n        value = column?.formatter && this.shouldFormatFilterValues(column) ?\n            column.formatter(value, rec) :\n            value && (isDate || isTime) ? parseDate(value) : value;\n\n        return value;\n    }\n}\nexport class FormattedValuesFilteringStrategy extends FilteringStrategy {\n    /**\n     * Creates a new instance of FormattedValuesFilteringStrategy.\n     *\n     * @param fields An array of column field names that should be formatted.\n     * If omitted the values of all columns which has formatter will be formatted.\n     */\n    constructor(private fields?: string[]) {\n        super();\n    }\n\n    protected override shouldFormatFilterValues(column: ColumnType): boolean {\n        return !this.fields || this.fields.length === 0 || this.fields.some(f => f === column.field);\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filtering-strategy.js","sourceRoot":"","sources":["../../../../../projects/igniteui-angular/src/lib/data-operations/filtering-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["import { FilteringLogic, IFilteringExpression } from './filtering-expression.interface';\nimport { FilteringExpressionsTree, IFilteringExpressionsTree } from './filtering-expressions-tree';\nimport { resolveNestedPath, parseDate, formatDate, formatCurrency } from '../core/utils';\nimport { ColumnType, GridType } from '../grids/common/grid.interface';\nimport { GridColumnDataType } from './data-util';\nimport { SortingDirection } from './sorting-strategy';\nimport { formatNumber, formatPercent, getLocaleCurrencyCode } from '@angular/common';\nimport { IFilteringState } from './filtering-state.interface';\nimport { isTree } from './expressions-tree-util';\n\nconst DateType = 'date';\nconst DateTimeType = 'dateTime';\nconst TimeType = 'time';\n\nexport class FilterUtil {\n    public static filter<T>(data: T[], state: IFilteringState, grid?: GridType): T[] {\n        if (!state.strategy) {\n            state.strategy = new FilteringStrategy();\n        }\n        return state.strategy.filter(data, state.expressionsTree, state.advancedExpressionsTree, grid);\n    }\n}\n\nexport interface IFilteringStrategy {\n    filter(data: any[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree,\n        grid?: GridType): any[];\n    /* csSuppress */\n    getFilterItems(column: ColumnType, tree: IFilteringExpressionsTree) : Promise<IgxFilterItem[]>;\n}\n\n/* csSuppress */\nexport interface IgxFilterItem {\n    value: any;\n    label?: string;\n    children?: IgxFilterItem[];\n}\n\n/* csSuppress */\nexport abstract class BaseFilteringStrategy implements IFilteringStrategy  {\n    // protected\n    public findMatchByExpression(rec: any, expr: IFilteringExpression, isDate?: boolean, isTime?: boolean, grid?: GridType): boolean {\n        const cond = expr.condition;\n        const val = this.getFieldValue(rec, expr.fieldName, isDate, isTime, grid);\n        return cond.logic(val, expr.searchVal, expr.ignoreCase);\n    }\n\n    // protected\n    public matchRecord(rec: any, expressions: IFilteringExpressionsTree | IFilteringExpression, grid?: GridType): boolean {\n        if (expressions) {\n            if (isTree(expressions)) {\n                const expressionsTree = expressions;\n                const operator = expressionsTree.operator as FilteringLogic;\n                let matchOperand;\n\n                if (expressionsTree.filteringOperands && expressionsTree.filteringOperands.length) {\n                    for (const operand of expressionsTree.filteringOperands) {\n                        matchOperand = this.matchRecord(rec, operand, grid);\n\n                        // Return false if at least one operand does not match and the filtering logic is And\n                        if (!matchOperand && operator === FilteringLogic.And) {\n                            return false;\n                        }\n\n                        // Return true if at least one operand matches and the filtering logic is Or\n                        if (matchOperand && operator === FilteringLogic.Or) {\n                            return true;\n                        }\n                    }\n\n                    return matchOperand;\n                }\n\n                return true;\n            } else {\n                const expression = expressions;\n                const column = grid && grid.getColumnByName(expression.fieldName);\n                const isDate = column ? column.dataType === DateType || column.dataType === DateTimeType : false;\n                const isTime = column ? column.dataType === TimeType : false;\n                return this.findMatchByExpression(rec, expression, isDate, isTime, grid);\n            }\n        }\n\n        return true;\n    }\n\n    public getFilterItems(column: ColumnType, tree: IFilteringExpressionsTree): Promise<IgxFilterItem[]> {\n\n        let data = column.grid.gridAPI.filterDataByExpressions(tree);\n        data = column.grid.gridAPI.sortDataByExpressions(data,\n            [{ fieldName: column.field, dir: SortingDirection.Asc, ignoreCase: column.sortingIgnoreCase }]);\n\n        const columnField = column.field;\n        let filterItems: IgxFilterItem[] = data.map(record => {\n            let value = resolveNestedPath(record, columnField);\n            const applyFormatter = column.formatter && this.shouldFormatFilterValues(column);\n\n            value = applyFormatter ?\n                column.formatter(value, record) :\n                value;\n\n            return {\n                value,\n                label: this.getFilterItemLabel(column, value, !applyFormatter, record)\n            };\n        });\n        filterItems = this.getUniqueFilterItems(column, filterItems);\n\n        return Promise.resolve(filterItems);\n    }\n\n    protected getFilterItemLabel(column: ColumnType, value: any, applyFormatter: boolean, data: any) {\n        if (column.formatter) {\n            if (applyFormatter) {\n                return column.formatter(value, data);\n            }\n            return value;\n        }\n\n        const { display, format, digitsInfo, currencyCode, timezone } = column.pipeArgs;\n        const locale = column.grid.locale;\n\n        switch (column.dataType) {\n            case GridColumnDataType.Date:\n            case GridColumnDataType.DateTime:\n            case GridColumnDataType.Time:\n                return formatDate(value, format, locale, timezone);\n            case GridColumnDataType.Currency:\n                return formatCurrency(value, currencyCode || getLocaleCurrencyCode(locale), display, digitsInfo, locale);\n            case GridColumnDataType.Number:\n                return formatNumber(value, locale, digitsInfo);\n            case GridColumnDataType.Percent:\n                return formatPercent(value, locale, digitsInfo);\n            default:\n                return value;\n        }\n    }\n\n    protected getUniqueFilterItems(column: ColumnType, filterItems: IgxFilterItem[]) {\n        const filteredUniqueValues = filterItems.reduce((map, item) => {\n            let key = item.value;\n\n            if (column.dataType === GridColumnDataType.String && column.filteringIgnoreCase) {\n                key = key?.toString().toLowerCase();\n            } else if (column.dataType === GridColumnDataType.DateTime) {\n                key = item.value?.toString();\n                item.value = key ? new Date(key) : key;\n            } else if (column.dataType === GridColumnDataType.Time) {\n                const date = key ? new Date(key) : key;\n                key = date ? new Date().setHours(date.getHours(), date.getMinutes(), date.getSeconds()) : key;\n                item.value = key ? new Date(key) : key;\n            } else if (column.dataType === GridColumnDataType.Date) {\n                const date = key ? new Date(key) : key;\n                key = date ? new Date(date.getFullYear(), date.getMonth(), date.getDate()).toISOString() : key;\n                item.value = date;\n            }\n\n            return map.has(key) ? map : map.set(key, item)\n        }, new Map());\n        const uniqueValues = Array.from(filteredUniqueValues.values());\n\n        return uniqueValues;\n    }\n\n    protected shouldFormatFilterValues(_column: ColumnType): boolean {\n        return false;\n    }\n\n    public abstract filter(data: any[], expressionsTree: IFilteringExpressionsTree,\n        advancedExpressionsTree?: IFilteringExpressionsTree, grid?: GridType): any[];\n\n    protected abstract getFieldValue(rec: any, fieldName: string, isDate?: boolean, isTime?: boolean, grid?: GridType): any;\n}\n\n/* csSuppress */\nexport class NoopFilteringStrategy extends BaseFilteringStrategy {\n    protected getFieldValue(rec: any, _fieldName: string) {\n        return rec;\n    }\n    private static _instance: NoopFilteringStrategy = null;\n\n    public static instance() {\n        return this._instance || (this._instance = new NoopFilteringStrategy());\n    }\n\n    public filter(data: any[], _: IFilteringExpressionsTree, __?: IFilteringExpressionsTree): any[] {\n        return data;\n    }\n}\n\n\nexport class FilteringStrategy extends BaseFilteringStrategy {\n    private static _instance: FilteringStrategy = null;\n\n    constructor() {\n        super();\n    }\n\n    public static instance() {\n        return this._instance || (this._instance = new this());\n    }\n\n    public filter<T>(data: T[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree: IFilteringExpressionsTree,\n        grid: GridType): T[] {\n        let i;\n        let rec;\n        const len = data.length;\n        const res: T[] = [];\n\n        if ((FilteringExpressionsTree.empty(expressionsTree) && FilteringExpressionsTree.empty(advancedExpressionsTree)) || !len) {\n            return data;\n        }\n        for (i = 0; i < len; i++) {\n            rec = data[i];\n            if (this.matchRecord(rec, expressionsTree, grid) && this.matchRecord(rec, advancedExpressionsTree, grid)) {\n                res.push(rec);\n            }\n        }\n        return res;\n    }\n\n    protected getFieldValue(rec: any, fieldName: string, isDate = false, isTime = false, grid?: GridType): any {\n        const column = grid?.getColumnByName(fieldName);\n        let value = resolveNestedPath(rec, fieldName);\n\n        value = column?.formatter && this.shouldFormatFilterValues(column) ?\n            column.formatter(value, rec) :\n            value && (isDate || isTime) ? parseDate(value) : value;\n\n        return value;\n    }\n}\nexport class FormattedValuesFilteringStrategy extends FilteringStrategy {\n    /**\n     * Creates a new instance of FormattedValuesFilteringStrategy.\n     *\n     * @param fields An array of column field names that should be formatted.\n     * If omitted the values of all columns which has formatter will be formatted.\n     */\n    constructor(private fields?: string[]) {\n        super();\n    }\n\n    protected override shouldFormatFilterValues(column: ColumnType): boolean {\n        return !this.fields || this.fields.length === 0 || this.fields.some(f => f === column.field);\n    }\n}\n"]}

package/esm2022/lib/grids/filtering/excel-style/common.mjs

@@ -1,4 +1,4 @@
-import { FilteringExpressionsTree } from '../../../data-operations/filtering-expressions-tree';
+import { isTree } from '../../../data-operations/expressions-tree-util';
 /**
  * @hidden @internal
  */
@@ -33,10 +33,9 @@ function generateExpressionsListRecursive(expressions, operator, expressionsUIs)
     if (!expressions) {
         return;
     }
-    if (expressions instanceof FilteringExpressionsTree) {
-        const expressionsTree = expressions;
-        for (const operand of expressionsTree.filteringOperands) {
-            generateExpressionsListRecursive(operand, expressionsTree.operator, expressionsUIs);
+    if (isTree(expressions)) {
+        for (const operand of expressions.filteringOperands) {
+            generateExpressionsListRecursive(operand, expressions.operator, expressionsUIs);
         }
         if (expressionsUIs.length) {
             expressionsUIs[expressionsUIs.length - 1].afterOperator = operator;
@@ -53,4 +52,4 @@ function generateExpressionsListRecursive(expressions, operator, expressionsUIs)
         expressionsUIs.push(exprUI);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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