npm - @sisense/sdk-data - Versions diffs - 1.14.0 → 1.15.1 - Mend

@sisense/sdk-data 1.14.0 → 1.15.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

package/dist/cjs/dimensional-model/filters/utils/filter-from-jaql-util.test.js DELETED Viewed

@@ -1,623 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable vitest/expect-expect */
-const vitest_1 = require("vitest");
-const filter_from_jaql_util_js_1 = require("./filter-from-jaql-util.js");
-const filterFactory = __importStar(require("../factory.js"));
-const types_js_1 = require("./types.js");
-const attribute_measure_util_js_1 = require("./attribute-measure-util.js");
-const condition_filter_util_js_1 = require("./condition-filter-util.js");
-const filter_from_jaql_util_js_2 = require("./filter-from-jaql-util.js");
-const filter_code_util_js_1 = require("./filter-code-util.js");
-(0, vitest_1.describe)('filter-from-jaql-util', () => {
-    (0, vitest_1.describe)('createFilterFromJaqlInternal', () => {
-        const guid = 'instanceid';
-        const expectEqualFilters = (actual, expected) => {
-            // delete compose code
-            delete actual.composeCode;
-            expect(Object.assign({}, actual)).toEqual(Object.assign({}, expected));
-            expect(actual.serializable()).toBeDefined();
-        };
-        (0, vitest_1.describe)('MembersFilter', () => {
-            it('should handle include all', () => {
-                const jaql = {
-                    table: 'Category',
-                    column: 'Category',
-                    dim: '[Category.Category]',
-                    datatype: 'text',
-                    filter: {
-                        explicit: true,
-                        multiSelection: true,
-                        all: true,
-                    },
-                    title: 'Category',
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.members(attribute, [], [], guid);
-                expectEqualFilters(filter, expectedFilter);
-            });
-            it('should handle members text', () => {
-                const jaql = {
-                    table: 'Category',
-                    column: 'Category',
-                    dim: '[Category.Category]',
-                    datatype: 'text',
-                    filter: {
-                        explicit: true,
-                        multiSelection: true,
-                        members: ['Cell Phones', 'GPS Devices'],
-                    },
-                    title: 'Category',
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.members(attribute, jaql.filter.members, [], guid);
-                expectEqualFilters(filter, expectedFilter);
-            });
-            test('should handle members datetime', () => {
-                [
-                    {
-                        title: 'Years',
-                        table: 'Commerce',
-                        column: 'Date',
-                        dim: '[Commerce.Date (Calendar)]',
-                        datatype: 'datetime',
-                        level: 'years',
-                        filter: {
-                            explicit: true,
-                            multiSelection: true,
-                            members: ['2013-01-01T00:00:00', '2011-01-01T00:00:00'],
-                        },
-                    },
-                    {
-                        datasource: {
-                            title: 'Sample ECommerce',
-                            fullname: 'LocalHost/Sample ECommerce',
-                            id: 'localhost_aSampleIAAaECommerce',
-                            address: 'LocalHost',
-                            database: 'aSampleIAAaECommerce',
-                        },
-                        column: 'Date',
-                        dim: '[Commerce.Date (Calendar)]',
-                        datatype: 'datetime',
-                        level: 'years',
-                        title: 'YEARS',
-                        collapsed: true,
-                        isDashboardFilter: true,
-                        filter: {
-                            explicit: true,
-                            multiSelection: true,
-                            members: ['2013-01-01T00:00:00'],
-                        },
-                    },
-                ].forEach((jaql) => {
-                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                    const expectedFilter = filterFactory.members(attribute, jaql.filter.members, [], guid);
-                    expectEqualFilters(filter, expectedFilter);
-                });
-            });
-            test('should handle JAQL without table name', () => {
-                const jaql = {
-                    column: 'Category',
-                    dim: '[Category.Category]',
-                    datatype: 'text',
-                    filter: {
-                        explicit: true,
-                        multiSelection: true,
-                        members: ['Cell Phones', 'GPS Devices'],
-                    },
-                    title: 'Category',
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.members(attribute, jaql.filter.members, [], guid);
-                expectEqualFilters(filter, expectedFilter);
-            });
-            it('should handle deactivated members', () => {
-                const jaql = {
-                    datasource: {
-                        title: 'Sample ECommerce',
-                        fullname: 'LocalHost/Sample ECommerce',
-                        id: 'localhost_aSampleIAAaECommerce',
-                        address: 'LocalHost',
-                        database: 'aSampleIAAaECommerce',
-                    },
-                    column: 'Country',
-                    dim: '[country.Country]',
-                    datatype: 'text',
-                    title: 'COUNTRY',
-                    collapsed: true,
-                    isDashboardFilter: true,
-                    filter: {
-                        explicit: true,
-                        multiSelection: true,
-                        members: ['Albania', 'Algeria', 'Angola'],
-                        filter: {
-                            turnedOff: true,
-                            exclude: {
-                                members: ['Angola'],
-                            },
-                        },
-                    },
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.members(attribute, ['Albania', 'Algeria'], ['Angola'], guid);
-                expectEqualFilters(filter, expectedFilter);
-            });
-        });
-        (0, vitest_1.describe)('NumericFilter', () => {
-            test('should handle unary operator for number', () => {
-                [
-                    { operator: types_js_1.ConditionFilterType.GREATER_THAN, factoryFunc: filterFactory.greaterThan },
-                    {
-                        operator: types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL,
-                        factoryFunc: filterFactory.greaterThanOrEqual,
-                    },
-                    { operator: types_js_1.ConditionFilterType.EQUALS, factoryFunc: filterFactory.equals },
-                    { operator: types_js_1.ConditionFilterType.LESS_THAN, factoryFunc: filterFactory.lessThan },
-                    {
-                        operator: types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL,
-                        factoryFunc: filterFactory.lessThanOrEqual,
-                    },
-                ].forEach((test) => {
-                    const jaql = {
-                        table: 'Commerce',
-                        column: 'Revenue',
-                        datatype: 'numeric',
-                        dim: '[Commerce.Revenue]',
-                        title: 'Revenue',
-                        filter: {
-                            [test.operator]: 1000,
-                        },
-                    };
-                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                    const expectedFilter = test.factoryFunc(attribute, jaql.filter[test.operator], guid);
-                    expectEqualFilters(filter, expectedFilter);
-                });
-            });
-            test('should handle unary operator for string', () => {
-                [
-                    { operator: types_js_1.ConditionFilterType.EQUALS, factoryFunc: filterFactory.equals },
-                    { operator: types_js_1.ConditionFilterType.STARTS_WITH, factoryFunc: filterFactory.startsWith },
-                    {
-                        operator: types_js_1.ConditionFilterType.DOESNT_START_WITH,
-                        factoryFunc: filterFactory.doesntStartWith,
-                    },
-                    {
-                        operator: types_js_1.ConditionFilterType.ENDS_WITH,
-                        factoryFunc: filterFactory.endsWith,
-                    },
-                    {
-                        operator: types_js_1.ConditionFilterType.DOESNT_END_WITH,
-                        factoryFunc: filterFactory.doesntEndWith,
-                    },
-                    {
-                        operator: types_js_1.ConditionFilterType.CONTAINS,
-                        factoryFunc: filterFactory.contains,
-                    },
-                    {
-                        operator: types_js_1.ConditionFilterType.DOESNT_CONTAIN,
-                        factoryFunc: filterFactory.doesntContain,
-                    },
-                ].forEach((test) => {
-                    const jaql = {
-                        table: 'Country',
-                        column: 'Country',
-                        datatype: 'text',
-                        dim: '[Country.Country]',
-                        title: 'Country',
-                        filter: {
-                            [test.operator]: 'ABC',
-                        },
-                    };
-                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                    const expectedFilter = test.factoryFunc(attribute, jaql.filter[test.operator], guid);
-                    expectEqualFilters(filter, expectedFilter);
-                });
-            });
-            test('should handle binary operator', () => {
-                [{ operator: types_js_1.ConditionFilterType.BETWEEN, factoryFunc: filterFactory.between }].forEach((test) => {
-                    const jaql = {
-                        table: 'Commerce',
-                        column: 'Revenue',
-                        datatype: 'numeric',
-                        dim: '[Commerce.Revenue]',
-                        title: 'Revenue',
-                        filter: {
-                            from: 1000,
-                            to: 2000,
-                        },
-                    };
-                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                    const expectedFilter = test.factoryFunc(attribute, jaql.filter.from, jaql.filter.to, guid);
-                    expectEqualFilters(filter, expectedFilter);
-                });
-            });
-            test('should handle not between operator', () => {
-                const jaql = {
-                    table: 'Commerce',
-                    column: 'Revenue',
-                    datatype: 'numeric',
-                    dim: '[Commerce.Revenue]',
-                    title: 'Revenue',
-                    filter: {
-                        exclude: {
-                            from: 1000,
-                            to: 2000,
-                        },
-                    },
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.exclude(filterFactory.between(attribute, jaql.filter.exclude.from, jaql.filter.exclude.to, guid), undefined, guid);
-                expectEqualFilters(filter.filter, expectedFilter.filter);
-                expect(filter.serializable()).toBeDefined();
-                expect(filter.id).toEqual(expectedFilter.id);
-            });
-        });
-        (0, vitest_1.describe)('RelativeDateFilter', () => {
-            test('should handle dateRelativeFrom', () => {
-                [
-                    {
-                        jaql: {
-                            title: 'Years',
-                            table: 'Commerce',
-                            column: 'Date',
-                            dim: '[Commerce.Date (Calendar)]',
-                            datatype: 'datetime',
-                            level: 'months',
-                            filter: {
-                                next: {
-                                    count: 18,
-                                    offset: 0,
-                                    anchor: '2011-01',
-                                },
-                            },
-                        },
-                        factoryFunc: filterFactory.dateRelativeFrom,
-                    },
-                ].forEach(({ jaql, factoryFunc }) => {
-                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                    const expectedFilter = factoryFunc(attribute, jaql.filter.next.offset, jaql.filter.next.count, jaql.filter.next.anchor, guid);
-                    expectEqualFilters(filter, expectedFilter);
-                    expect(filter.serializable()).toBeDefined();
-                    expect(filter.jaql().jaql).toEqual(expectedFilter.jaql().jaql);
-                });
-            });
-            test('should handle dateRelativeTo', () => {
-                [
-                    {
-                        jaql: {
-                            title: 'Years',
-                            table: 'Commerce',
-                            column: 'Date',
-                            dim: '[Commerce.Date (Calendar)]',
-                            datatype: 'datetime',
-                            level: 'months',
-                            filter: {
-                                last: {
-                                    count: 18,
-                                    offset: 0,
-                                    anchor: '2011-01',
-                                },
-                            },
-                        },
-                        factoryFunc: filterFactory.dateRelativeTo,
-                    },
-                ].forEach(({ jaql, factoryFunc }) => {
-                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                    const expectedFilter = factoryFunc(attribute, jaql.filter.last.offset, jaql.filter.last.count, jaql.filter.last.anchor, guid);
-                    expectEqualFilters(filter, expectedFilter);
-                });
-            });
-        });
-        (0, vitest_1.describe)('DateRangeFilter', () => {
-            test('should handle', () => {
-                const jaql = {
-                    title: 'Years',
-                    table: 'Commerce',
-                    column: 'Date',
-                    dim: '[Commerce.Date (Calendar)]',
-                    datatype: 'datetime',
-                    level: 'years',
-                    filter: {
-                        from: '2010-01-01',
-                        to: '2012-01-01',
-                    },
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.dateRange(attribute, '2010-01-01', '2012-01-01', guid);
-                expectEqualFilters(filter, expectedFilter);
-                expect(filter.from).toBeDefined();
-                expect(filter.to).toBeDefined();
-                expect(filter.level).toBeDefined();
-            });
-        });
-        (0, vitest_1.describe)('RankingFilter', () => {
-            it('should handle top', () => {
-                const jaql = {
-                    table: 'Brand',
-                    column: 'Brand',
-                    datatype: 'text',
-                    title: 'Top 10 Brand by Total Revenue',
-                    dim: '[Brand.Brand]',
-                    filter: {
-                        top: 10,
-                        by: {
-                            table: 'Commerce',
-                            column: 'Revenue',
-                            datatype: 'numeric',
-                            title: 'sum Revenue',
-                            dim: '[Commerce.Revenue]',
-                            agg: 'sum',
-                        },
-                    },
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const measure = (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(jaql.filter.by);
-                const expectedFilter = filterFactory.topRanking(attribute, measure, jaql.filter.top, guid);
-                expectEqualFilters(filter, expectedFilter);
-            });
-            it('should handle bottom', () => {
-                const jaql = {
-                    table: 'Brand',
-                    column: 'Brand',
-                    datatype: 'text',
-                    title: 'Bottom 10 Brand by Total Revenue',
-                    dim: '[Brand.Brand]',
-                    filter: {
-                        bottom: 10,
-                        by: {
-                            table: 'Commerce',
-                            column: 'Revenue',
-                            datatype: 'numeric',
-                            title: 'sum Revenue',
-                            dim: '[Commerce.Revenue]',
-                            agg: 'sum',
-                        },
-                    },
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const measure = (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(jaql.filter.by);
-                const expectedFilter = filterFactory.bottomRanking(attribute, measure, jaql.filter.bottom, guid);
-                expectEqualFilters(filter, expectedFilter);
-            });
-        });
-        (0, vitest_1.describe)('LogicalAttributeFilter', () => {
-            it('should handle or', () => {
-                const jaql = {
-                    table: 'Brand',
-                    column: 'Brand',
-                    datatype: 'text',
-                    title: 'Brand',
-                    dim: '[Brand.Brand]',
-                    filter: {
-                        or: [
-                            {
-                                startsWith: 'A',
-                            },
-                            {
-                                endsWith: 's',
-                            },
-                        ],
-                    },
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.union(jaql.filter.or.map((c) => (0, condition_filter_util_js_1.createAttributeFilterFromConditionFilterJaql)(attribute, c, guid)), guid);
-                expect(filter.type).toEqual(expectedFilter.type);
-                expect(filter.id).toEqual(expectedFilter.id);
-                expect(filter.serializable()).toBeDefined();
-            });
-            it('should handle and', () => {
-                const jaql = {
-                    table: 'Brand',
-                    column: 'Brand',
-                    datatype: 'text',
-                    title: 'Brand',
-                    dim: '[Brand.Brand]',
-                    filter: {
-                        and: [
-                            {
-                                startsWith: 'A',
-                            },
-                            {
-                                endsWith: 's',
-                            },
-                        ],
-                    },
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.intersection(jaql.filter.and.map((c) => (0, condition_filter_util_js_1.createAttributeFilterFromConditionFilterJaql)(attribute, c, guid)), guid);
-                expect(filter.type).toEqual(expectedFilter.type);
-                expect(filter.id).toEqual(expectedFilter.id);
-                expect(filter.serializable()).toBeDefined();
-            });
-        });
-        (0, vitest_1.describe)('MeasureFilter', () => {
-            it('should handle unary operation', () => {
-                [
-                    {
-                        operator: types_js_1.ConditionFilterType.GREATER_THAN,
-                        factoryFunc: filterFactory.measureGreaterThan,
-                    },
-                    {
-                        operator: types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL,
-                        factoryFunc: filterFactory.measureGreaterThanOrEqual,
-                    },
-                    { operator: types_js_1.ConditionFilterType.EQUALS, factoryFunc: filterFactory.measureEquals },
-                    { operator: types_js_1.ConditionFilterType.LESS_THAN, factoryFunc: filterFactory.measureLessThan },
-                    {
-                        operator: types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL,
-                        factoryFunc: filterFactory.measureLessThanOrEqual,
-                    },
-                ].forEach((test) => {
-                    const jaql = {
-                        table: 'Commerce',
-                        column: 'Revenue',
-                        datatype: 'numeric',
-                        title: 'sum Revenue',
-                        dim: '[Commerce.Revenue]',
-                        agg: 'sum',
-                        filter: {
-                            [test.operator]: 2000,
-                        },
-                    };
-                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                    const measure = (0, attribute_measure_util_js_1.createMeasureFromFilterJaql)(jaql);
-                    expect(measure).toBeDefined();
-                    if (!measure)
-                        return;
-                    const expectedFilter = test.factoryFunc(measure, jaql.filter[test.operator], guid);
-                    expectEqualFilters(filter, expectedFilter);
-                });
-            });
-        });
-        (0, vitest_1.describe)('ExcludeFilter', () => {
-            it('should handle exclude members', () => {
-                const jaql = {
-                    table: 'Country',
-                    column: 'Country',
-                    datatype: 'text',
-                    title: 'exclude Turkey from Country',
-                    dim: '[Country.Country]',
-                    filter: {
-                        exclude: {
-                            members: ['Turkey'],
-                        },
-                    },
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.exclude((0, filter_code_util_js_1.withComposeCode)(filterFactory.members)(attribute, jaql.filter.exclude.members, undefined, guid), undefined, guid);
-                expectEqualFilters(filter, expectedFilter);
-            });
-        });
-        (0, vitest_1.describe)('Advanced filter (pass-through JAQL)', () => {
-            test('should handle', () => {
-                const jaql = {
-                    table: 'Commerce',
-                    column: 'Revenue',
-                    datatype: 'numeric',
-                    title: 'sum Revenue',
-                    filter: {
-                        custom: true,
-                        isAdvanced: true,
-                    },
-                };
-                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.customFilter(attribute, jaql.filter, guid);
-                expect(filter.jaql()).toEqual(expectedFilter.jaql());
-                expect(filter.jaql(true)).toEqual(expectedFilter.jaql(true));
-                expect(filter.serializable()).toBeDefined();
-                expect(filter.toJSON()).toBeDefined();
-            });
-        });
-        (0, vitest_1.describe)('Generic filter (pass-through JAQL)', () => {
-            test('should fall back to generic filter (pass-through JAQL)', () => {
-                [
-                    // SIMULATE INVALID FILTER TYPE
-                    {
-                        table: 'Commerce',
-                        column: 'Revenue',
-                        datatype: 'numeric',
-                        title: 'sum Revenue',
-                        filter: {
-                            filterType: 'INVALID',
-                        },
-                    },
-                    {
-                        type: 'measure',
-                        formula: 'QUARTILE([042C4-365], 2)',
-                        context: {
-                            '[042C4-365]': {
-                                table: 'Commerce',
-                                column: 'Revenue',
-                                dim: '[Commerce.Revenue]',
-                                datatype: 'numeric',
-                                title: 'Revenue',
-                            },
-                        },
-                        title: 'QUARTILE([Revenue], 2)',
-                        datatype: 'numeric',
-                        filter: {
-                            fromNotEqual: '500',
-                        },
-                    },
-                    {
-                        table: 'Brand',
-                        column: 'Brand',
-                        dim: '[Brand.Brand]',
-                        datatype: 'text',
-                        merged: true,
-                        title: 'Brand',
-                        filter: {
-                            top: 10,
-                            by: {
-                                type: 'measure',
-                                formula: 'QUARTILE([042C4-365], 2)',
-                                context: {
-                                    '[042C4-365]': {
-                                        table: 'Commerce',
-                                        column: 'Revenue',
-                                        dim: '[Commerce.Revenue]',
-                                        datatype: 'numeric',
-                                        title: 'Revenue',
-                                    },
-                                },
-                                title: 'QUARTILE([Revenue], 2)',
-                                datatype: 'numeric',
-                            },
-                            rankingMessage: 'QUARTILE([Revenue], 2)',
-                        },
-                    },
-                ].forEach((item) => {
-                    const jaql = item;
-                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                    const expectedFilter = (0, filter_from_jaql_util_js_2.createGenericFilter)(jaql, guid);
-                    expect(filter.jaql()).toEqual(expectedFilter.jaql());
-                    expect(filter.jaql(true)).toEqual(expectedFilter.jaql(true));
-                    expect(filter.serializable()).toBeDefined();
-                    expect(filter.toJSON()).toBeDefined();
-                });
-            });
-        });
-    });
-});

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

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