@sisense/sdk-data 1.8.0 → 1.9.0

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

@@ -0,0 +1,67 @@
+import { ConditionFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
+import { Attribute, BaseMeasure, Filter, LevelAttribute } from '../../interfaces.js';
+import { FilterJaql } from '../../types.js';
+/**
+ * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
+ *
+ * @param jaql - The JAQL object.
+ * @param instanceid - The instance ID.
+ * @returns A generic Filter object.
+ */
+export declare const createGenericFilter: (jaql: FilterJaql | FilterJaqlInternal, instanceid?: string) => Filter;
+/**
+ * Creates a filter that includes all members of the attribute.
+ *
+ * @param attribute - The attribute.
+ * @returns The created Filter object.
+ */
+export declare const createFilterIncludeAll: (attribute: Attribute) => Filter;
+/**
+ * Creates a filter from a specific items filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param specificItemsFilterJaql - Specific Items Filter Jaql
+ * @returns Filter object
+ */
+export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql) => Filter;
+/**
+ * Creates a filter from a date range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @returns Filter object
+ */
+export declare const createFilterFromDateRangeFilterJaql: (attribute: LevelAttribute, rangeFilterJaql: RangeFilterJaql) => Filter;
+/**
+ * Creates a filter from a numeric range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @returns Filter object
+ */
+export declare const createFilterFromNumericRangeJaql: (attribute: Attribute, rangeFilterJaql: RangeFilterJaql) => Filter;
+/**
+ * Creates a filter from a period filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param periodFilterJaql - Period Filter Jaql
+ * @returns Filter object
+ */
+export declare const createFilterFromPeriodFilterJaql: (attribute: LevelAttribute, periodFilterJaql: PeriodFilterJaql) => Filter;
+/**
+ * Creates a filter from a condition filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param conditionFilterJaql - Condition Filter Jaql
+ * @param measure - measure
+ * @returns Filter object
+ */
+export declare const createFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql, measure?: BaseMeasure) => Filter;
+/**
+ * Creates a filter from a filter JAQL object.
+ *
+ * @param jaql - The filter JAQL object.
+ * @param instanceid - The instance ID.
+ * @returns Filter object.
+ */
+export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, instanceid?: string) => Filter;

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

