@sisense/sdk-data 1.8.0 → 1.9.0

package/dist/dimensional-model/types.d.ts

@@ -162,7 +162,16 @@ export declare enum JaqlSortDirection {
     DESC = "desc"
 }
 /** @internal */
-export declare type Jaql = BaseJaql | FormulaJaql | FilterJaql;
+export declare type Jaql = BaseJaql | FormulaJaql | FilterJaql | PivotJaql;
+/** @internal */
+export declare type PivotJaql = (BaseJaql | FormulaJaql) & {
+    sortDetails?: {
+        dir: JaqlSortDirection;
+        field: number;
+        measurePath?: Record<string, string> | null;
+    };
+    subtotalAgg?: 'sum' | 'min' | 'max' | 'avg' | 'median';
+};
 /** @internal */
 export declare type BaseJaql = {
     agg?: string;

package/dist/dimensional-model/types.js

@@ -1,8 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable max-lines */
 /*
  * Types
  */
@@ -21,7 +19,7 @@ export const AggregationTypes = {
     /** Count aggregation type */
     Count: 'count',
     /** Count distinct aggregation type */
-    CountDistinct: 'countdistinct',
+    CountDistinct: 'countDistinct',
     /** Median aggregation type */
     Median: 'median',
     /** Variance aggregation type */

package/dist/utils.js

@@ -1,5 +1,5 @@
 import cloneDeep from 'lodash/cloneDeep.js';
-import { createFilterFromJaqlInternal } from './dimensional-model/filters/utils/filter-jaql-util.js';
+import { createFilterFromJaqlInternal } from './dimensional-model/filters/utils/filter-from-jaql-util.js';
 /**
  * A more performant, but slightly bulkier, RFC4122v4 implementation. Performance is improved by minimizing calls to random()
  *

package/package.json

@@ -11,7 +11,7 @@
     "Sisense",
     "Compose SDK"
   ],
-  "version": "1.8.0",
+  "version": "1.9.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -23,8 +23,8 @@
   "author": "Sisense ",
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@sisense/sdk-common": "^1.8.0",
-    "@sisense/sdk-rest-client": "^1.8.0",
+    "@sisense/sdk-common": "^1.9.0",
+    "@sisense/sdk-rest-client": "^1.9.0",
     "guid-typescript": "^1.0.9",
     "lodash": "^4.17.21",
     "numeral": "^2.0.6",

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

@@ -1,25 +0,0 @@
-import { ConditionJaql, FilterJaqlInternal, RangeJaql, SpecificItemsJaql } from './modern-analytics-filters/types.js';
-import { Attribute, Filter, LevelAttribute } from '../../interfaces.js';
-import { FilterJaql } from '../../types.js';
-/**
- * Creates a generic filter if the JAQL cannot be translated to a specific filter type.
- *
- * @param jaql - The JAQL object.
- * @param instanceid - The instance ID.
- * @returns - The created Filter object.
- */
-export declare const createGenericFilter: (jaql: FilterJaql | FilterJaqlInternal, instanceid?: string) => Filter;
-export declare const createFilterIncludeAll: (attribute: Attribute) => Filter;
-export declare const createFilterFromConditionJaql: (attribute: Attribute, conditionJaql: ConditionJaql) => Filter;
-export declare const createFilterFromSpecificItemsJaql: (attribute: Attribute, specificItemsJaql: SpecificItemsJaql) => Filter;
-export declare const createFilterFromRangeJaql: (attribute: LevelAttribute, rangeJaql: RangeJaql) => Filter;
-export declare function capitalizeFirstLetter(str: string): string;
-export declare const createAttributeFromFilterJaql: (jaql: FilterJaql | FilterJaqlInternal) => Attribute | LevelAttribute;
-/**
- * Creates a filter from a JAQL object.
- *
- * @param jaql - The filter JAQL object.
- * @param instanceid - The instance ID.
- * @returns - The created Filter object.
- */
-export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, instanceid?: string) => Filter;

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

@@ -1,167 +0,0 @@
-/* eslint-disable max-lines */
-import { ConditionTypes, FILTER_TYPES, } from './modern-analytics-filters/types.js';
-import { isNumber } from '../../simple-column-types.js';
-import { MetadataTypes } from '../../types.js';
-import { DimensionalAttribute, DimensionalLevelAttribute } from '../../attributes.js';
-import * as filterFactory from '../factory.js';
-import { getSelectedConditionOption } from './modern-analytics-filters/condition-filter-util.js';
-import { extractTypeFromFilterJaql } from './modern-analytics-filters/filter-types-util.js';
-import { normalizeAttributeName } from '../../base.js';
-const DATA_MODEL_MODULE_NAME = 'DM';
-/**
- * High order function to construct compose code for filter factory functions
- *
- * @param func - filter factory function
- */
-function withComposeCode(func) {
-    return function (...args) {
-        const argValues = args
-            .map((arg) => {
-            if (MetadataTypes.isAttribute(arg)) {
-                return arg.composeCode;
-            }
-            if (Array.isArray(arg)) {
-                return ('[' +
-                    arg
-                        .map((item) => {
-                        if (typeof item === 'string') {
-                            return `'${item}'`;
-                        }
-                        if (typeof item === 'number') {
-                            return item;
-                        }
-                        return JSON.stringify(item);
-                    })
-                        .join(', ') +
-                    ']');
-            }
-            return JSON.stringify(arg);
-        })
-            .join(', ');
-        const signature = `filterFactory.${func.name}(${argValues})`;
-        const filter = func(...args);
-        filter.composeCode = signature;
-        return filter;
-    };
-}
-/**
- * Creates a generic filter if the JAQL cannot be translated to a specific filter type.
- *
- * @param jaql - The JAQL object.
- * @param instanceid - The instance ID.
- * @returns - The created Filter object.
- */
-export const createGenericFilter = (jaql, instanceid) => {
-    return {
-        guid: instanceid,
-        jaql: (nested) => {
-            if (nested) {
-                return jaql;
-            }
-            return {
-                jaql,
-                panel: 'scope',
-            };
-        },
-        attribute: {
-            id: jaql.dim,
-        },
-        type: 'filter',
-        serializable() {
-            return Object.assign(Object.assign({}, this), { jaql: this.jaql() });
-        },
-        toJSON() {
-            return this.serializable();
-        },
-    };
-};
-export const createFilterIncludeAll = (attribute) => {
-    return withComposeCode(filterFactory.members)(attribute, []);
-};
-export const createFilterFromConditionJaql = (attribute, conditionJaql) => {
-    switch (getSelectedConditionOption(conditionJaql)) {
-        case ConditionTypes.BOTTOM:
-            return withComposeCode(filterFactory.bottomRanking)(attribute, conditionJaql[ConditionTypes.BOTTOM]);
-        case ConditionTypes.GREATER_THAN:
-            return withComposeCode(filterFactory.greaterThan)(attribute, conditionJaql[ConditionTypes.GREATER_THAN]);
-        case ConditionTypes.GREATER_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.greaterThanOrEqual)(attribute, conditionJaql[ConditionTypes.GREATER_THAN_OR_EQUAL]);
-        case ConditionTypes.EQUALS:
-            return withComposeCode(filterFactory.equals)(attribute, conditionJaql[ConditionTypes.EQUALS]);
-    }
-    throw 'Jaql contains unsupported condition filter: ' + JSON.stringify(conditionJaql);
-};
-export const createFilterFromSpecificItemsJaql = (attribute, specificItemsJaql) => {
-    return withComposeCode(filterFactory.members)(attribute, specificItemsJaql.members);
-};
-export const createFilterFromRangeJaql = (attribute, rangeJaql) => {
-    return withComposeCode(filterFactory.dateRange)(attribute, rangeJaql.from, rangeJaql.to);
-};
-// TODO
-// export const createFilterFromPeriodJaql = (
-//   attribute: LevelAttribute,
-//   periodJaql: PeriodJaql,
-// ): Filter => {
-//   return filterFactory.dateRange(attribute, rangeJaql.from as string, rangeJaql.to as string);
-// };
-export function capitalizeFirstLetter(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}
-export const createAttributeFromFilterJaql = (jaql) => {
-    if (jaql.level) {
-        // while level in JAQL is in lowercase, LevelAttribute.granularity has the first char capitalized
-        const dateLevel = capitalizeFirstLetter(jaql.level);
-        const levelAttribute = new DimensionalLevelAttribute(jaql.column, jaql.dim, dateLevel);
-        levelAttribute.composeCode = normalizeAttributeName(jaql.table, jaql.column, dateLevel, DATA_MODEL_MODULE_NAME);
-        return levelAttribute;
-    }
-    const attributeType = isNumber(jaql.datatype)
-        ? MetadataTypes.NumericAttribute
-        : MetadataTypes.TextAttribute;
-    const attribute = new DimensionalAttribute(jaql.column, jaql.dim, attributeType);
-    attribute.composeCode = normalizeAttributeName(jaql.table, jaql.column, undefined, DATA_MODEL_MODULE_NAME);
-    return attribute;
-};
-/**
- * Creates a filter from a JAQL object.
- *
- * @param jaql - The filter JAQL object.
- * @param instanceid - The instance ID.
- * @returns - The created Filter object.
- */
-// eslint-disable-next-line complexity
-export const createFilterFromJaqlInternal = (jaql, instanceid) => {
-    try {
-        const jaqlWrapperType = extractTypeFromFilterJaql(jaql, jaql.datatype);
-        const { filter: filterJaqlWithType } = jaqlWrapperType;
-        const { jaqlType } = filterJaqlWithType;
-        const attribute = createAttributeFromFilterJaql(jaql);
-        switch (jaqlType) {
-            case FILTER_TYPES.INCLUDE_ALL:
-                return createFilterIncludeAll(attribute);
-            case FILTER_TYPES.SPECIFIC_ITEMS:
-                return createFilterFromSpecificItemsJaql(attribute, filterJaqlWithType);
-            case FILTER_TYPES.CONDITION:
-                return createFilterFromConditionJaql(attribute, filterJaqlWithType);
-            case FILTER_TYPES.DATE_RANGE:
-                return createFilterFromRangeJaql(attribute, filterJaqlWithType);
-            case FILTER_TYPES.PERIOD:
-                // TODO implement Filters of Period type
-                break;
-            case FILTER_TYPES.NUMERIC_RANGE:
-                // TODO implement Filters of Numeric Range type
-                break;
-            case FILTER_TYPES.ADVANCED:
-                // TODO implement Filters of Advanced type
-                break;
-            case FILTER_TYPES.INVALID:
-                return createGenericFilter(jaql, instanceid);
-        }
-    }
-    catch (e) {
-        // console.error(e);
-        return createGenericFilter(jaql, instanceid);
-    }
-    // if a filter type is untranslatable, fall back to the generic filter
-    return createGenericFilter(jaql, instanceid);
-};

