@itwin/components-react 3.7.3 → 3.7.5

package/lib/esm/components-react/table/columnfiltering/TableColumnFilterDescriptor.js

@@ -1,360 +1,360 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Table
- */
-import { DistinctValueCollection, FilterCompositionLogicalOperator, FilterDescriptorCollection, FilterOperator, } from "./ColumnFiltering";
-/* eslint-disable deprecation/deprecation */
-/** A ColumnFilterDescriptor for TableColumn.
- * @internal
- */
-export class TableColumnFilterDescriptor {
-    /** Initializes a new instance of the ColumnFilterDescriptor class.
-     * @param  column      The column.
-     * @param  memberKey   The member (key).
-     * @param  memberType  The member type.
-     */
-    constructor(column, memberKey, memberType) {
-        this._column = column;
-        this._memberKey = memberKey;
-        this._memberType = memberType;
-        this._distinctFilter = new DistinctValuesFilterDescriptorImpl(column);
-        this._fieldFilter = new FieldFilterDescriptorImpl(column);
-        this._compositeFilter = new CompositeFilterDescriptorImpl();
-        this._compositeFilter.logicalOperator = FilterCompositionLogicalOperator.And;
-        this._compositeFilter.filterDescriptorCollection.add(this._distinctFilter);
-        this._compositeFilter.filterDescriptorCollection.add(this._fieldFilter);
-    }
-    /** Gets the distinct values filter descriptor.
-     */
-    get distinctFilter() {
-        return this._distinctFilter;
-    }
-    /** Gets the field filter descriptor.
-     */
-    get fieldFilter() {
-        return this._fieldFilter;
-    }
-    /** Determines if the filter descriptor is active.
-     */
-    get isActive() {
-        return this._compositeFilter.isActive;
-    }
-    /** Gets the column.
-     */
-    get column() {
-        return this._column;
-    }
-    /** Clears the filter descriptor.
-     */
-    clear() {
-        this._distinctFilter.clear();
-        this._fieldFilter.clear();
-        // Do NOT call this._compositeFilter.clear() here. That removes the filters from the composite.
-    }
-    /** Evaluates a row for filtering
-     */
-    evaluateRow(row) {
-        return this._compositeFilter.evaluateRow(row);
-    }
-    /** Determines if this filter is for a particular column.
-     */
-    isFilterForColumn(columnKey) {
-        return (this.isActive && this._column.filterMemberKey === columnKey);
-    }
-    getFilterExpression() {
-        return this._compositeFilter.getFilterExpression();
-    }
-    /** Gets the member (key).
-     */
-    get memberKey() {
-        return this._memberKey;
-    }
-    /** Sets the member (key).
-     */
-    set memberKey(value) {
-        if (value !== this.memberKey) {
-            this._memberKey = value;
-            this.distinctFilter.filterDescriptorCollection.descriptors.forEach((fd) => fd.memberKey = value);
-            this.fieldFilter.filterDescriptorCollection.descriptors.forEach((fd) => fd.memberKey = value);
-        }
-    }
-    /** Gets the member type.
-     */
-    get memberType() {
-        return this._memberType;
-    }
-    /** Sets the member type.
-     */
-    set memberType(value) {
-        if (value !== this.memberType) {
-            this._memberType = value;
-            this.distinctFilter.filterDescriptorCollection.descriptors.forEach((fd) => fd.memberType = value);
-            this.fieldFilter.filterDescriptorCollection.descriptors.forEach((fd) => fd.memberType = value);
-        }
-    }
-}
-/** Filtering descriptor which serves as a container for one or more child filtering descriptors.
- * @internal
- */
-class CompositeFilterDescriptorImpl {
-    constructor() {
-        this._logicalOperator = FilterCompositionLogicalOperator.And;
-    }
-    /** Gets the logical operator.
-     */
-    get logicalOperator() { return this._logicalOperator; }
-    /** Sets the logical operator.
-     */
-    set logicalOperator(value) {
-        if (this._logicalOperator !== value) {
-            this._logicalOperator = value;
-        }
-    }
-    /** Gets the filter descriptors that will be used for composition.
-     */
-    get filterDescriptorCollection() {
-        if (!this._filterDescriptors) {
-            this._filterDescriptors = new FilterDescriptorCollection();
-        }
-        return this._filterDescriptors;
-    }
-    /** Determines if the filter descriptor is active.
-     */
-    get isActive() {
-        let active = false;
-        // istanbul ignore else
-        if (this._filterDescriptors)
-            active = this._filterDescriptors.isActive;
-        return active;
-    }
-    /** Clears the filter descriptor.
-     */
-    /* istanbul ignore next */
-    clear() {
-        if (this._filterDescriptors)
-            this._filterDescriptors.clear();
-    }
-    /** Evaluates a row for filtering
-     */
-    evaluateRow(row) {
-        let passed = true;
-        for (const fd of this.filterDescriptorCollection.descriptors) {
-            /* istanbul ignore next */
-            if (!fd.isActive)
-                continue;
-            passed = fd.evaluateRow(row);
-            if (passed && FilterCompositionLogicalOperator.Or === this.logicalOperator)
-                return true;
-            else if (!passed && FilterCompositionLogicalOperator.And === this.logicalOperator)
-                return false;
-        }
-        return passed;
-    }
-    /** Determines if this filter is for a particular column.
-     */
-    isFilterForColumn(columnKey) {
-        for (const fd of this.filterDescriptorCollection.descriptors) {
-            /* istanbul ignore next */
-            if (!fd.isActive)
-                continue;
-            if (fd.isFilterForColumn(columnKey))
-                return true;
-        }
-        return false;
-    }
-    /** Returns filter as ECExpression */
-    getFilterExpression() {
-        let result = "";
-        for (let i = 0; i < this.filterDescriptorCollection.descriptors.length; i++) {
-            if (!this.filterDescriptorCollection.descriptors[i].isActive)
-                continue;
-            if (i > 0 && result !== "") {
-                switch (this.logicalOperator) {
-                    case FilterCompositionLogicalOperator.And:
-                        result += (" And ");
-                        break;
-                    case FilterCompositionLogicalOperator.Or:
-                        result += (" Or ");
-                        break;
-                }
-            }
-            result += (`(${this.filterDescriptorCollection.descriptors[i].getFilterExpression()})`);
-        }
-        return result;
-    }
-}
-/** The default implementation of DistinctValuesFilterDescriptor.
- * @internal
- */
-class DistinctValuesFilterDescriptorImpl {
-    constructor(column) {
-        this._distinctValuesComparisonOperator = FilterOperator.IsEqualTo;
-        this._column = column;
-        this._compositeFilter = new CompositeFilterDescriptorImpl();
-        this._compositeFilter.logicalOperator = FilterCompositionLogicalOperator.Or;
-    }
-    /** Gets the distinct values from the collection as an Array.
-     */
-    get distinctValues() {
-        const distinctValues = new DistinctValueCollection();
-        for (const fd of this.filterDescriptorCollection.descriptors) {
-            distinctValues.values.push(fd.value);
-        }
-        return distinctValues;
-    }
-    /** Gets the collection of distinct values.
-     */
-    get filterDescriptorCollection() {
-        return this._compositeFilter.filterDescriptorCollection;
-    }
-    /** Determines if the filter descriptor is active.
-     */
-    get isActive() {
-        return this.filterDescriptorCollection.descriptors.some((fd) => fd.isActive);
-    }
-    /** Tries to find a distinct value in the collection.
-     */
-    tryFindDescriptor(distinctValue) {
-        return this.filterDescriptorCollection.descriptors.find((fd) => fd.value === distinctValue);
-    }
-    /** Adds a distinct value to the collection.
-     */
-    addDistinctValue(distinctValue) {
-        const existing = this.tryFindDescriptor(distinctValue);
-        if (existing) {
-            return;
-        }
-        const newFilterDescriptor = this._column.createSimpleFilterDescriptor(distinctValue, this.distinctValuesComparisonOperator);
-        newFilterDescriptor.isCaseSensitive = true;
-        this.filterDescriptorCollection.add(newFilterDescriptor);
-    }
-    /** Removes a distinct value from the collection.
-     */
-    removeDistinctValue(distinctValue) {
-        const existing = this.tryFindDescriptor(distinctValue);
-        if (existing) {
-            return this.filterDescriptorCollection.remove(existing);
-        }
-        return false;
-    }
-    /** Clears the filter descriptor.
-     */
-    clear() {
-        this.filterDescriptorCollection.clear();
-    }
-    /** Gets the distinct values comparison operator.
-     */
-    get distinctValuesComparisonOperator() { return this._distinctValuesComparisonOperator; }
-    /** Sets the distinct values comparison operator.
-     */
-    set distinctValuesComparisonOperator(value) {
-        // istanbul ignore else
-        if (this._distinctValuesComparisonOperator !== value) {
-            this._distinctValuesComparisonOperator = value;
-        }
-    }
-    /** Evaluates a row for filtering
-     */
-    evaluateRow(row) {
-        return this._compositeFilter.evaluateRow(row);
-    }
-    /** Determines if this filter is for a particular column.
-     */
-    isFilterForColumn(columnKey) {
-        return this._compositeFilter.isFilterForColumn(columnKey);
-    }
-    getFilterExpression() {
-        return this._compositeFilter.getFilterExpression();
-    }
-}
-/** The default implementation of IFieldFilterDescriptor.
- * @internal
- */
-class FieldFilterDescriptorImpl {
-    constructor(column) {
-        this._column = column;
-        this._compositeFilter = new CompositeFilterDescriptorImpl();
-        this._compositeFilter.logicalOperator = FilterCompositionLogicalOperator.Or;
-    }
-    /** Gets the logical operator.
-     */
-    get logicalOperator() {
-        return this._compositeFilter.logicalOperator;
-    }
-    /** Sets the logical operator.
-     */
-    set logicalOperator(value) {
-        this._compositeFilter.logicalOperator = value;
-    }
-    /** Determines if the filter descriptor is active.
-     */
-    get isActive() {
-        return this.filterDescriptorCollection.descriptors.some((fd) => fd.isActive);
-    }
-    /** Gets the collection of distinct values.
-     */
-    get filterDescriptorCollection() {
-        return this._compositeFilter.filterDescriptorCollection;
-    }
-    /** Tries to find a field value in the collection.
-     */
-    tryFindDescriptor(fieldValue, operator) {
-        return this.filterDescriptorCollection.descriptors.find((fd) => {
-            return fd.value === fieldValue && fd.operator === operator;
-        });
-    }
-    /** Adds a field value to the collection.
-     */
-    addFieldValue(fieldValue, operator, isCaseSensitive = false) {
-        const existing = this.tryFindDescriptor(fieldValue, operator);
-        if (existing) {
-            return;
-        }
-        const newFilterDescriptor = this._column.createSimpleFilterDescriptor(fieldValue, operator);
-        newFilterDescriptor.isCaseSensitive = isCaseSensitive;
-        this.filterDescriptorCollection.add(newFilterDescriptor);
-    }
-    /** Removes a distinct value from the collection.
-     */
-    removeFieldValue(fieldValue, operator) {
-        const existing = this.tryFindDescriptor(fieldValue, operator);
-        if (existing) {
-            return this.filterDescriptorCollection.remove(existing);
-        }
-        return false;
-    }
-    /** Clears the filter descriptor.
-     */
-    clear() {
-        this.logicalOperator = FilterCompositionLogicalOperator.And;
-        this.filterDescriptorCollection.clear();
-    }
-    /** Evaluates a row for filtering
-     */
-    evaluateRow(row) {
-        let result = true;
-        for (const fd of this.filterDescriptorCollection.descriptors) {
-            /* istanbul ignore next */
-            if (!fd.isActive)
-                continue;
-            result = fd.evaluateRow(row);
-            if (result && this.logicalOperator === FilterCompositionLogicalOperator.Or)
-                return true;
-            else if (!result && this.logicalOperator === FilterCompositionLogicalOperator.And)
-                return false;
-        }
-        return result;
-    }
-    /** Determines if this filter is for a particular column.
-     */
-    isFilterForColumn(columnKey) {
-        return (this.isActive && this._column.filterMemberKey === columnKey);
-    }
-    getFilterExpression() {
-        return this._compositeFilter.getFilterExpression();
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Table
+ */
+import { DistinctValueCollection, FilterCompositionLogicalOperator, FilterDescriptorCollection, FilterOperator, } from "./ColumnFiltering";
+/* eslint-disable deprecation/deprecation */
+/** A ColumnFilterDescriptor for TableColumn.
+ * @internal
+ */
+export class TableColumnFilterDescriptor {
+    /** Initializes a new instance of the ColumnFilterDescriptor class.
+     * @param  column      The column.
+     * @param  memberKey   The member (key).
+     * @param  memberType  The member type.
+     */
+    constructor(column, memberKey, memberType) {
+        this._column = column;
+        this._memberKey = memberKey;
+        this._memberType = memberType;
+        this._distinctFilter = new DistinctValuesFilterDescriptorImpl(column);
+        this._fieldFilter = new FieldFilterDescriptorImpl(column);
+        this._compositeFilter = new CompositeFilterDescriptorImpl();
+        this._compositeFilter.logicalOperator = FilterCompositionLogicalOperator.And;
+        this._compositeFilter.filterDescriptorCollection.add(this._distinctFilter);
+        this._compositeFilter.filterDescriptorCollection.add(this._fieldFilter);
+    }
+    /** Gets the distinct values filter descriptor.
+     */
+    get distinctFilter() {
+        return this._distinctFilter;
+    }
+    /** Gets the field filter descriptor.
+     */
+    get fieldFilter() {
+        return this._fieldFilter;
+    }
+    /** Determines if the filter descriptor is active.
+     */
+    get isActive() {
+        return this._compositeFilter.isActive;
+    }
+    /** Gets the column.
+     */
+    get column() {
+        return this._column;
+    }
+    /** Clears the filter descriptor.
+     */
+    clear() {
+        this._distinctFilter.clear();
+        this._fieldFilter.clear();
+        // Do NOT call this._compositeFilter.clear() here. That removes the filters from the composite.
+    }
+    /** Evaluates a row for filtering
+     */
+    evaluateRow(row) {
+        return this._compositeFilter.evaluateRow(row);
+    }
+    /** Determines if this filter is for a particular column.
+     */
+    isFilterForColumn(columnKey) {
+        return (this.isActive && this._column.filterMemberKey === columnKey);
+    }
+    getFilterExpression() {
+        return this._compositeFilter.getFilterExpression();
+    }
+    /** Gets the member (key).
+     */
+    get memberKey() {
+        return this._memberKey;
+    }
+    /** Sets the member (key).
+     */
+    set memberKey(value) {
+        if (value !== this.memberKey) {
+            this._memberKey = value;
+            this.distinctFilter.filterDescriptorCollection.descriptors.forEach((fd) => fd.memberKey = value);
+            this.fieldFilter.filterDescriptorCollection.descriptors.forEach((fd) => fd.memberKey = value);
+        }
+    }
+    /** Gets the member type.
+     */
+    get memberType() {
+        return this._memberType;
+    }
+    /** Sets the member type.
+     */
+    set memberType(value) {
+        if (value !== this.memberType) {
+            this._memberType = value;
+            this.distinctFilter.filterDescriptorCollection.descriptors.forEach((fd) => fd.memberType = value);
+            this.fieldFilter.filterDescriptorCollection.descriptors.forEach((fd) => fd.memberType = value);
+        }
+    }
+}
+/** Filtering descriptor which serves as a container for one or more child filtering descriptors.
+ * @internal
+ */
+class CompositeFilterDescriptorImpl {
+    constructor() {
+        this._logicalOperator = FilterCompositionLogicalOperator.And;
+    }
+    /** Gets the logical operator.
+     */
+    get logicalOperator() { return this._logicalOperator; }
+    /** Sets the logical operator.
+     */
+    set logicalOperator(value) {
+        if (this._logicalOperator !== value) {
+            this._logicalOperator = value;
+        }
+    }
+    /** Gets the filter descriptors that will be used for composition.
+     */
+    get filterDescriptorCollection() {
+        if (!this._filterDescriptors) {
+            this._filterDescriptors = new FilterDescriptorCollection();
+        }
+        return this._filterDescriptors;
+    }
+    /** Determines if the filter descriptor is active.
+     */
+    get isActive() {
+        let active = false;
+        // istanbul ignore else
+        if (this._filterDescriptors)
+            active = this._filterDescriptors.isActive;
+        return active;
+    }
+    /** Clears the filter descriptor.
+     */
+    /* istanbul ignore next */
+    clear() {
+        if (this._filterDescriptors)
+            this._filterDescriptors.clear();
+    }
+    /** Evaluates a row for filtering
+     */
+    evaluateRow(row) {
+        let passed = true;
+        for (const fd of this.filterDescriptorCollection.descriptors) {
+            /* istanbul ignore next */
+            if (!fd.isActive)
+                continue;
+            passed = fd.evaluateRow(row);
+            if (passed && FilterCompositionLogicalOperator.Or === this.logicalOperator)
+                return true;
+            else if (!passed && FilterCompositionLogicalOperator.And === this.logicalOperator)
+                return false;
+        }
+        return passed;
+    }
+    /** Determines if this filter is for a particular column.
+     */
+    isFilterForColumn(columnKey) {
+        for (const fd of this.filterDescriptorCollection.descriptors) {
+            /* istanbul ignore next */
+            if (!fd.isActive)
+                continue;
+            if (fd.isFilterForColumn(columnKey))
+                return true;
+        }
+        return false;
+    }
+    /** Returns filter as ECExpression */
+    getFilterExpression() {
+        let result = "";
+        for (let i = 0; i < this.filterDescriptorCollection.descriptors.length; i++) {
+            if (!this.filterDescriptorCollection.descriptors[i].isActive)
+                continue;
+            if (i > 0 && result !== "") {
+                switch (this.logicalOperator) {
+                    case FilterCompositionLogicalOperator.And:
+                        result += (" And ");
+                        break;
+                    case FilterCompositionLogicalOperator.Or:
+                        result += (" Or ");
+                        break;
+                }
+            }
+            result += (`(${this.filterDescriptorCollection.descriptors[i].getFilterExpression()})`);
+        }
+        return result;
+    }
+}
+/** The default implementation of DistinctValuesFilterDescriptor.
+ * @internal
+ */
+class DistinctValuesFilterDescriptorImpl {
+    constructor(column) {
+        this._distinctValuesComparisonOperator = FilterOperator.IsEqualTo;
+        this._column = column;
+        this._compositeFilter = new CompositeFilterDescriptorImpl();
+        this._compositeFilter.logicalOperator = FilterCompositionLogicalOperator.Or;
+    }
+    /** Gets the distinct values from the collection as an Array.
+     */
+    get distinctValues() {
+        const distinctValues = new DistinctValueCollection();
+        for (const fd of this.filterDescriptorCollection.descriptors) {
+            distinctValues.values.push(fd.value);
+        }
+        return distinctValues;
+    }
+    /** Gets the collection of distinct values.
+     */
+    get filterDescriptorCollection() {
+        return this._compositeFilter.filterDescriptorCollection;
+    }
+    /** Determines if the filter descriptor is active.
+     */
+    get isActive() {
+        return this.filterDescriptorCollection.descriptors.some((fd) => fd.isActive);
+    }
+    /** Tries to find a distinct value in the collection.
+     */
+    tryFindDescriptor(distinctValue) {
+        return this.filterDescriptorCollection.descriptors.find((fd) => fd.value === distinctValue);
+    }
+    /** Adds a distinct value to the collection.
+     */
+    addDistinctValue(distinctValue) {
+        const existing = this.tryFindDescriptor(distinctValue);
+        if (existing) {
+            return;
+        }
+        const newFilterDescriptor = this._column.createSimpleFilterDescriptor(distinctValue, this.distinctValuesComparisonOperator);
+        newFilterDescriptor.isCaseSensitive = true;
+        this.filterDescriptorCollection.add(newFilterDescriptor);
+    }
+    /** Removes a distinct value from the collection.
+     */
+    removeDistinctValue(distinctValue) {
+        const existing = this.tryFindDescriptor(distinctValue);
+        if (existing) {
+            return this.filterDescriptorCollection.remove(existing);
+        }
+        return false;
+    }
+    /** Clears the filter descriptor.
+     */
+    clear() {
+        this.filterDescriptorCollection.clear();
+    }
+    /** Gets the distinct values comparison operator.
+     */
+    get distinctValuesComparisonOperator() { return this._distinctValuesComparisonOperator; }
+    /** Sets the distinct values comparison operator.
+     */
+    set distinctValuesComparisonOperator(value) {
+        // istanbul ignore else
+        if (this._distinctValuesComparisonOperator !== value) {
+            this._distinctValuesComparisonOperator = value;
+        }
+    }
+    /** Evaluates a row for filtering
+     */
+    evaluateRow(row) {
+        return this._compositeFilter.evaluateRow(row);
+    }
+    /** Determines if this filter is for a particular column.
+     */
+    isFilterForColumn(columnKey) {
+        return this._compositeFilter.isFilterForColumn(columnKey);
+    }
+    getFilterExpression() {
+        return this._compositeFilter.getFilterExpression();
+    }
+}
+/** The default implementation of IFieldFilterDescriptor.
+ * @internal
+ */
+class FieldFilterDescriptorImpl {
+    constructor(column) {
+        this._column = column;
+        this._compositeFilter = new CompositeFilterDescriptorImpl();
+        this._compositeFilter.logicalOperator = FilterCompositionLogicalOperator.Or;
+    }
+    /** Gets the logical operator.
+     */
+    get logicalOperator() {
+        return this._compositeFilter.logicalOperator;
+    }
+    /** Sets the logical operator.
+     */
+    set logicalOperator(value) {
+        this._compositeFilter.logicalOperator = value;
+    }
+    /** Determines if the filter descriptor is active.
+     */
+    get isActive() {
+        return this.filterDescriptorCollection.descriptors.some((fd) => fd.isActive);
+    }
+    /** Gets the collection of distinct values.
+     */
+    get filterDescriptorCollection() {
+        return this._compositeFilter.filterDescriptorCollection;
+    }
+    /** Tries to find a field value in the collection.
+     */
+    tryFindDescriptor(fieldValue, operator) {
+        return this.filterDescriptorCollection.descriptors.find((fd) => {
+            return fd.value === fieldValue && fd.operator === operator;
+        });
+    }
+    /** Adds a field value to the collection.
+     */
+    addFieldValue(fieldValue, operator, isCaseSensitive = false) {
+        const existing = this.tryFindDescriptor(fieldValue, operator);
+        if (existing) {
+            return;
+        }
+        const newFilterDescriptor = this._column.createSimpleFilterDescriptor(fieldValue, operator);
+        newFilterDescriptor.isCaseSensitive = isCaseSensitive;
+        this.filterDescriptorCollection.add(newFilterDescriptor);
+    }
+    /** Removes a distinct value from the collection.
+     */
+    removeFieldValue(fieldValue, operator) {
+        const existing = this.tryFindDescriptor(fieldValue, operator);
+        if (existing) {
+            return this.filterDescriptorCollection.remove(existing);
+        }
+        return false;
+    }
+    /** Clears the filter descriptor.
+     */
+    clear() {
+        this.logicalOperator = FilterCompositionLogicalOperator.And;
+        this.filterDescriptorCollection.clear();
+    }
+    /** Evaluates a row for filtering
+     */
+    evaluateRow(row) {
+        let result = true;
+        for (const fd of this.filterDescriptorCollection.descriptors) {
+            /* istanbul ignore next */
+            if (!fd.isActive)
+                continue;
+            result = fd.evaluateRow(row);
+            if (result && this.logicalOperator === FilterCompositionLogicalOperator.Or)
+                return true;
+            else if (!result && this.logicalOperator === FilterCompositionLogicalOperator.And)
+                return false;
+        }
+        return result;
+    }
+    /** Determines if this filter is for a particular column.
+     */
+    isFilterForColumn(columnKey) {
+        return (this.isActive && this._column.filterMemberKey === columnKey);
+    }
+    getFilterExpression() {
+        return this._compositeFilter.getFilterExpression();
+    }
+}
 //# sourceMappingURL=TableColumnFilterDescriptor.js.map