@@ -0,0 +1,149 @@
+import { FILTER_TYPES, } from './types.js';
+import * as filterFactory from '../factory.js';
+import { createAttributeFilterFromConditionFilterJaql, createMeasureFilterFromConditionFilterJaql, } from './condition-filter-util.js';
+import { extractFilterTypeFromFilterJaql } from './filter-types-util.js';
+import { withComposeCode } from './filter-code-util.js';
+import { createAttributeFromFilterJaql, createMeasureFromFilterJaql, } from './attribute-measure-util.js';
+/**
+ * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
+ *
+ * @param jaql - The JAQL object.
+ * @param instanceid - The instance ID.
+ * @returns A generic 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();
+        },
+    };
+};
+/**
+ * Creates a filter that includes all members of the attribute.
+ *
+ * @param attribute - The attribute.
+ * @returns The created Filter object.
+ */
+export const createFilterIncludeAll = (attribute) => {
+    return withComposeCode(filterFactory.members)(attribute, []);
+};
+/**
+ * Creates a filter from a specific items filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param specificItemsFilterJaql - Specific Items Filter Jaql
+ * @returns Filter object
+ */
+export const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJaql) => {
+    return withComposeCode(filterFactory.members)(attribute, specificItemsFilterJaql.members);
+};
+/**
+ * Creates a filter from a date range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @returns Filter object
+ */
+export const createFilterFromDateRangeFilterJaql = (attribute, rangeFilterJaql) => {
+    return withComposeCode(filterFactory.dateRange)(attribute, rangeFilterJaql.from, rangeFilterJaql.to);
+};
+/**
+ * Creates a filter from a numeric range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @returns Filter object
+ */
+export const createFilterFromNumericRangeJaql = (attribute, rangeFilterJaql) => {
+    return withComposeCode(filterFactory.between)(attribute, rangeFilterJaql.from, rangeFilterJaql.to);
+};
+/**
+ * Creates a filter from a period filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param periodFilterJaql - Period Filter Jaql
+ * @returns Filter object
+ */
+export const createFilterFromPeriodFilterJaql = (attribute, periodFilterJaql) => {
+    if (periodFilterJaql.last) {
+        return withComposeCode(filterFactory.dateRelativeTo)(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor);
+    }
+    else {
+        return withComposeCode(filterFactory.dateRelativeFrom)(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor);
+    }
+};
+/**
+ * Creates a filter from a condition filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param conditionFilterJaql - Condition Filter Jaql
+ * @param measure - measure
+ * @returns Filter object
+ */
+export const createFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, measure) => {
+    if (measure) {
+        return createMeasureFilterFromConditionFilterJaql(measure, conditionFilterJaql);
+    }
+    else {
+        return createAttributeFilterFromConditionFilterJaql(attribute, conditionFilterJaql);
+    }
+};
+/**
+ * Creates a filter from a filter JAQL object.
+ *
+ * @param jaql - The filter JAQL object.
+ * @param instanceid - The instance ID.
+ * @returns Filter object.
+ */
+export const createFilterFromJaqlInternal = (jaql, instanceid) => {
+    try {
+        if ('formula' in jaql) {
+            // generic pass-through JAQL filter will be used instead
+            throw 'Formula-based filter not supported yet: ' + JSON.stringify(jaql);
+        }
+        const filterJaqlWrapperWithType = extractFilterTypeFromFilterJaql(jaql, jaql.datatype);
+        const { filter: filterJaqlWithType } = filterJaqlWrapperWithType;
+        const { filterType } = filterJaqlWithType;
+        const attribute = createAttributeFromFilterJaql(jaql);
+        const measure = createMeasureFromFilterJaql(jaql);
+        switch (filterType) {
+            case FILTER_TYPES.INCLUDE_ALL:
+                return createFilterIncludeAll(attribute);
+            case FILTER_TYPES.SPECIFIC_ITEMS:
+                return createFilterFromSpecificItemsFilterJaql(attribute, filterJaqlWithType);
+            case FILTER_TYPES.CONDITION:
+                return createFilterFromConditionFilterJaql(attribute, filterJaqlWithType, measure);
+            case FILTER_TYPES.DATE_RANGE:
+                return createFilterFromDateRangeFilterJaql(attribute, filterJaqlWithType);
+            case FILTER_TYPES.PERIOD:
+                return createFilterFromPeriodFilterJaql(attribute, filterJaqlWithType);
+            case FILTER_TYPES.NUMERIC_RANGE:
+                return createFilterFromNumericRangeJaql(attribute, filterJaqlWithType);
+            case FILTER_TYPES.ADVANCED:
+            case FILTER_TYPES.INVALID:
+                return createGenericFilter(jaql, instanceid);
+        }
+    }
+    catch (e) {
+        // if a filter type is untranslatable, fall back to the generic pass-through JAQL filter
+        // console.error(e);
+    }
+    return createGenericFilter(jaql, instanceid);
+};

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

@@ -0,0 +1,15 @@
+import { FilterModalType, AnyTypeFilterJaql, DatetimeLevel, FilterType, FilterJaqlInternal, FilterJaqlWrapperWithType } from './types.js';
+export declare const isNumericRangeFilter: (filter: AnyTypeFilterJaql) => boolean;
+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/dimensional-model/filters/utils/filter-types-util.js