package/dist/dimensional-model/filters/utils/modern-analytics-filters/condition-filter-util.d.ts

@@ -1,2 +0,0 @@
-import { ConditionJaql, ConditionTypes } from './types.js';
-export declare const getSelectedConditionOption: (filter: ConditionJaql) => ConditionTypes;

package/dist/dimensional-model/filters/utils/modern-analytics-filters/condition-filter-util.js

@@ -1,27 +0,0 @@
-import * as conditionTypesUtil from './condition-types-util.js';
-export const getSelectedConditionOption = (filter) => {
-    let selected;
-    selected = conditionTypesUtil.isBottomCondition(filter);
-    selected = conditionTypesUtil.isTopCondition(filter, selected);
-    selected = conditionTypesUtil.isExcludeCondition(filter, selected);
-    selected = conditionTypesUtil.isWithinCondition(filter, selected);
-    selected = conditionTypesUtil.isGreaterThanCondition(filter, selected);
-    selected = conditionTypesUtil.isGreaterThanOrEqualCondition(filter, selected);
-    selected = conditionTypesUtil.isLessThanCondition(filter, selected);
-    selected = conditionTypesUtil.isLessThanOrEqualCondition(filter, selected);
-    selected = conditionTypesUtil.isEqualsCondition(filter, selected);
-    selected = conditionTypesUtil.isNotEqualCondition(filter, selected);
-    selected = conditionTypesUtil.isEmptyCondition(filter, selected);
-    selected = conditionTypesUtil.isNotEmptyCondition(filter, selected);
-    selected = conditionTypesUtil.isContainsCondition(filter, selected);
-    selected = conditionTypesUtil.isDoesntContainCondition(filter, selected);
-    selected = conditionTypesUtil.isDoesntEndWithCondition(filter, selected);
-    selected = conditionTypesUtil.isDoesntStartsWithCondition(filter, selected);
-    selected = conditionTypesUtil.isEndsWithCondition(filter, selected);
-    selected = conditionTypesUtil.isStartsWithCondition(filter, selected);
-    selected = conditionTypesUtil.isBetweenCondition(filter, selected);
-    selected = conditionTypesUtil.isNotBetweenCondition(filter, selected);
-    selected = conditionTypesUtil.isMembersCondition(filter, selected);
-    selected = conditionTypesUtil.isMultipleCondition(filter, selected);
-    return selected;
-};

