@sisense/sdk-data 1.11.0 → 1.12.0

package/dist/cjs/dimensional-model/filters/utils/filter-matcher-utils.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFilterMatcher = void 0;
+const condition_filter_util_js_1 = require("./condition-filter-util.js");
+const filter_types_util_js_1 = require("./filter-types-util.js");
+const types_js_1 = require("./types.js");
+const defaultFormatter = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    return `${value}`;
+};
+const defaultDatetimeFormatter = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    return new Date(value).toISOString();
+};
+const defaultMatcher = () => false;
+function createCombinedFilterMatcher(createFilterMatcherFn, filterJaql) {
+    const filter = filterJaql.filter;
+    if ('or' in filter) {
+        return (value) => {
+            return filter.or
+                .map((filterItem) => createFilterMatcherFn(Object.assign(Object.assign({}, filterJaql), { filter: filterItem })))
+                .reduce((acc, filterMatcher) => {
+                return acc || filterMatcher(value);
+            }, false);
+        };
+    }
+    if ('and' in filter) {
+        return (value) => {
+            return filter.and
+                .map((filterItem) => createFilterMatcherFn(Object.assign(Object.assign({}, filterJaql), { filter: filterItem })))
+                .reduce((acc, filterMatcher) => {
+                return acc && filterMatcher(value);
+            }, true);
+        };
+    }
+    return createFilterMatcherFn(filterJaql);
+}
+function createMembersFilterMatcher(filterJaql) {
+    const { datatype } = filterJaql;
+    const filter = filterJaql.filter;
+    const formatter = datatype === 'datetime' ? defaultDatetimeFormatter : defaultFormatter;
+    return (value) => {
+        const formattedMembers = filter.members.map(formatter);
+        const formattedValue = formatter(value);
+        return formattedMembers.includes(formattedValue);
+    };
+}
+function createExcludeMembersFilterMatcher(filterJaql) {
+    const { datatype } = filterJaql;
+    const filter = filterJaql.filter;
+    const formatter = datatype === 'datetime' ? defaultDatetimeFormatter : defaultFormatter;
+    return (value) => {
+        var _a, _b;
+        const formattedMembers = ((_b = (_a = filter.exclude) === null || _a === void 0 ? void 0 : _a.members) === null || _b === void 0 ? void 0 : _b.map(formatter)) || [];
+        const formattedValue = formatter(value);
+        return !formattedMembers.includes(formattedValue);
+    };
+}
+function createTextFilterMatcher(filterJaql) {
+    const filter = filterJaql.filter;
+    const conditionFilterType = (0, condition_filter_util_js_1.getSelectedConditionOption)(filter);
+    if (conditionFilterType === types_js_1.ConditionFilterType.STARTS_WITH) {
+        return (value) => {
+            return new RegExp(`^${filter.startsWith}`, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.ENDS_WITH) {
+        return (value) => {
+            return new RegExp(`${filter.endsWith}$`, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.CONTAINS) {
+        return (value) => {
+            return new RegExp(filter.contains, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.EQUALS) {
+        return (value) => {
+            return (value.localeCompare(filter.equals, undefined, {
+                sensitivity: 'base',
+            }) === 0);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.DOESNT_START_WITH) {
+        return (value) => {
+            return !new RegExp(`^${filter.doesntStartWith}`, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.DOESNT_END_WITH) {
+        return (value) => {
+            return !new RegExp(`${filter.doesntEndWith}$`, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.DOESNT_CONTAIN) {
+        return (value) => {
+            return !new RegExp(filter.doesntContain, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.DOESNT_EQUAL) {
+        return (value) => {
+            return (value.localeCompare(filter.doesntEqual, undefined, {
+                sensitivity: 'base',
+            }) !== 0);
+        };
+    }
+    return defaultMatcher;
+}
+function createNumericFilterMatcher(filterJaql) {
+    const filter = filterJaql.filter;
+    const conditionFilterType = (0, condition_filter_util_js_1.getSelectedConditionOption)(filter);
+    if (conditionFilterType === types_js_1.ConditionFilterType.EQUALS) {
+        return (value) => {
+            return Number(filter.equals) === Number(value);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.DOESNT_EQUAL) {
+        return (value) => {
+            return Number(filter.doesntEqual) !== Number(value);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.LESS_THAN) {
+        return (value) => {
+            return Number(value) < Number(filter.toNotEqual);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.GREATER_THAN) {
+        return (value) => {
+            return Number(value) > Number(filter.fromNotEqual);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.BETWEEN) {
+        return (value) => {
+            return Number(filter.to) >= Number(value) && Number(value) >= Number(filter.from);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL) {
+        return (value) => {
+            return Number(value) >= Number(filter.from);
+        };
+    }
+    if (conditionFilterType === types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL) {
+        return (value) => {
+            return Number(filter.to) >= Number(value);
+        };
+    }
+    return defaultMatcher;
+}
+/** @internal */
+function createFilterMatcher(filterJaql) {
+    const filterJaqlInternal = filterJaql;
+    const { datatype } = filterJaqlInternal;
+    const filter = filterJaqlInternal.filter;
+    if ((0, filter_types_util_js_1.isSpecificItemsFilter)(filter)) {
+        return createMembersFilterMatcher(filterJaqlInternal);
+    }
+    if ((0, filter_types_util_js_1.isConditionFilter)(filter) &&
+        (0, condition_filter_util_js_1.getSelectedConditionOption)(filter) === types_js_1.ConditionFilterType.IS_NOT) {
+        return createExcludeMembersFilterMatcher(filterJaqlInternal);
+    }
+    // text filters
+    if (datatype === 'text') {
+        return createCombinedFilterMatcher(createTextFilterMatcher, filterJaqlInternal);
+    }
+    // // numeric filters
+    if (datatype === 'numeric') {
+        return createCombinedFilterMatcher(createNumericFilterMatcher, filterJaqlInternal);
+    }
+    return defaultMatcher;
+}
+exports.createFilterMatcher = createFilterMatcher;

package/dist/cjs/dimensional-model/filters/utils/filter-matcher-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/dimensional-model/filters/utils/filter-matcher-utils.test.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const filter_matcher_utils_js_1 = require("./filter-matcher-utils.js");
+describe('createFilterMatcher', () => {
+    it('should create a filter matcher for specific items', () => {
+        const membersFilterJaql = {
+            datatype: 'text',
+            filter: {
+                members: ['item1', 'item2', 'item3'],
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(membersFilterJaql);
+        expect(filterMatcher('item1')).toBe(true);
+        expect(filterMatcher('item4')).toBe(false);
+    });
+    it('should create a filter matcher for excluding specific items', () => {
+        const excludeMembersFilterJaql = {
+            datatype: 'text',
+            filter: {
+                exclude: {
+                    members: ['exclude1', 'exclude2'],
+                },
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(excludeMembersFilterJaql);
+        expect(filterMatcher('exclude1')).toBe(false);
+        expect(filterMatcher('exclude3')).toBe(true);
+    });
+    it('should create a text filter matcher for STARTS_WITH text condition', () => {
+        const startWithFilterJaql = {
+            datatype: 'text',
+            filter: {
+                startsWith: 'abc',
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(startWithFilterJaql);
+        expect(filterMatcher('abcdef')).toBe(true);
+        expect(filterMatcher('xyzabc')).toBe(false);
+    });
+    it('should create a text filter matcher for ENDS_WITH text condition', () => {
+        const endsWithFilterJaql = {
+            datatype: 'text',
+            filter: {
+                endsWith: 'abc',
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(endsWithFilterJaql);
+        expect(filterMatcher('abcdef')).toBe(false);
+        expect(filterMatcher('xyzabc')).toBe(true);
+    });
+    it('should create a text filter matcher for CONTAINS text condition', () => {
+        const containsFilterJaql = {
+            datatype: 'text',
+            filter: {
+                contains: 'abc',
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(containsFilterJaql);
+        expect(filterMatcher('abcdef')).toBe(true);
+        expect(filterMatcher('xyz')).toBe(false);
+    });
+    it('should create a filter matcher for EQUALS text condition', () => {
+        const equalsFilterJaql = {
+            datatype: 'text',
+            filter: {
+                equals: 'abc',
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(equalsFilterJaql);
+        expect(filterMatcher('abc')).toBe(true);
+        expect(filterMatcher('def')).toBe(false);
+    });
+    it('should create a text filter matcher for DOESNT_START_WITH text condition', () => {
+        const doesntStartWithFilterJaql = {
+            datatype: 'text',
+            filter: {
+                doesntStartWith: 'abc',
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(doesntStartWithFilterJaql);
+        expect(filterMatcher('abcdef')).toBe(false);
+        expect(filterMatcher('xyzabc')).toBe(true);
+    });
+    it('should create a text filter matcher for DOESNT_END_WITH text condition', () => {
+        const doesntEndWithFilterJaql = {
+            datatype: 'text',
+            filter: {
+                doesntEndWith: 'abc',
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(doesntEndWithFilterJaql);
+        expect(filterMatcher('abcdef')).toBe(true);
+        expect(filterMatcher('xyzabc')).toBe(false);
+    });
+    it('should create a text filter matcher for DOESNT_CONTAIN text condition', () => {
+        const doesntContainFilterJaql = {
+            datatype: 'text',
+            filter: {
+                doesntContain: 'abc',
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(doesntContainFilterJaql);
+        expect(filterMatcher('abcdef')).toBe(false);
+        expect(filterMatcher('xyz')).toBe(true);
+    });
+    it('should create a filter matcher for DOESNT_EQUAL text condition', () => {
+        const doesntEqualFilterJaql = {
+            datatype: 'text',
+            filter: {
+                doesntEqual: 'abc',
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(doesntEqualFilterJaql);
+        expect(filterMatcher('abc')).toBe(false);
+        expect(filterMatcher('def')).toBe(true);
+    });
+    it('should create a filter matcher for EQUALS numeric condition', () => {
+        const equalsNumericFilterJaql = {
+            datatype: 'numeric',
+            filter: {
+                equals: 10,
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(equalsNumericFilterJaql);
+        expect(filterMatcher(10)).toBe(true);
+        expect(filterMatcher(5)).toBe(false);
+    });
+    it('should create a filter matcher for DOESNT_EQUAL numeric condition', () => {
+        const doesntEqualNumericFilterJaql = {
+            datatype: 'numeric',
+            filter: {
+                doesntEqual: 10,
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(doesntEqualNumericFilterJaql);
+        expect(filterMatcher(10)).toBe(false);
+        expect(filterMatcher(5)).toBe(true);
+    });
+    it('should create a filter matcher for LESS_THAN numeric condition', () => {
+        const lessThanNumericFilterJaql = {
+            datatype: 'numeric',
+            filter: {
+                toNotEqual: 10,
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(lessThanNumericFilterJaql);
+        expect(filterMatcher(5)).toBe(true);
+        expect(filterMatcher(15)).toBe(false);
+    });
+    it('should create a filter matcher for GREATER_THAN numeric condition', () => {
+        const greaterThanNumericFilterJaql = {
+            datatype: 'numeric',
+            filter: {
+                fromNotEqual: 10,
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(greaterThanNumericFilterJaql);
+        expect(filterMatcher(15)).toBe(true);
+        expect(filterMatcher(5)).toBe(false);
+    });
+    it('should create a filter matcher for BETWEEN numeric condition', () => {
+        const betweenNumericFilterJaql = {
+            datatype: 'numeric',
+            filter: {
+                from: 5,
+                to: 10,
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(betweenNumericFilterJaql);
+        expect(filterMatcher(7)).toBe(true);
+        expect(filterMatcher(3)).toBe(false);
+        expect(filterMatcher(12)).toBe(false);
+    });
+    it('should create a filter matcher for GREATER_THAN_OR_EQUAL numeric condition', () => {
+        const greaterThanOrEqualNumericFilterJaql = {
+            datatype: 'numeric',
+            filter: {
+                from: 10,
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(greaterThanOrEqualNumericFilterJaql);
+        expect(filterMatcher(15)).toBe(true);
+        expect(filterMatcher(10)).toBe(true);
+        expect(filterMatcher(5)).toBe(false);
+    });
+    it('should create a filter matcher for LESS_THAN_OR_EQUAL numeric condition', () => {
+        const lessThanOrEqualNumericFilterJaql = {
+            datatype: 'numeric',
+            filter: {
+                to: 10,
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(lessThanOrEqualNumericFilterJaql);
+        expect(filterMatcher(5)).toBe(true);
+        expect(filterMatcher(10)).toBe(true);
+        expect(filterMatcher(15)).toBe(false);
+    });
+    it('should create a filter matcher for "AND" combined multiple condition filters', () => {
+        const andCombinedFilterJaql = {
+            datatype: 'numeric',
+            filter: {
+                and: [
+                    {
+                        toNotEqual: 10,
+                    },
+                    {
+                        fromNotEqual: 5,
+                    },
+                ],
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(andCombinedFilterJaql);
+        expect(filterMatcher(10)).toBe(false);
+        expect(filterMatcher(7)).toBe(true);
+        expect(filterMatcher(5)).toBe(false);
+    });
+    it('should create a filter matcher for "OR" combined multiple condition filters', () => {
+        const orCombinedFilterJaql = {
+            datatype: 'text',
+            filter: {
+                or: [
+                    {
+                        equals: 'apple',
+                    },
+                    {
+                        equals: 'banana',
+                    },
+                ],
+            },
+        };
+        const filterMatcher = (0, filter_matcher_utils_js_1.createFilterMatcher)(orCombinedFilterJaql);
+        expect(filterMatcher('apple')).toBe(true);
+        expect(filterMatcher('banana')).toBe(true);
+        expect(filterMatcher('orange')).toBe(false);
+    });
+});

package/dist/cjs/dimensional-model/filters/utils/filter-types-util.d.ts

@@ -0,0 +1,17 @@
+import { FilterModalType, AnyTypeFilterJaql, DatetimeLevel, FilterType, SpecificItemsFilterJaql, ConditionFilterJaql, FilterJaqlInternal, FilterJaqlWrapperWithType } from './types.js';
+export declare const isSpecificItemsFilter: (filter: AnyTypeFilterJaql) => filter is SpecificItemsFilterJaql;
+export declare const isNumericRangeFilter: (filter: AnyTypeFilterJaql) => boolean;
+export declare const isConditionFilter: (filter: AnyTypeFilterJaql) => filter is ConditionFilterJaql;
+export declare const getFilterType: (filter: AnyTypeFilterJaql, dataType?: FilterModalType, timeData?: {
+    level?: DatetimeLevel;
+    bucket?: string;
+}) => FilterType;
+/**
+ * Extracts Filter Type from Filter Jaql
+ *
+ * @param jaql - jaql
+ * @param dataType - data type
+ * @return FilterJaqlWrapperType
+ * @internal
+ */
+export declare const extractFilterTypeFromFilterJaql: (jaql: FilterJaqlInternal, dataType: FilterModalType) => FilterJaqlWrapperWithType;

package/dist/cjs/dimensional-model/filters/utils/filter-types-util.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFilterTypeFromFilterJaql = exports.getFilterType = exports.isConditionFilter = exports.isNumericRangeFilter = exports.isSpecificItemsFilter = void 0;
+const condition_filter_util_js_1 = require("./condition-filter-util.js");
+const types_js_1 = require("./types.js");
+const date_time_filter_util_js_1 = require("./date-time-filter-util.js");
+const isIncludeAllFilter = (filter) => filter === null || filter === void 0 ? void 0 : filter.all;
+const getInnerPeriodFilter = (filter) => (filter.last ? filter.last : filter.next);
+const isPeriodFilter = (filter) => { var _a; return ((_a = getInnerPeriodFilter(filter)) === null || _a === void 0 ? void 0 : _a.offset) < 2; };
+const isSpecificItemsFilter = (filter) => { var _a; return ((_a = filter === null || filter === void 0 ? void 0 : filter.members) === null || _a === void 0 ? void 0 : _a.length) > 0; };
+exports.isSpecificItemsFilter = isSpecificItemsFilter;
+const isFromOrToDefined = (fromRange, toRange) => (fromRange && typeof fromRange === 'string') || (toRange && typeof toRange === 'string');
+const isFromAndToEmpty = (from, to) => from === '' && to === '';
+const isDateRangeFilter = (filter, dataType) => {
+    const { from, to } = filter;
+    if (dataType !== types_js_1.FilterModalType.DATE_TIME)
+        return false;
+    if (isFromOrToDefined(from, to))
+        return true;
+    return isFromAndToEmpty(from, to);
+};
+const isNumericRangeFilter = (filter) => {
+    const { from, to } = filter;
+    return !!(from !== undefined && to !== undefined && !filter.isBetween);
+};
+exports.isNumericRangeFilter = isNumericRangeFilter;
+const isConditionFilter = (filter) => (0, condition_filter_util_js_1.getSelectedConditionOption)(filter) !== types_js_1.ConditionFilterType.NONE;
+exports.isConditionFilter = isConditionFilter;
+const isAdvancedFilter = (filter) => Object.keys(filter).includes('isAdvanced');
+const isTimeLevelNotSupported = (timeData) => !!(timeData.level &&
+    timeData.bucket &&
+    timeData.level === types_js_1.DatetimeLevel.MINUTES &&
+    types_js_1.nonSupportedMinutesBuckets.includes(timeData.bucket));
+const isInvalidFilter = (filter) => filter.filterType === types_js_1.FILTER_TYPES.INVALID;
+const getFilterType = (filter, dataType = types_js_1.FilterModalType.DATE_TIME, timeData) => {
+    if (timeData && isTimeLevelNotSupported(timeData))
+        return types_js_1.FILTER_TYPES.ADVANCED;
+    if (isIncludeAllFilter(filter))
+        return types_js_1.FILTER_TYPES.INCLUDE_ALL;
+    if (isPeriodFilter(filter))
+        return types_js_1.FILTER_TYPES.PERIOD;
+    if ((0, exports.isSpecificItemsFilter)(filter))
+        return types_js_1.FILTER_TYPES.SPECIFIC_ITEMS;
+    if (isDateRangeFilter(filter, dataType))
+        return types_js_1.FILTER_TYPES.DATE_RANGE;
+    if ((0, exports.isNumericRangeFilter)(filter))
+        return types_js_1.FILTER_TYPES.NUMERIC_RANGE;
+    if ((0, exports.isConditionFilter)(filter))
+        return types_js_1.FILTER_TYPES.CONDITION;
+    if (isAdvancedFilter(filter))
+        return types_js_1.FILTER_TYPES.ADVANCED;
+    if (isInvalidFilter(filter))
+        return types_js_1.FILTER_TYPES.INVALID;
+    return types_js_1.FILTER_TYPES.ADVANCED;
+};
+exports.getFilterType = getFilterType;
+/**
+ * Extracts Filter Type from Filter Jaql
+ *
+ * @param jaql - jaql
+ * @param dataType - data type
+ * @return FilterJaqlWrapperType
+ * @internal
+ */
+const extractFilterTypeFromFilterJaql = (jaql, dataType) => {
+    const { level: filterLevel, filter, bucket } = jaql;
+    const filterFromJaql = filter || types_js_1.DEFAULT_FILTER_JAQL_WRAPPER.filter;
+    const filterToReturn = {
+        filter: Object.assign(Object.assign({}, filterFromJaql), { filterType: (0, exports.getFilterType)(filterFromJaql, dataType) }),
+    };
+    if (dataType === types_js_1.FilterModalType.DATE_TIME) {
+        const backgroundFilter = filterFromJaql;
+        const level = (backgroundFilter === null || backgroundFilter === void 0 ? void 0 : backgroundFilter.level) || filterLevel;
+        filterToReturn.level = (0, date_time_filter_util_js_1.getCorrectTimeLevel)(level, bucket);
+        filterToReturn.filter.filterType = (0, exports.getFilterType)(filterFromJaql, dataType, { level, bucket });
+    }
+    return filterToReturn;
+};
+exports.extractFilterTypeFromFilterJaql = extractFilterTypeFromFilterJaql;