@sisense/sdk-data 1.7.2 → 1.8.0

package/README.md

@@ -1,3 +1,3 @@
 This library, which is a part of Sisense Compose SDK, is
-for implementing the elements of [dimensional modeling](https://docs.sisense.com/main/SisenseLinux/data-model-building-practices.htm?tocpath=Modeling%20Data%7C_____4)
+for implementing the elements of dimensional modeling
 including dimensions, attributes, measures, and filters.

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

@@ -97,7 +97,7 @@ export const boxWhiskerIqrOutliers = (target) => {
     });
     outliersAttrWithInnerFilter.name = `${outliersAttrWithInnerFilter.name} (Outliers)`;
     outliersAttrWithInnerFilter.jaql = () => {
-        return Object.assign(Object.assign({}, target.jaql()), { filter: {
+        return Object.assign(Object.assign({}, target.jaql(true)), { filter: {
                 or: [
                     {
                         fromNotEqual: outliersMax.jaql(true),
@@ -125,7 +125,7 @@ export const boxWhiskerStdDevOutliers = (target) => {
         Attr: target,
     });
     outliersAttrWithInnerFilter.jaql = () => {
-        return Object.assign(Object.assign({}, target.jaql()), { filter: {
+        return Object.assign(Object.assign({}, target.jaql(true)), { filter: {
                 or: [
                     {
                         fromNotEqual: outliersMax.jaql(true),

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

@@ -41,3 +41,14 @@ export declare abstract class DimensionalElement implements Element {
  * @internal
  */
 export declare function normalizeName(name: string): string;
+/**
+ * Normalize attribute name
+ *
+ * @param tableName - Table name (e.g., Commerce Sales)
+ * @param columnName - Column name (e.g., Order Date)
+ * @param dateLevel - Date level (e.g., Years)
+ * @param modelName - module name (e.g., DM)
+ * @return full normalized attribute name (e.g., DM.CommerceSales.OrderDate.Years)
+ * @internal
+ */
+export declare function normalizeAttributeName(tableName: string, columnName: string, dateLevel?: string, modelName?: string): string;

package/dist/dimensional-model/base.js

@@ -51,3 +51,20 @@ export function normalizeName(name) {
     }
     return normalizedName;
 }
+/**
+ * Normalize attribute name
+ *
+ * @param tableName - Table name (e.g., Commerce Sales)
+ * @param columnName - Column name (e.g., Order Date)
+ * @param dateLevel - Date level (e.g., Years)
+ * @param modelName - module name (e.g., DM)
+ * @return full normalized attribute name (e.g., DM.CommerceSales.OrderDate.Years)
+ * @internal
+ */
+export function normalizeAttributeName(tableName, columnName, dateLevel, modelName) {
+    return ((modelName && modelName.length > 0 ? modelName + '.' : '') +
+        normalizeName(tableName) +
+        '.' +
+        normalizeName(columnName) +
+        (dateLevel && dateLevel.length > 0 ? '.' + dateLevel : ''));
+}

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

@@ -698,3 +698,12 @@ export declare namespace logic {
      */
     const or: (left: FilterRelationsNode, right: FilterRelationsNode) => FilterRelations;
 }
+/**
+ * Creates a filter from JAQL
+ *
+ * @param jaql - Filter Jaql
+ * @param instanceid - Filter instance id
+ * @returns A filter instance
+ * @internal
+ */
+export declare function customFilter(jaql: any, instanceid?: string): Filter;

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

@@ -1,4 +1,5 @@
 import { TextOperators, NumericOperators, DateOperators, LogicalOperators, RankingOperators, LogicalAttributeFilter, MembersFilter, ExcludeFilter, NumericFilter, MeasureFilter, RankingFilter, TextFilter, DateRangeFilter, RelativeDateFilter, } from './filters.js';
+import { createGenericFilter } from './utils/filter-jaql-util.js';
 // LOGICAL FILTERS
 /**
  * Creates a filter representing the union of multiple filters on the same attribute. The resulting
@@ -810,3 +811,15 @@ export var logic;
         right: relate(right),
     });
 })(logic = logic || (logic = {}));
+// CUSTOM FILTER
+/**
+ * Creates a filter from JAQL
+ *
+ * @param jaql - Filter Jaql
+ * @param instanceid - Filter instance id
+ * @returns A filter instance
+ * @internal
+ */
+export function customFilter(jaql, instanceid) {
+    return createGenericFilter(jaql, instanceid);
+}

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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,167 @@
+/* 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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,138 @@
+/* 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/date-time-filter-util.d.ts

@@ -0,0 +1,2 @@
+import { DatetimeLevel } from './types.js';
+export declare const getCorrectTimeLevel: (level?: DatetimeLevel, bucket?: string) => DatetimeLevel;

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

@@ -0,0 +1,8 @@
+import { DatetimeLevel } from './types.js';
+export const getCorrectTimeLevel = (level, bucket) => {
+    let newLevel = level ? level.toLocaleLowerCase() : DatetimeLevel.YEARS;
+    if (newLevel === DatetimeLevel.MINUTES && bucket === '60') {
+        newLevel = DatetimeLevel.HOURS;
+    }
+    return newLevel;
+};

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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,114 @@
+/* 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;
+};

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

@@ -0,0 +1,200 @@
+declare type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
+}[Keys];
+export declare type JaqlContext = Record<string, Partial<FilterJaqlInternal>>;
+export declare type Id = string;
+export declare type Datasource = {
+    address: Id;
+    database: string;
+    id: string;
+    title: string;
+    live?: boolean;
+    fullname: string;
+    lastBuildTime?: string;
+    revisionId?: string;
+};
+export declare enum GeneralFilterTypes {
+    INCLUDE_ALL = "INCLUDE_ALL",
+    ADVANCED = "ADVANCED",
+    INVALID = "INVALID",
+    CONDITION = "CONDITION",
+    SPECIFIC_ITEMS = "SPECIFIC_ITEMS"
+}
+export declare enum DateTimeFilterTypes {
+    PERIOD = "PERIOD",
+    DATE_RANGE = "DATE_RANGE"
+}
+export declare enum NumericFilterTypes {
+    NUMERIC_RANGE = "NUMERIC_RANGE"
+}
+export declare type FilterTypes = GeneralFilterTypes | DateTimeFilterTypes | NumericFilterTypes;
+export interface FilterType {
+    jaqlType?: FilterTypes;
+    custom?: boolean;
+    isAdvanced?: boolean;
+    rankingMessage?: string;
+    isBetween?: boolean;
+    isEmpty?: boolean;
+}
+export interface IncludeAllJaql extends FilterType {
+    all: boolean;
+}
+export declare type PeriodDetails = {
+    count: number;
+    offset: number;
+    anchor?: string;
+};
+export interface PeriodJaqlOptions extends FilterType {
+    last: PeriodDetails;
+    next: PeriodDetails;
+    multiSelection?: boolean;
+    isNotCurrentPeriod?: boolean;
+}
+export declare type PeriodJaql = RequireOnlyOne<PeriodJaqlOptions, 'last' | 'next'>;
+export interface RangeJaql extends FilterType {
+    from?: string | number;
+    to?: string | number;
+    multiSelection?: boolean;
+}
+export declare type RankingJaql = {
+    agg: string;
+    column: string;
+    datatype: string;
+    dim: string;
+    level?: string;
+    merged?: boolean;
+    table: string;
+};
+export declare type FilterMultiSelect = {
+    explicit?: boolean;
+    multiSelection: boolean;
+    members: string[];
+    isCondition?: boolean;
+};
+export declare type MultipleCondition = {
+    or: ConditionJaql[];
+    and: ConditionJaql[];
+};
+export declare type ConditionJaqlOptions = FilterType & {
+    top: number;
+    bottom: number;
+    exclude: {
+        members?: string[];
+        from?: number;
+        to?: number;
+    };
+    startsWith: string;
+    doesntStartWith: string;
+    endsWith: string;
+    doesntEndWith: string;
+    doesntContain: string;
+    equals: number | string;
+    doesntEqual: number | string;
+    to: number;
+    toNotEqual: number;
+    from: number;
+    fromNotEqual: number;
+    contains: string;
+    by?: RankingJaql;
+    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;
+export declare enum DatetimeLevel {
+    YEARS = "years",
+    QUARTERS = "quarters",
+    MONTHS = "months",
+    WEEKS = "weeks",
+    DAYS = "days",
+    HOURS = "hours",
+    MINUTES = "minutes"
+}
+export declare type FilterJaqlInternal = {
+    title: string;
+    column: string;
+    datasource?: Datasource;
+    datatype: string;
+    dim: string;
+    dimension?: string;
+    fiscal?: string;
+    firstday?: string;
+    merged?: boolean;
+    table: string;
+    filter?: FilterJaqlTypes;
+    level?: DatetimeLevel;
+    locale?: string;
+    bucket?: string;
+    collapsed?: boolean;
+    isDashboardFilter?: boolean;
+    formula?: string;
+    context?: JaqlContext;
+    agg?: string;
+};
+export declare enum FilterModalTypes {
+    DATE_TIME = "datetime",
+    NUMERIC = "numeric",
+    TEXT = "text"
+}
+export declare type BackgroundFilterExtraProps = {
+    level?: DatetimeLevel;
+    turnedOff?: boolean;
+};
+export declare type BackgroundFilter = {
+    filter?: FilterJaqlTypes & BackgroundFilterExtraProps;
+};
+export declare type FilterJaqlWrapperType = {
+    filter: FilterJaqlTypes & 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;
+};
+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 const FILTER_JAQL_DEFAULT: FilterJaqlDefaultType;
+export declare const FILTER_JAQL_WRAPPER: FilterJaqlWrapperType;
+export declare enum ConditionTypes {
+    IS = "members",
+    IS_NOT = "exclude",
+    IS_WITHIN = "isWithin",
+    TOP = "top",
+    BOTTOM = "bottom",
+    AFTER = "after",
+    BEFORE = "before",
+    STARTS_WITH = "startsWith",
+    DOESNT_START_WITH = "doesntStartWith",
+    ENDS_WITH = "endsWith",
+    DOESNT_END_WITH = "doesntEndWith",
+    CONTAINS = "contains",
+    DOESNT_CONTAIN = "doesntContain",
+    EQUALS = "equals",
+    DOESNT_EQUAL = "doesntEqual",
+    IS_EMPTY = "isEmpty",
+    IS_NOT_EMPTY = "isNotEmpty",
+    GREATER_THAN = "fromNotEqual",
+    GREATER_THAN_OR_EQUAL = "from",
+    LESS_THAN = "toNotEqual",
+    LESS_THAN_OR_EQUAL = "to",
+    BETWEEN = "between",
+    IS_NOT_BETWEEN = "isNotBetween",
+    MULTIPLE_CONDITION = "multipleCondition",
+    NONE = "none"
+}
+export {};

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

@@ -0,0 +1,97 @@
+/* eslint-disable max-lines */
+export var GeneralFilterTypes;
+(function (GeneralFilterTypes) {
+    GeneralFilterTypes["INCLUDE_ALL"] = "INCLUDE_ALL";
+    GeneralFilterTypes["ADVANCED"] = "ADVANCED";
+    GeneralFilterTypes["INVALID"] = "INVALID";
+    GeneralFilterTypes["CONDITION"] = "CONDITION";
+    GeneralFilterTypes["SPECIFIC_ITEMS"] = "SPECIFIC_ITEMS";
+})(GeneralFilterTypes = GeneralFilterTypes || (GeneralFilterTypes = {}));
+export var DateTimeFilterTypes;
+(function (DateTimeFilterTypes) {
+    DateTimeFilterTypes["PERIOD"] = "PERIOD";
+    DateTimeFilterTypes["DATE_RANGE"] = "DATE_RANGE";
+})(DateTimeFilterTypes = DateTimeFilterTypes || (DateTimeFilterTypes = {}));
+export var NumericFilterTypes;
+(function (NumericFilterTypes) {
+    NumericFilterTypes["NUMERIC_RANGE"] = "NUMERIC_RANGE";
+})(NumericFilterTypes = NumericFilterTypes || (NumericFilterTypes = {}));
+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 FilterModalTypes;
+(function (FilterModalTypes) {
+    FilterModalTypes["DATE_TIME"] = "datetime";
+    FilterModalTypes["NUMERIC"] = "numeric";
+    FilterModalTypes["TEXT"] = "text";
+})(FilterModalTypes = FilterModalTypes || (FilterModalTypes = {}));
+export const nonSupportedMinutesBuckets = ['1', '30'];
+export const FILTER_TYPES = Object.assign(Object.assign(Object.assign({}, GeneralFilterTypes), DateTimeFilterTypes), NumericFilterTypes);
+export const FILTER_JAQL_DEFAULT = {
+    [FILTER_TYPES.INCLUDE_ALL]: {
+        all: true,
+        jaqlType: FILTER_TYPES.INCLUDE_ALL,
+    },
+    [FILTER_TYPES.PERIOD]: {
+        last: { count: 1, offset: 1 },
+        isNotCurrentPeriod: true,
+        jaqlType: FILTER_TYPES.PERIOD,
+    },
+    [FILTER_TYPES.DATE_RANGE]: {
+        jaqlType: FILTER_TYPES.DATE_RANGE,
+    },
+    [FILTER_TYPES.NUMERIC_RANGE]: {
+        jaqlType: FILTER_TYPES.NUMERIC_RANGE,
+    },
+    [FILTER_TYPES.CONDITION]: {
+        explicit: false,
+        multiSelection: true,
+        exclude: { members: [] },
+        jaqlType: FILTER_TYPES.CONDITION,
+    },
+    [FILTER_TYPES.SPECIFIC_ITEMS]: {
+        explicit: true,
+        multiSelection: true,
+        members: [],
+        jaqlType: FILTER_TYPES.SPECIFIC_ITEMS,
+    },
+};
+export const FILTER_JAQL_WRAPPER = {
+    filter: FILTER_JAQL_DEFAULT.INCLUDE_ALL,
+    level: DatetimeLevel.YEARS,
+};
+export var ConditionTypes;
+(function (ConditionTypes) {
+    ConditionTypes["IS"] = "members";
+    ConditionTypes["IS_NOT"] = "exclude";
+    ConditionTypes["IS_WITHIN"] = "isWithin";
+    ConditionTypes["TOP"] = "top";
+    ConditionTypes["BOTTOM"] = "bottom";
+    ConditionTypes["AFTER"] = "after";
+    ConditionTypes["BEFORE"] = "before";
+    ConditionTypes["STARTS_WITH"] = "startsWith";
+    ConditionTypes["DOESNT_START_WITH"] = "doesntStartWith";
+    ConditionTypes["ENDS_WITH"] = "endsWith";
+    ConditionTypes["DOESNT_END_WITH"] = "doesntEndWith";
+    ConditionTypes["CONTAINS"] = "contains";
+    ConditionTypes["DOESNT_CONTAIN"] = "doesntContain";
+    ConditionTypes["EQUALS"] = "equals";
+    ConditionTypes["DOESNT_EQUAL"] = "doesntEqual";
+    ConditionTypes["IS_EMPTY"] = "isEmpty";
+    ConditionTypes["IS_NOT_EMPTY"] = "isNotEmpty";
+    ConditionTypes["GREATER_THAN"] = "fromNotEqual";
+    ConditionTypes["GREATER_THAN_OR_EQUAL"] = "from";
+    ConditionTypes["LESS_THAN"] = "toNotEqual";
+    ConditionTypes["LESS_THAN_OR_EQUAL"] = "to";
+    ConditionTypes["BETWEEN"] = "between";
+    ConditionTypes["IS_NOT_BETWEEN"] = "isNotBetween";
+    ConditionTypes["MULTIPLE_CONDITION"] = "multipleCondition";
+    ConditionTypes["NONE"] = "none";
+})(ConditionTypes = ConditionTypes || (ConditionTypes = {}));

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

@@ -10,8 +10,7 @@ export interface DataModel {
     [propName: string]: any;
 }
 /**
- * Common interface for elements of
- * [dimensional modeling](https://docs.sisense.com/main/SisenseLinux/data-model-building-practices.htm?tocpath=Modeling%20Data%7C_____4).
+ * Common interface for elements of a dimensional model.
  *
  * @internal
  */
@@ -61,6 +60,12 @@ export interface Element {
      * @internal
      */
     skipValidation?: boolean;
+    /**
+     * Optional CSDK code to initialize this element
+     *
+     * @internal
+     */
+    composeCode?: string;
 }
 /**
  * Base interface for measure, which is typically numeric aggregation over {@link Attribute}(s).
@@ -210,9 +215,6 @@ export interface Dimension extends Element, Attribute {
 }
 /**
  * Date Dimension extending {@link Dimension}.
- *
- * See [here](https://docs.sisense.com/main/SisenseLinux/date-and-time-fields.htm)
- * for more details on Date and Time Resolution for ElastiCubes and for Live Models.
  */
 export interface DateDimension extends Dimension {
     /**
@@ -265,9 +267,9 @@ export interface DateDimension extends Dimension {
     readonly AggMinutesRoundTo1: LevelAttribute;
 }
 /**
- * Common interface of an Attribute as defined in
- * [Dimensional Modeling](https://docs.sisense.com/main/SisenseLinux/data-model-building-practices.htm?tocpath=Modeling%20Data%7C_____4).
- * It is an extension of a {@link Column} in a generic {@link Data | Data Set}.
+ * Common interface of an attribute as in a dimensional model.
+ *
+ * An attribute is an extension of a {@link Column} in a generic {@link Data | data set}.
  */
 export interface Attribute extends Element {
     /**
@@ -354,6 +356,7 @@ export interface CustomFormulaContext {
 export interface PivotAttribute {
     attribute: Attribute;
     includeSubTotals?: boolean;
+    sort?: PivotRowsSort;
 }
 /**
  * Runs type guard check for PivotAttribute.
@@ -454,3 +457,50 @@ export declare type FilterRelationsModelIdNode = {
 export declare type FilterRelationsModelBracketNode = {
     value: FilterRelationsModelNode;
 };
+/** Sorting direction, either in Ascending order, Descending order, or None */
+export declare type SortDirection = 'sortAsc' | 'sortDesc' | 'sortNone';
+/**
+ * Sorting configuration for pivot "rows".
+ *
+ * This configuration allows sorting pivot "rows" either by their data or by data in a specific "values" column.
+ *
+ * @example
+ * Examples of sorting configurations for various scenarios:
+ *
+ * (1) Row sorted in ascending order by its data:
+ * ```ts
+ * { direction: 'sortAsc' }
+ * ```
+ *
+ * (2) Row sorted in descending order by data in the first "values" column (index 0):
+ * ```ts
+ * {
+ *    direction: 'sortDesc',
+ *    by: {
+ *      valuesIndex: 0,
+ *    }
+ * }
+ * ```
+ *
+ * (3) Row sorted in ascending order by data in the second "values" column (index 1) under the "columns" values of "Female" (for Gender) and "0-18" (for AgeRange):
+ * ```ts
+ * {
+ *    direction: 'sortAsc',
+ *    by: {
+ *      valuesIndex: 1,
+ *      columnsMembersPath: ['Female', '0-18']
+ *    }
+ * }
+ * ```
+ */
+export declare type PivotRowsSort = {
+    /** {@inheritDoc SortDirection} */
+    direction: SortDirection;
+    /** Sorting target configuration, allowing sorting "rows" by the data in a specific "values" column */
+    by?: {
+        /** Index of the target "values" item (measure) */
+        valuesIndex?: number;
+        /** Path to the target column if selected "columns" items (dimensions) are involved */
+        columnsMembersPath?: (string | number)[];
+    };
+};

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

@@ -40,8 +40,8 @@ export declare const RankingSortTypes: {
  *
  * You can nest custom formulas by placing one inside the `formula` parameter of another.
  *
- * Note: [Shared formulas](https://docs.sisense.com/main/SisenseLinux/shared-formulas.htm) must be
- * fetched prior to use (see {@link @sisense/sdk-ui!useGetSharedFormula | useGetSharedFormula}).
+ * Note: To use [shared formulas](https://docs.sisense.com/main/SisenseLinux/shared-formulas.htm)
+ * from a Fusion Embed instance, you must fetch them first using {@link @sisense/sdk-ui!useGetSharedFormula | useGetSharedFormula}.
  *
  * @example
  * An example of constructing a custom formulas using dimensions, measures, and nested custom formulas

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

@@ -105,8 +105,8 @@ function transformCustomFormulaJaql(jaql) {
  *
  * You can nest custom formulas by placing one inside the `formula` parameter of another.
  *
- * Note: [Shared formulas](https://docs.sisense.com/main/SisenseLinux/shared-formulas.htm) must be
- * fetched prior to use (see {@link @sisense/sdk-ui!useGetSharedFormula | useGetSharedFormula}).
+ * Note: To use [shared formulas](https://docs.sisense.com/main/SisenseLinux/shared-formulas.htm)
+ * from a Fusion Embed instance, you must fetch them first using {@link @sisense/sdk-ui!useGetSharedFormula | useGetSharedFormula}.
  *
  * @example
  * An example of constructing a custom formulas using dimensions, measures, and nested custom formulas

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

@@ -157,7 +157,7 @@ export declare enum DataType {
     DATETIME = "datetime"
 }
 /** @internal */
-export declare enum SortDirection {
+export declare enum JaqlSortDirection {
     ASC = "asc",
     DESC = "desc"
 }
@@ -172,7 +172,7 @@ export declare type BaseJaql = {
     column: string;
     title: string;
     level?: 'years' | 'quarters' | 'months' | 'weeks' | 'minutes' | 'days';
-    sort?: SortDirection;
+    sort?: JaqlSortDirection;
 };
 /** @internal */
 export declare type FormulaID = string;
@@ -181,13 +181,13 @@ export declare type FormulaContext = BaseJaql | FormulaJaql | FilterJaql;
 /** @internal */
 export declare type FormulaJaql = {
     type?: 'measure';
-    sort?: SortDirection;
+    sort?: JaqlSortDirection;
     title: string;
     formula: string;
     context?: Record<FormulaID, FormulaContext>;
 };
 /** @internal */
-export declare type BaseFilter = IncludeAllFilter | IncludeMembersFilter | ExcludeMembersFilter;
+export declare type BaseFilter = IncludeAllFilter | IncludeMembersFilter | ExcludeMembersFilter | JaqlNumericFilter | AndFilter<JaqlNumericFilter> | OrFilter<JaqlNumericFilter>;
 /** @internal */
 export declare type BackgroundFilter = BaseFilter & {
     level?: 'string';
@@ -216,3 +216,26 @@ export declare type FilterJaql = BaseJaql & {
         filter?: BackgroundFilter | TurnOffMembersFilter;
     };
 };
+declare type NumericFilterValue = number | FormulaJaql;
+/** @internal */
+export declare type JaqlNumericFilter = {
+    equals?: NumericFilterValue;
+    doesntEqual?: NumericFilterValue;
+    toNotEqual?: NumericFilterValue;
+    to?: NumericFilterValue;
+    fromNotEqual?: NumericFilterValue;
+    from?: NumericFilterValue;
+    '='?: NumericFilterValue;
+    '<'?: NumericFilterValue;
+    '>'?: NumericFilterValue;
+    '>='?: NumericFilterValue;
+    '<='?: NumericFilterValue;
+};
+declare type AndFilter<FilterItem> = {
+    and: FilterItem[];
+};
+/** @internal */
+export declare type OrFilter<FilterItem> = {
+    or: FilterItem[];
+};
+export {};

package/dist/dimensional-model/types.js

@@ -290,8 +290,8 @@ export var DataType;
     DataType["DATETIME"] = "datetime";
 })(DataType = DataType || (DataType = {}));
 /** @internal */
-export var SortDirection;
-(function (SortDirection) {
-    SortDirection["ASC"] = "asc";
-    SortDirection["DESC"] = "desc";
-})(SortDirection = SortDirection || (SortDirection = {}));
+export var JaqlSortDirection;
+(function (JaqlSortDirection) {
+    JaqlSortDirection["ASC"] = "asc";
+    JaqlSortDirection["DESC"] = "desc";
+})(JaqlSortDirection = JaqlSortDirection || (JaqlSortDirection = {}));

package/dist/index.d.ts

@@ -54,8 +54,6 @@ export * from './dimensional-model/measures/measures.js';
  * Functions to create measures that aggregate, summarize, and accumulate data,
  * plus show changes in data over time.
  *
- * They are similar to [Formulas](https://docs.sisense.com/main/SisenseLinux/build-formulas.htm) in Sisense.
- *
  * Measures created with these functions can be used in the data options of UI components such as
  * {@link @sisense/sdk-ui!ChartProps | Chart}, {@link @sisense/sdk-ui!ChartWidgetProps | ChartWidget},
  * and {@link @sisense/sdk-ui!ExecuteQueryProps | ExecuteQuery}.

package/dist/index.js

@@ -54,8 +54,6 @@ export * from './dimensional-model/measures/measures.js';
  * Functions to create measures that aggregate, summarize, and accumulate data,
  * plus show changes in data over time.
  *
- * They are similar to [Formulas](https://docs.sisense.com/main/SisenseLinux/build-formulas.htm) in Sisense.
- *
  * Measures created with these functions can be used in the data options of UI components such as
  * {@link @sisense/sdk-ui!ChartProps | Chart}, {@link @sisense/sdk-ui!ChartWidgetProps | ChartWidget},
  * and {@link @sisense/sdk-ui!ExecuteQueryProps | ExecuteQuery}.

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { Filter, FilterRelations, FilterRelationsJaql, DataSource, DataSourceInfo } from './index.js';
+import { Filter, FilterRelations, FilterRelationsJaql, DataSource, DataSourceInfo, FilterJaql } from './index.js';
 /**
  * A more performant, but slightly bulkier, RFC4122v4 implementation. Performance is improved by minimizing calls to random()
  *
@@ -16,11 +16,22 @@ export declare const getFilterListAndRelations: (filterRelations: FilterRelation
 };
 /**
  * Gets the name of the data source
+ *
  * @internal
  */
 export declare function getDataSourceName(dataSource: DataSource): string;
 /**
  * Checks if the provided 'dataSource' is a data source info structure that contains more than just the data source name.
+ *
  * @internal
  */
 export declare function isDataSourceInfo(dataSource: DataSource): dataSource is DataSourceInfo;
+/**
+ * Creates a filter from a JAQL object.
+ *
+ * @param jaql - The filter JAQL object.
+ * @param instanceid - The instance ID.
+ * @returns - The created Filter object.
+ * @internal
+ */
+export declare const createFilterFromJaql: (jaql: FilterJaql, instanceid?: string) => Filter;

package/dist/utils.js

@@ -1,4 +1,5 @@
 import cloneDeep from 'lodash/cloneDeep.js';
+import { createFilterFromJaqlInternal } from './dimensional-model/filters/utils/filter-jaql-util.js';
 /**
  * A more performant, but slightly bulkier, RFC4122v4 implementation. Performance is improved by minimizing calls to random()
  *
@@ -63,6 +64,7 @@ export const getFilterListAndRelations = (filterRelations) => {
 };
 /**
  * Gets the name of the data source
+ *
  * @internal
  */
 export function getDataSourceName(dataSource) {
@@ -70,8 +72,23 @@ export function getDataSourceName(dataSource) {
 }
 /**
  * Checks if the provided 'dataSource' is a data source info structure that contains more than just the data source name.
+ *
  * @internal
  */
 export function isDataSourceInfo(dataSource) {
     return typeof dataSource === 'object' && 'type' in dataSource && 'title' in dataSource;
 }
+/**
+ * Creates a filter from a JAQL object.
+ *
+ * @param jaql - The filter JAQL object.
+ * @param instanceid - The instance ID.
+ * @returns - The created Filter object.
+ * @internal
+ */
+export const createFilterFromJaql = (jaql, instanceid) => {
+    // translation logic is based on FilterJaqlInternal type (from internal modern-analytics-filters)
+    // TODO reconcile FilterJaql and FilterJaqlInternal
+    const jaqlInternal = jaql;
+    return createFilterFromJaqlInternal(jaqlInternal, instanceid);
+};

package/package.json

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