package/dist/dimensional-model/filters/utils/modern-analytics-filters/condition-types-util.d.ts

@@ -1,24 +0,0 @@
-import { ConditionTypes } from './types.js';
-import type { ConditionJaql } from './types.js';
-export declare const isTopCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isBottomCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isExcludeCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isMembersCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isWithinCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isGreaterThanCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isGreaterThanOrEqualCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isLessThanCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isLessThanOrEqualCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isEqualsCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isNotEqualCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isEmptyCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isNotEmptyCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isContainsCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isDoesntContainCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isStartsWithCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isDoesntStartsWithCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isEndsWithCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isDoesntEndWithCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isBetweenCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isNotBetweenCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;
-export declare const isMultipleCondition: (filter: ConditionJaql, selected?: ConditionTypes) => ConditionTypes;

package/dist/dimensional-model/filters/utils/modern-analytics-filters/condition-types-util.js

@@ -1,138 +0,0 @@
-/* eslint-disable max-lines */
-import { ConditionTypes } from './types.js';
-export const isTopCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.top !== undefined) {
-        return ConditionTypes.TOP;
-    }
-    return selected;
-};
-export const isBottomCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.bottom !== undefined) {
-        return ConditionTypes.BOTTOM;
-    }
-    return selected;
-};
-export const isExcludeCondition = (filter, selected = ConditionTypes.NONE) => {
-    var _a;
-    if ((_a = filter.exclude) === null || _a === void 0 ? void 0 : _a.members) {
-        return ConditionTypes.IS_NOT;
-    }
-    return selected;
-};
-export const isMembersCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.members && filter.isCondition) {
-        return ConditionTypes.IS;
-    }
-    return selected;
-};
-export const isWithinCondition = (filter, selected = ConditionTypes.NONE) => {
-    var _a, _b;
-    if (((_a = filter.last) === null || _a === void 0 ? void 0 : _a.anchor) !== undefined || ((_b = filter.next) === null || _b === void 0 ? void 0 : _b.anchor) !== undefined) {
-        return ConditionTypes.IS_WITHIN;
-    }
-    return selected;
-};
-export const isGreaterThanCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.fromNotEqual !== undefined) {
-        return ConditionTypes.GREATER_THAN;
-    }
-    return selected;
-};
-export const isGreaterThanOrEqualCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.from !== undefined && !filter.isBetween) {
-        return ConditionTypes.GREATER_THAN_OR_EQUAL;
-    }
-    return selected;
-};
-export const isLessThanCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.toNotEqual !== undefined) {
-        return ConditionTypes.LESS_THAN;
-    }
-    return selected;
-};
-export const isLessThanOrEqualCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.to !== undefined && !filter.isBetween) {
-        return ConditionTypes.LESS_THAN_OR_EQUAL;
-    }
-    return selected;
-};
-export const isEqualsCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.equals !== undefined) {
-        return ConditionTypes.EQUALS;
-    }
-    return selected;
-};
-export const isNotEqualCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.doesntEqual !== undefined) {
-        return ConditionTypes.DOESNT_EQUAL;
-    }
-    return selected;
-};
-export const isEmptyCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.equals === '' && filter.isEmpty) {
-        return ConditionTypes.IS_EMPTY;
-    }
-    return selected;
-};
-export const isNotEmptyCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.doesntEqual === '' && filter.isEmpty) {
-        return ConditionTypes.IS_NOT_EMPTY;
-    }
-    return selected;
-};
-export const isContainsCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.contains !== undefined) {
-        return ConditionTypes.CONTAINS;
-    }
-    return selected;
-};
-export const isDoesntContainCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.doesntContain !== undefined) {
-        return ConditionTypes.DOESNT_CONTAIN;
-    }
-    return selected;
-};
-export const isStartsWithCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.startsWith !== undefined) {
-        return ConditionTypes.STARTS_WITH;
-    }
-    return selected;
-};
-export const isDoesntStartsWithCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.doesntStartWith !== undefined) {
-        return ConditionTypes.DOESNT_START_WITH;
-    }
-    return selected;
-};
-export const isEndsWithCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.endsWith !== undefined) {
-        return ConditionTypes.ENDS_WITH;
-    }
-    return selected;
-};
-export const isDoesntEndWithCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.doesntEndWith !== undefined) {
-        return ConditionTypes.DOESNT_END_WITH;
-    }
-    return selected;
-};
-export const isBetweenCondition = (filter, selected = ConditionTypes.NONE) => {
-    if (filter.from !== undefined && filter.to !== undefined) {
-        return ConditionTypes.BETWEEN;
-    }
-    return selected;
-};
-export const isNotBetweenCondition = (filter, selected = ConditionTypes.NONE) => {
-    const { exclude } = filter;
-    if ((exclude === null || exclude === void 0 ? void 0 : exclude.from) !== undefined && (exclude === null || exclude === void 0 ? void 0 : exclude.to) !== undefined) {
-        return ConditionTypes.IS_NOT_BETWEEN;
-    }
-    return selected;
-};
-export const isMultipleCondition = (filter, selected = ConditionTypes.NONE) => {
-    const { or, and } = filter;
-    if (or || and) {
-        return ConditionTypes.MULTIPLE_CONDITION;
-    }
-    return selected;
-};

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