@@ -0,0 +1,71 @@
+import { getSelectedConditionOption } from './condition-filter-util.js';
+import { FilterModalType, DatetimeLevel, FILTER_TYPES, nonSupportedMinutesBuckets, ConditionFilterType, DEFAULT_FILTER_JAQL_WRAPPER, } from './types.js';
+import { getCorrectTimeLevel } from './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; };
+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 !== FilterModalType.DATE_TIME)
+        return false;
+    if (isFromOrToDefined(from, to))
+        return true;
+    return isFromAndToEmpty(from, to);
+};
+export const isNumericRangeFilter = (filter) => {
+    const { from, to } = filter;
+    return !!(from !== undefined && to !== undefined && !filter.isBetween);
+};
+const isConditionFilter = (filter) => getSelectedConditionOption(filter) !== ConditionFilterType.NONE;
+const isAdvancedFilter = (filter) => Object.keys(filter).includes('isAdvanced');
+const isTimeLevelNotSupported = (timeData) => !!(timeData.level &&
+    timeData.bucket &&
+    timeData.level === DatetimeLevel.MINUTES &&
+    nonSupportedMinutesBuckets.includes(timeData.bucket));
+const isInvalidFilter = (filter) => filter.filterType === FILTER_TYPES.INVALID;
+export const getFilterType = (filter, dataType = FilterModalType.DATE_TIME, timeData) => {
+    if (timeData && isTimeLevelNotSupported(timeData))
+        return FILTER_TYPES.ADVANCED;
+    if (isIncludeAllFilter(filter))
+        return FILTER_TYPES.INCLUDE_ALL;
+    if (isPeriodFilter(filter))
+        return FILTER_TYPES.PERIOD;
+    if (isSpecificItemsFilter(filter))
+        return FILTER_TYPES.SPECIFIC_ITEMS;
+    if (isDateRangeFilter(filter, dataType))
+        return FILTER_TYPES.DATE_RANGE;
+    if (isNumericRangeFilter(filter))
+        return FILTER_TYPES.NUMERIC_RANGE;
+    if (isConditionFilter(filter))
+        return FILTER_TYPES.CONDITION;
+    if (isAdvancedFilter(filter))
+        return FILTER_TYPES.ADVANCED;
+    if (isInvalidFilter(filter))
+        return FILTER_TYPES.INVALID;
+    return FILTER_TYPES.ADVANCED;
+};
+/**
+ * Extracts Filter Type from Filter Jaql
+ *
+ * @param jaql - jaql
+ * @param dataType - data type
+ * @return FilterJaqlWrapperType
+ * @internal
+ */
+export const extractFilterTypeFromFilterJaql = (jaql, dataType) => {
+    const { level: filterLevel, filter, bucket } = jaql;
+    const filterFromJaql = filter || DEFAULT_FILTER_JAQL_WRAPPER.filter;
+    const filterToReturn = {
+        filter: Object.assign(Object.assign({}, filterFromJaql), { filterType: getFilterType(filterFromJaql, dataType) }),
+    };
+    if (dataType === FilterModalType.DATE_TIME) {
+        const backgroundFilter = filterFromJaql;
+        const level = (backgroundFilter === null || backgroundFilter === void 0 ? void 0 : backgroundFilter.level) || filterLevel;
+        filterToReturn.level = getCorrectTimeLevel(level, bucket);
+        filterToReturn.filter.filterType = getFilterType(filterFromJaql, dataType, { level, bucket });
+    }
+    return filterToReturn;
+};

package/dist/dimensional-model/filters/utils/{modern-analytics-filters/types.d.ts → types.d.ts}

@@ -13,50 +13,50 @@ export declare type Datasource = {
     lastBuildTime?: string;
     revisionId?: string;
 };
-export declare enum GeneralFilterTypes {
+export declare enum GeneralFilterType {
     INCLUDE_ALL = "INCLUDE_ALL",
     ADVANCED = "ADVANCED",
     INVALID = "INVALID",
     CONDITION = "CONDITION",
     SPECIFIC_ITEMS = "SPECIFIC_ITEMS"
 }
-export declare enum DateTimeFilterTypes {
+export declare enum DateTimeFilterType {
     PERIOD = "PERIOD",
     DATE_RANGE = "DATE_RANGE"
 }
-export declare enum NumericFilterTypes {
+export declare enum NumericFilterType {
     NUMERIC_RANGE = "NUMERIC_RANGE"
 }
-export declare type FilterTypes = GeneralFilterTypes | DateTimeFilterTypes | NumericFilterTypes;
-export interface FilterType {
-    jaqlType?: FilterTypes;
+export declare type FilterType = GeneralFilterType | DateTimeFilterType | NumericFilterType;
+export interface BaseFilterJaql {
+    filterType?: FilterType;
     custom?: boolean;
     isAdvanced?: boolean;
     rankingMessage?: string;
     isBetween?: boolean;
     isEmpty?: boolean;
 }
-export interface IncludeAllJaql extends FilterType {
+export interface IncludeAllFilterJaql extends BaseFilterJaql {
     all: boolean;
 }
-export declare type PeriodDetails = {
+export declare type PeriodFilterDetails = {
     count: number;
     offset: number;
     anchor?: string;
 };
-export interface PeriodJaqlOptions extends FilterType {
-    last: PeriodDetails;
-    next: PeriodDetails;
+export interface PeriodFilterJaqlOptions extends BaseFilterJaql {
+    last: PeriodFilterDetails;
+    next: PeriodFilterDetails;
     multiSelection?: boolean;
     isNotCurrentPeriod?: boolean;
 }
-export declare type PeriodJaql = RequireOnlyOne<PeriodJaqlOptions, 'last' | 'next'>;
-export interface RangeJaql extends FilterType {
+export declare type PeriodFilterJaql = RequireOnlyOne<PeriodFilterJaqlOptions, 'last' | 'next'>;
+export interface RangeFilterJaql extends BaseFilterJaql {
     from?: string | number;
     to?: string | number;
     multiSelection?: boolean;
 }
-export declare type RankingJaql = {
+export declare type RankingFilterJaql = {
     agg: string;
     column: string;
     datatype: string;
@@ -65,17 +65,17 @@ export declare type RankingJaql = {
     merged?: boolean;
     table: string;
 };
-export declare type FilterMultiSelect = {
+export declare type FilterMultiSelectJaql = {
     explicit?: boolean;
     multiSelection: boolean;
     members: string[];
     isCondition?: boolean;
 };
-export declare type MultipleCondition = {
-    or: ConditionJaql[];
-    and: ConditionJaql[];
+export declare type FilterMultipleConditionJaql = {
+    or: ConditionFilterJaql[];
+    and: ConditionFilterJaql[];
 };
-export declare type ConditionJaqlOptions = FilterType & {
+export declare type ConditionFilterJaqlOptions = BaseFilterJaql & {
     top: number;
     bottom: number;
     exclude: {
@@ -95,13 +95,13 @@ export declare type ConditionJaqlOptions = FilterType & {
     from: number;
     fromNotEqual: number;
     contains: string;
-    by?: RankingJaql;
+    by?: RankingFilterJaql;
     rankingMessage?: string;
-} & Partial<FilterMultiSelect> & Partial<PeriodJaql> & Partial<RangeJaql> & Partial<MultipleCondition>;
-export declare type ConditionJaql = RequireOnlyOne<ConditionJaqlOptions, 'top' | 'bottom' | 'exclude' | 'last' | 'next' | 'contains' | 'equals' | 'doesntEqual' | 'to' | 'toNotEqual' | 'from' | 'fromNotEqual' | 'startsWith' | 'doesntStartWith' | 'endsWith' | 'doesntEndWith' | 'doesntContain' | 'or' | 'and'>;
-export declare type InvalidType = FilterType;
-export declare type SpecificItemsJaql = FilterType & FilterMultiSelect;
-export declare type FilterJaqlTypes = IncludeAllJaql | PeriodJaql | RangeJaql | ConditionJaql | InvalidType | SpecificItemsJaql;
+} & Partial<FilterMultiSelectJaql> & Partial<PeriodFilterJaql> & Partial<RangeFilterJaql> & Partial<FilterMultipleConditionJaql>;
+export declare type ConditionFilterJaql = RequireOnlyOne<ConditionFilterJaqlOptions, 'top' | 'bottom' | 'exclude' | 'last' | 'next' | 'contains' | 'equals' | 'doesntEqual' | 'to' | 'toNotEqual' | 'from' | 'fromNotEqual' | 'startsWith' | 'doesntStartWith' | 'endsWith' | 'doesntEndWith' | 'doesntContain' | 'or' | 'and'>;
+export declare type InvalidTypeFilterJaql = BaseFilterJaql;
+export declare type SpecificItemsFilterJaql = BaseFilterJaql & FilterMultiSelectJaql;
+export declare type AnyTypeFilterJaql = IncludeAllFilterJaql | PeriodFilterJaql | RangeFilterJaql | ConditionFilterJaql | InvalidTypeFilterJaql | SpecificItemsFilterJaql;
 export declare enum DatetimeLevel {
     YEARS = "years",
     QUARTERS = "quarters",
@@ -122,7 +122,7 @@ export declare type FilterJaqlInternal = {
     firstday?: string;
     merged?: boolean;
     table: string;
-    filter?: FilterJaqlTypes;
+    filter?: AnyTypeFilterJaql;
     level?: DatetimeLevel;
     locale?: string;
     bucket?: string;
@@ -132,7 +132,7 @@ export declare type FilterJaqlInternal = {
     context?: JaqlContext;
     agg?: string;
 };
-export declare enum FilterModalTypes {
+export declare enum FilterModalType {
     DATE_TIME = "datetime",
     NUMERIC = "numeric",
     TEXT = "text"
@@ -142,35 +142,35 @@ export declare type BackgroundFilterExtraProps = {
     turnedOff?: boolean;
 };
 export declare type BackgroundFilter = {
-    filter?: FilterJaqlTypes & BackgroundFilterExtraProps;
+    filter?: AnyTypeFilterJaql & BackgroundFilterExtraProps;
 };
-export declare type FilterJaqlWrapperType = {
-    filter: FilterJaqlTypes & BackgroundFilter;
+export declare type FilterJaqlWrapperWithType = {
+    filter: AnyTypeFilterJaql & BackgroundFilter;
     level?: DatetimeLevel;
     agg?: string;
 };
 export declare const nonSupportedMinutesBuckets: string[];
 export declare const FILTER_TYPES: {
-    NUMERIC_RANGE: NumericFilterTypes.NUMERIC_RANGE;
-    PERIOD: DateTimeFilterTypes.PERIOD;
-    DATE_RANGE: DateTimeFilterTypes.DATE_RANGE;
-    INCLUDE_ALL: GeneralFilterTypes.INCLUDE_ALL;
-    ADVANCED: GeneralFilterTypes.ADVANCED;
-    INVALID: GeneralFilterTypes.INVALID;
-    CONDITION: GeneralFilterTypes.CONDITION;
-    SPECIFIC_ITEMS: GeneralFilterTypes.SPECIFIC_ITEMS;
+    NUMERIC_RANGE: NumericFilterType.NUMERIC_RANGE;
+    PERIOD: DateTimeFilterType.PERIOD;
+    DATE_RANGE: DateTimeFilterType.DATE_RANGE;
+    INCLUDE_ALL: GeneralFilterType.INCLUDE_ALL;
+    ADVANCED: GeneralFilterType.ADVANCED;
+    INVALID: GeneralFilterType.INVALID;
+    CONDITION: GeneralFilterType.CONDITION;
+    SPECIFIC_ITEMS: GeneralFilterType.SPECIFIC_ITEMS;
 };
-export declare type FilterJaqlDefaultType = {
-    [FILTER_TYPES.INCLUDE_ALL]: IncludeAllJaql;
-    [FILTER_TYPES.PERIOD]: PeriodJaql;
-    [FILTER_TYPES.DATE_RANGE]: RangeJaql;
-    [FILTER_TYPES.NUMERIC_RANGE]: RangeJaql;
-    [FILTER_TYPES.CONDITION]: ConditionJaql;
-    [FILTER_TYPES.SPECIFIC_ITEMS]: SpecificItemsJaql;
+export declare type FilterJaqlByTypeMap = {
+    [FILTER_TYPES.INCLUDE_ALL]: IncludeAllFilterJaql;
+    [FILTER_TYPES.PERIOD]: PeriodFilterJaql;
+    [FILTER_TYPES.DATE_RANGE]: RangeFilterJaql;
+    [FILTER_TYPES.NUMERIC_RANGE]: RangeFilterJaql;
+    [FILTER_TYPES.CONDITION]: ConditionFilterJaql;
+    [FILTER_TYPES.SPECIFIC_ITEMS]: SpecificItemsFilterJaql;
 };
-export declare const FILTER_JAQL_DEFAULT: FilterJaqlDefaultType;
-export declare const FILTER_JAQL_WRAPPER: FilterJaqlWrapperType;
-export declare enum ConditionTypes {
+export declare const DEFAULT_FILTER_JAQL_BY_TYPE_MAP: FilterJaqlByTypeMap;
+export declare const DEFAULT_FILTER_JAQL_WRAPPER: FilterJaqlWrapperWithType;
+export declare enum ConditionFilterType {
     IS = "members",
     IS_NOT = "exclude",
     IS_WITHIN = "isWithin",

package/dist/dimensional-model/filters/utils/types.js

@@ -0,0 +1,96 @@
+export var GeneralFilterType;
+(function (GeneralFilterType) {
+    GeneralFilterType["INCLUDE_ALL"] = "INCLUDE_ALL";
+    GeneralFilterType["ADVANCED"] = "ADVANCED";
+    GeneralFilterType["INVALID"] = "INVALID";
+    GeneralFilterType["CONDITION"] = "CONDITION";
+    GeneralFilterType["SPECIFIC_ITEMS"] = "SPECIFIC_ITEMS";
+})(GeneralFilterType = GeneralFilterType || (GeneralFilterType = {}));
+export var DateTimeFilterType;
+(function (DateTimeFilterType) {
+    DateTimeFilterType["PERIOD"] = "PERIOD";
+    DateTimeFilterType["DATE_RANGE"] = "DATE_RANGE";
+})(DateTimeFilterType = DateTimeFilterType || (DateTimeFilterType = {}));
+export var NumericFilterType;
+(function (NumericFilterType) {
+    NumericFilterType["NUMERIC_RANGE"] = "NUMERIC_RANGE";
+})(NumericFilterType = NumericFilterType || (NumericFilterType = {}));
+export var DatetimeLevel;
+(function (DatetimeLevel) {
+    DatetimeLevel["YEARS"] = "years";
+    DatetimeLevel["QUARTERS"] = "quarters";
+    DatetimeLevel["MONTHS"] = "months";
+    DatetimeLevel["WEEKS"] = "weeks";
+    DatetimeLevel["DAYS"] = "days";
+    DatetimeLevel["HOURS"] = "hours";
+    DatetimeLevel["MINUTES"] = "minutes";
+})(DatetimeLevel = DatetimeLevel || (DatetimeLevel = {}));
+export var FilterModalType;
+(function (FilterModalType) {
+    FilterModalType["DATE_TIME"] = "datetime";
+    FilterModalType["NUMERIC"] = "numeric";
+    FilterModalType["TEXT"] = "text";
+})(FilterModalType = FilterModalType || (FilterModalType = {}));
+export const nonSupportedMinutesBuckets = ['1', '30'];
+export const FILTER_TYPES = Object.assign(Object.assign(Object.assign({}, GeneralFilterType), DateTimeFilterType), NumericFilterType);
+export const DEFAULT_FILTER_JAQL_BY_TYPE_MAP = {
+    [FILTER_TYPES.INCLUDE_ALL]: {
+        all: true,
+        filterType: FILTER_TYPES.INCLUDE_ALL,
+    },
+    [FILTER_TYPES.PERIOD]: {
+        last: { count: 1, offset: 1 },
+        isNotCurrentPeriod: true,
+        filterType: FILTER_TYPES.PERIOD,
+    },
+    [FILTER_TYPES.DATE_RANGE]: {
+        filterType: FILTER_TYPES.DATE_RANGE,
+    },
+    [FILTER_TYPES.NUMERIC_RANGE]: {
+        filterType: FILTER_TYPES.NUMERIC_RANGE,
+    },
+    [FILTER_TYPES.CONDITION]: {
+        explicit: false,
+        multiSelection: true,
+        exclude: { members: [] },
+        filterType: FILTER_TYPES.CONDITION,
+    },
+    [FILTER_TYPES.SPECIFIC_ITEMS]: {
+        explicit: true,
+        multiSelection: true,
+        members: [],
+        filterType: FILTER_TYPES.SPECIFIC_ITEMS,
+    },
+};
+export const DEFAULT_FILTER_JAQL_WRAPPER = {
+    filter: DEFAULT_FILTER_JAQL_BY_TYPE_MAP.INCLUDE_ALL,
+    level: DatetimeLevel.YEARS,
+};
+export var ConditionFilterType;
+(function (ConditionFilterType) {
+    ConditionFilterType["IS"] = "members";
+    ConditionFilterType["IS_NOT"] = "exclude";
+    ConditionFilterType["IS_WITHIN"] = "isWithin";
+    ConditionFilterType["TOP"] = "top";
+    ConditionFilterType["BOTTOM"] = "bottom";
+    ConditionFilterType["AFTER"] = "after";
+    ConditionFilterType["BEFORE"] = "before";
+    ConditionFilterType["STARTS_WITH"] = "startsWith";
+    ConditionFilterType["DOESNT_START_WITH"] = "doesntStartWith";
+    ConditionFilterType["ENDS_WITH"] = "endsWith";
+    ConditionFilterType["DOESNT_END_WITH"] = "doesntEndWith";
+    ConditionFilterType["CONTAINS"] = "contains";
+    ConditionFilterType["DOESNT_CONTAIN"] = "doesntContain";
+    ConditionFilterType["EQUALS"] = "equals";
+    ConditionFilterType["DOESNT_EQUAL"] = "doesntEqual";
+    ConditionFilterType["IS_EMPTY"] = "isEmpty";
+    ConditionFilterType["IS_NOT_EMPTY"] = "isNotEmpty";
+    ConditionFilterType["GREATER_THAN"] = "fromNotEqual";
+    ConditionFilterType["GREATER_THAN_OR_EQUAL"] = "from";
+    ConditionFilterType["LESS_THAN"] = "toNotEqual";
+    ConditionFilterType["LESS_THAN_OR_EQUAL"] = "to";
+    ConditionFilterType["BETWEEN"] = "between";
+    ConditionFilterType["IS_NOT_BETWEEN"] = "isNotBetween";
+    ConditionFilterType["MULTIPLE_CONDITION"] = "multipleCondition";
+    ConditionFilterType["NONE"] = "none";
+})(ConditionFilterType = ConditionFilterType || (ConditionFilterType = {}));

package/dist/dimensional-model/measures/factory.d.ts

@@ -125,6 +125,8 @@ export declare function sum(attribute: Attribute, name?: string, format?: string
 /**
  * Creates an average aggregation measure over the given attribute.
  *
+ * Both `average()` and `avg()` can be used interchangeably.
+ *
  * @example
  * Calculate the average cost across all items in a category from the Sample Ecommerce data model.
  * ```ts
@@ -137,6 +139,17 @@ export declare function sum(attribute: Attribute, name?: string, format?: string
  * @group Aggregation
  */
 export declare function average(attribute: Attribute, name?: string, format?: string): BaseMeasure;
+/**
+ * {@inheritDoc average}
+ *
+ * @example
+ * Calculate the average cost across all items in a category from the Sample Ecommerce data model.
+ * ```ts
+ * measureFactory.avg(DM.Commerce.Cost)
+ * ```
+ * @group Aggregation
+ */
+export declare function avg(attribute: Attribute, name?: string, format?: string): BaseMeasure;
 /**
  * Creates a min aggregation measure over the given attribute.
  *

package/dist/dimensional-model/measures/factory.js

@@ -217,6 +217,8 @@ export function sum(attribute, name, format) {
 /**
  * Creates an average aggregation measure over the given attribute.
  *
+ * Both `average()` and `avg()` can be used interchangeably.
+ *
  * @example
  * Calculate the average cost across all items in a category from the Sample Ecommerce data model.
  * ```ts
@@ -231,6 +233,19 @@ export function sum(attribute, name, format) {
 export function average(attribute, name, format) {
     return aggregate(attribute, AggregationTypes.Average, name, format);
 }
+/**
+ * {@inheritDoc average}
+ *
+ * @example
+ * Calculate the average cost across all items in a category from the Sample Ecommerce data model.
+ * ```ts
+ * measureFactory.avg(DM.Commerce.Cost)
+ * ```
+ * @group Aggregation
+ */
+export function avg(attribute, name, format) {
+    return average(attribute, name, format);
+}
 /**
  * Creates a min aggregation measure over the given attribute.
  *

package/dist/dimensional-model/measures/measures.js

@@ -2,11 +2,8 @@
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable complexity */
-/* eslint-disable max-lines */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable sonarjs/cognitive-complexity */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 import * as m from './factory.js';
 import { Sort, AggregationTypes, MetadataTypes } from '../types.js';
@@ -352,7 +349,7 @@ export function createMeasure(json) {
     // legacy
     const exp = json.dim || json.expression;
     if (exp) {
-        att = new DimensionalAttribute(exp, exp);
+        att = new DimensionalAttribute(exp, exp, undefined, desc);
     }
     // official SDK
     if (json.attribute) {