@@ -1,31 +0,0 @@
-import { FilterModalTypes, FilterJaqlTypes, DatetimeLevel, FilterTypes, PeriodJaql, FilterJaqlInternal, FilterJaqlWrapperType } from './types.js';
-export declare const isIncludeAllFilter: (filter: FilterJaqlTypes, currentDefaultFilter: FilterTypes) => FilterTypes;
-export declare const getInnerPeriodFilter: (filter: PeriodJaql) => {
-    count: number;
-    offset: number;
-    anchor?: string;
-};
-export declare const isPeriodFilter: (filter: FilterJaqlTypes, currentDefaultFilter: FilterTypes) => FilterTypes;
-export declare const isSpecificItemsFilter: (filter: FilterJaqlTypes, currentDefaultFilter: FilterTypes) => FilterTypes;
-export declare const isDateRangeFilter: (filter: FilterJaqlTypes, currentDefaultFilter: FilterTypes, dataType: FilterModalTypes) => FilterTypes;
-export declare const isNumericRangeFilter: (filter: FilterJaqlTypes, currentDefaultFilter: FilterTypes) => FilterTypes;
-export declare const isConditionFilter: (filter: FilterJaqlTypes, currentDefaultFilter: FilterTypes) => FilterTypes;
-export declare const isAdvancedFilter: (filter: FilterJaqlTypes, currentDefaultFilter: FilterTypes) => FilterTypes;
-export declare const isTimeLevelNotSupported: (timeData: {
-    level?: DatetimeLevel;
-    bucket?: string;
-}) => boolean;
-export declare const isInvalidFilter: (filter: FilterJaqlTypes, currentDefaultFilter: FilterTypes) => FilterTypes;
-export declare const getFilterType: (filter: FilterJaqlTypes, dataType?: FilterModalTypes, timeData?: {
-    level?: DatetimeLevel;
-    bucket?: string;
-}) => FilterTypes;
-/**
- * Extracts Type from Filter Jaql
- *
- * @param jaql - jaql
- * @param dataType - data type
- * @return FilterJaqlWrapperType
- * @internal
- */
-export declare const extractTypeFromFilterJaql: (jaql: FilterJaqlInternal, dataType: FilterModalTypes) => FilterJaqlWrapperType;

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

@@ -1,114 +0,0 @@
-/* eslint-disable max-lines */
-import { getSelectedConditionOption } from './condition-filter-util.js';
-import { FilterModalTypes, DatetimeLevel, FILTER_TYPES, nonSupportedMinutesBuckets, ConditionTypes, FILTER_JAQL_WRAPPER, } from './types.js';
-import { getCorrectTimeLevel } from './date-time-filter-util.js';
-export const isIncludeAllFilter = (filter, currentDefaultFilter) => {
-    if (filter === null || filter === void 0 ? void 0 : filter.all) {
-        return FILTER_TYPES.INCLUDE_ALL;
-    }
-    return currentDefaultFilter;
-};
-export const getInnerPeriodFilter = (filter) => {
-    return filter.last ? filter.last : filter.next;
-};
-export const isPeriodFilter = (filter, currentDefaultFilter) => {
-    const period = getInnerPeriodFilter(filter);
-    if ((period === null || period === void 0 ? void 0 : period.offset) < 2) {
-        return FILTER_TYPES.PERIOD;
-    }
-    return currentDefaultFilter;
-};
-export const isSpecificItemsFilter = (filter, currentDefaultFilter) => {
-    const specificItemsFilter = filter;
-    if (specificItemsFilter === null || specificItemsFilter === void 0 ? void 0 : specificItemsFilter.members) {
-        if (specificItemsFilter.members.length > 0) {
-            return FILTER_TYPES.SPECIFIC_ITEMS;
-        }
-        return FILTER_TYPES.INCLUDE_ALL;
-    }
-    return currentDefaultFilter;
-};
-const areFromOrToDefined = (fromRange, toRange) => (fromRange && typeof fromRange === 'string') || (toRange && typeof toRange === 'string');
-const areFromAndToEmpty = (from, to) => from === '' && to === '';
-export const isDateRangeFilter = (filter, currentDefaultFilter, dataType) => {
-    const { from, to } = filter;
-    if (dataType !== FilterModalTypes.DATE_TIME) {
-        return currentDefaultFilter;
-    }
-    if (areFromOrToDefined(from, to)) {
-        return FILTER_TYPES.DATE_RANGE;
-    }
-    if (areFromAndToEmpty(from, to)) {
-        return FILTER_TYPES.INCLUDE_ALL;
-    }
-    return currentDefaultFilter;
-};
-export const isNumericRangeFilter = (filter, currentDefaultFilter) => {
-    const { from, to } = filter;
-    if (from !== undefined && to !== undefined && !filter.isBetween) {
-        return FILTER_TYPES.NUMERIC_RANGE;
-    }
-    return currentDefaultFilter;
-};
-export const isConditionFilter = (filter, currentDefaultFilter) => {
-    if (getSelectedConditionOption(filter) !== ConditionTypes.NONE) {
-        return FILTER_TYPES.CONDITION;
-    }
-    return currentDefaultFilter;
-};
-export const isAdvancedFilter = (filter, currentDefaultFilter) => {
-    if (Object.keys(filter).includes('isAdvanced')) {
-        return FILTER_TYPES.ADVANCED;
-    }
-    return currentDefaultFilter;
-};
-export const isTimeLevelNotSupported = (timeData) => {
-    const { level, bucket } = timeData;
-    return !!(level &&
-        bucket &&
-        level === DatetimeLevel.MINUTES &&
-        nonSupportedMinutesBuckets.includes(bucket));
-};
-export const isInvalidFilter = (filter, currentDefaultFilter) => {
-    if (filter.jaqlType === FILTER_TYPES.INVALID) {
-        return FILTER_TYPES.INVALID;
-    }
-    return currentDefaultFilter;
-};
-export const getFilterType = (filter, dataType = FilterModalTypes.DATE_TIME, timeData) => {
-    let filterType = FILTER_TYPES.ADVANCED;
-    if (timeData && isTimeLevelNotSupported(timeData)) {
-        return filterType;
-    }
-    filterType = isIncludeAllFilter(filter, filterType);
-    filterType = isPeriodFilter(filter, filterType);
-    filterType = isSpecificItemsFilter(filter, filterType);
-    filterType = isConditionFilter(filter, filterType);
-    filterType = isNumericRangeFilter(filter, filterType);
-    filterType = isDateRangeFilter(filter, filterType, dataType);
-    filterType = isAdvancedFilter(filter, filterType);
-    filterType = isInvalidFilter(filter, filterType);
-    return filterType;
-};
-/**
- * Extracts Type from Filter Jaql
- *
- * @param jaql - jaql
- * @param dataType - data type
- * @return FilterJaqlWrapperType
- * @internal
- */
-export const extractTypeFromFilterJaql = (jaql, dataType) => {
-    const { level: filterLevel, filter, bucket } = jaql;
-    const filterFromJaql = filter || FILTER_JAQL_WRAPPER.filter;
-    const filterToReturn = {
-        filter: Object.assign(Object.assign({}, filterFromJaql), { jaqlType: getFilterType(filterFromJaql, dataType) }),
-    };
-    if (dataType === FilterModalTypes.DATE_TIME) {
-        const backgroundFilter = filterFromJaql;
-        const level = (backgroundFilter === null || backgroundFilter === void 0 ? void 0 : backgroundFilter.level) || filterLevel;
-        filterToReturn.level = getCorrectTimeLevel(level, bucket);
-        filterToReturn.filter.jaqlType = getFilterType(filterFromJaql, dataType, { level, bucket });
-    }
-    return filterToReturn;
-};