@sisense/sdk-data 1.7.2 → 1.9.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/attributes.d.ts

@@ -125,3 +125,14 @@ export declare function createAttribute(json: any): Attribute;
  * @internal
  */
 export declare function createLevel(json: any): LevelAttribute;
+/**
+ * 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/attributes.js

@@ -207,7 +207,7 @@ export class DimensionalLevelAttribute extends DimensionalAttribute {
     }
     static translateJaqlToGranularity(json) {
         const returnUnsupported = (lvl) => {
-            console.warn('Unsupported granularity');
+            console.warn('Unsupported granularity', lvl);
             return lvl;
         };
         if (json.dateTimeLevel) {
@@ -281,3 +281,22 @@ export function createAttribute(json) {
 export function createLevel(json) {
     return new DimensionalLevelAttribute(json.name || json.title, json.attribute || json.expression || json.dim, json.granularity, json.format, json.desc || json.description);
 }
+/**
+ * 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
+            ? '.' + DimensionalLevelAttribute.translateJaqlToGranularity({ level: dateLevel })
+            : ''));
+}

package/dist/dimensional-model/dimensions.js

@@ -247,7 +247,7 @@ export function createDimension(json) {
     const type = DimensionalDimension.parseType(json.dimtype || json.type);
     // date dimension
     if (type == MetadataTypes.DateDimension) {
-        return new DimensionalDateDimension(name, expression);
+        return new DimensionalDateDimension(name, expression, description);
     }
     // attributes
     const atts = Object.getOwnPropertyNames(json)
@@ -258,12 +258,12 @@ export function createDimension(json) {
             let att;
             for (let i = 0; i < json.attributes.length; i++) {
                 att = json.attributes[i];
-                atts.push(new DimensionalAttribute(att.name, att.expression, att.type));
+                atts.push(new DimensionalAttribute(att.name, att.expression, att.type, att.description));
             }
         }
         // default attribute
         else if (expression) {
-            atts.push(new DimensionalAttribute(name, expression));
+            atts.push(new DimensionalAttribute(name, expression, type, description));
         }
     }
     // nested dimensions
@@ -295,5 +295,6 @@ export function createDimension(json) {
 export function createDateDimension(json) {
     const name = json.name || json.title;
     const expression = json.expression || json.dim;
-    return new DimensionalDateDimension(name, expression);
+    const description = json.desc || json.description;
+    return new DimensionalDateDimension(name, expression, description);
 }

package/dist/dimensional-model/factory.js

@@ -1,4 +1,3 @@
-/* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { MetadataTypes } from './types.js';
 import { createMeasure } from './measures/measures.js';

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

@@ -523,6 +523,39 @@ export declare function today(dimension: DateDimension): Filter;
  * @internal
  */
 export declare function measureBase(attribute: Attribute, measure: Measure, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number): Filter;
+/**
+ * Creates a filter to isolate a measure value equal to a given number.
+ *
+ * @example
+ * Filter for categories that have an average revenue equal 50 in the Sample ECommerce data model.
+ * ```ts
+ * filterFactory.measureEquals(
+ *   measures.average(DM.Commerce.Revenue),
+ *   50
+ * )
+ * ```
+ * @param measure - Measure to filter by
+ * @param value - Value
+ * @returns A filter instance
+ */
+export declare function measureEquals(measure: BaseMeasure, value: number): Filter;
+/**
+ * Creates a filter to isolate a measure value greater than to a given number.
+ *
+ * @example
+ * Filter for categories that have an average revenue greater than
+ * to 50 in the Sample ECommerce data model.
+ * ```ts
+ * filterFactory.measureGreaterThan(
+ *   measures.average(DM.Commerce.Revenue),
+ *   50
+ * )
+ * ```
+ * @param measure - Measure to filter by
+ * @param value - Min value
+ * @returns A filter instance
+ */
+export declare function measureGreaterThan(measure: BaseMeasure, value: number): Filter;
 /**
  * Creates a filter to isolate a measure value greater than or equal to a given number.
  *
@@ -557,6 +590,22 @@ export declare function measureGreaterThanOrEqual(measure: BaseMeasure, value: n
  * @returns A filter instance
  */
 export declare function measureLessThanOrEqual(measure: BaseMeasure, value: number): Filter;
+/**
+ * Creates a filter to isolate a measure value less than a given number.
+ *
+ * @example
+ * Filter for categories that have an average revenue less than 100 in the Sample ECommerce data model.
+ * ```ts
+ * filterFactory.measureLessThan(
+ *   measures.average(DM.Commerce.Revenue),
+ *   100
+ * )
+ * ```
+ * @param measure - Measure to filter by
+ * @param value - Value
+ * @returns A filter instance
+ */
+export declare function measureLessThan(measure: BaseMeasure, value: number): Filter;
 /**
  * Creates a filter to isolate a measure value between or equal to two given numbers.
  *
@@ -698,3 +747,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-from-jaql-util.js';
 // LOGICAL FILTERS
 /**
  * Creates a filter representing the union of multiple filters on the same attribute. The resulting
@@ -599,6 +600,43 @@ export function today(dimension) {
 export function measureBase(attribute, measure, operatorA, valueA, operatorB, valueB) {
     return new MeasureFilter(attribute, measure, operatorA, valueA, operatorB, valueB);
 }
+/**
+ * Creates a filter to isolate a measure value equal to a given number.
+ *
+ * @example
+ * Filter for categories that have an average revenue equal 50 in the Sample ECommerce data model.
+ * ```ts
+ * filterFactory.measureEquals(
+ *   measures.average(DM.Commerce.Revenue),
+ *   50
+ * )
+ * ```
+ * @param measure - Measure to filter by
+ * @param value - Value
+ * @returns A filter instance
+ */
+export function measureEquals(measure, value) {
+    return measureBase(measure.attribute, measure, NumericOperators.Equals, value);
+}
+/**
+ * Creates a filter to isolate a measure value greater than to a given number.
+ *
+ * @example
+ * Filter for categories that have an average revenue greater than
+ * to 50 in the Sample ECommerce data model.
+ * ```ts
+ * filterFactory.measureGreaterThan(
+ *   measures.average(DM.Commerce.Revenue),
+ *   50
+ * )
+ * ```
+ * @param measure - Measure to filter by
+ * @param value - Min value
+ * @returns A filter instance
+ */
+export function measureGreaterThan(measure, value) {
+    return measureBase(measure.attribute, measure, NumericOperators.FromNotEqual, value);
+}
 /**
  * Creates a filter to isolate a measure value greater than or equal to a given number.
  *
@@ -637,6 +675,24 @@ export function measureGreaterThanOrEqual(measure, value) {
 export function measureLessThanOrEqual(measure, value) {
     return measureBase(measure.attribute, measure, NumericOperators.To, value);
 }
+/**
+ * Creates a filter to isolate a measure value less than a given number.
+ *
+ * @example
+ * Filter for categories that have an average revenue less than 100 in the Sample ECommerce data model.
+ * ```ts
+ * filterFactory.measureLessThan(
+ *   measures.average(DM.Commerce.Revenue),
+ *   100
+ * )
+ * ```
+ * @param measure - Measure to filter by
+ * @param value - Value
+ * @returns A filter instance
+ */
+export function measureLessThan(measure, value) {
+    return measureBase(measure.attribute, measure, NumericOperators.ToNotEqual, value);
+}
 /**
  * Creates a filter to isolate a measure value between or equal to two given numbers.
  *
@@ -810,3 +866,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/filters.js

@@ -2,11 +2,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable max-lines */
 /* eslint-disable max-params */
 /* eslint-disable @typescript-eslint/restrict-template-expressions */
-/* eslint-disable max-lines-per-function */
-/* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 import hash from 'object-hash';
 import { DimensionalElement } from '../base.js';

package/dist/dimensional-model/filters/utils/attribute-measure-util.d.ts

@@ -0,0 +1,47 @@
+import { Attribute, BaseMeasure, LevelAttribute } from '../../interfaces.js';
+import { FilterJaql } from '../../types.js';
+import { FilterJaqlInternal, RankingFilterJaql } from './types.js';
+/**
+ * Creates an attribute or level attribute from the provided parameters
+ *
+ * @param dim - Dimension expression
+ * @param table - Table name
+ * @param column - Column name
+ * @param level - Date level
+ * @param dataType - Data type
+ * @returns attribute or level attribute
+ */
+export declare const createAttributeHelper: (dim: string, table: string, column: string, level: string | undefined, dataType: string) => Attribute | LevelAttribute;
+/**
+ * Creates an attribute or level attribute from the provided filter JAQL object
+ *
+ * @param jaql - Filter JAQL object
+ * @returns attribute or level attribute
+ */
+export declare const createAttributeFromFilterJaql: (jaql: FilterJaql | FilterJaqlInternal) => Attribute | LevelAttribute;
+/**
+ * Creates a measure from the provided parameters
+ *
+ * @param dim - Dimension expression
+ * @param table - Table name
+ * @param column - Column name
+ * @param level - Date level
+ * @param dataType - Data type
+ * @param agg - Aggregation function
+ * @returns measure
+ */
+export declare const createMeasureHelper: (dim: string, table: string, column: string, level: string | undefined, dataType: string, agg: string) => BaseMeasure;
+/**
+ * Creates a measure from the provided filter JAQL object
+ *
+ * @param jaql - Filter JAQL object
+ * @returns Measure
+ */
+export declare const createMeasureFromFilterJaql: (jaql: FilterJaqlInternal) => BaseMeasure | undefined;
+/**
+ * Creates a measure from the provided ranking filter JAQL object
+ *
+ * @param jaql - Ranking filter Jaql object
+ * @returns Measure
+ */
+export declare const createMeasureFromRankingFilterJaql: (jaql: RankingFilterJaql) => BaseMeasure;

package/dist/dimensional-model/filters/utils/attribute-measure-util.js

@@ -0,0 +1,77 @@
+import { DimensionalAttribute, DimensionalLevelAttribute, normalizeAttributeName, } from '../../attributes.js';
+import { isNumber } from '../../simple-column-types.js';
+import { MetadataTypes } from '../../types.js';
+import * as measureFactory from '../../measures/factory.js';
+const DATA_MODEL_MODULE_NAME = 'DM';
+/**
+ * Creates an attribute or level attribute from the provided parameters
+ *
+ * @param dim - Dimension expression
+ * @param table - Table name
+ * @param column - Column name
+ * @param level - Date level
+ * @param dataType - Data type
+ * @returns attribute or level attribute
+ */
+export const createAttributeHelper = (dim, table, column, level, dataType) => {
+    if (level) {
+        const dateLevel = DimensionalLevelAttribute.translateJaqlToGranularity({ level });
+        const levelAttribute = new DimensionalLevelAttribute(column, dim, dateLevel);
+        levelAttribute.composeCode = normalizeAttributeName(table, column, level, DATA_MODEL_MODULE_NAME);
+        return levelAttribute;
+    }
+    const attributeType = isNumber(dataType)
+        ? MetadataTypes.NumericAttribute
+        : MetadataTypes.TextAttribute;
+    const attribute = new DimensionalAttribute(column, dim, attributeType);
+    attribute.composeCode = normalizeAttributeName(table, column, undefined, DATA_MODEL_MODULE_NAME);
+    return attribute;
+};
+/**
+ * Creates an attribute or level attribute from the provided filter JAQL object
+ *
+ * @param jaql - Filter JAQL object
+ * @returns attribute or level attribute
+ */
+export const createAttributeFromFilterJaql = (jaql) => {
+    return createAttributeHelper(jaql.dim, jaql.table, jaql.column, jaql.level, jaql.datatype);
+};
+/**
+ * Creates a measure from the provided parameters
+ *
+ * @param dim - Dimension expression
+ * @param table - Table name
+ * @param column - Column name
+ * @param level - Date level
+ * @param dataType - Data type
+ * @param agg - Aggregation function
+ * @returns measure
+ */
+export const createMeasureHelper = (dim, table, column, level, dataType, agg) => {
+    const attribute = createAttributeHelper(dim, table, column, level, dataType);
+    const measure = measureFactory.aggregate(attribute, agg);
+    measure.composeCode = `measureFactory.${agg}(${attribute.composeCode})`;
+    return measure;
+};
+/**
+ * Creates a measure from the provided filter JAQL object
+ *
+ * @param jaql - Filter JAQL object
+ * @returns Measure
+ */
+export const createMeasureFromFilterJaql = (jaql) => {
+    const { dim, table, column, level, datatype: dataType, agg } = jaql;
+    if (!agg)
+        return undefined;
+    return createMeasureHelper(dim, table, column, level, dataType, agg);
+};
+/**
+ * Creates a measure from the provided ranking filter JAQL object
+ *
+ * @param jaql - Ranking filter Jaql object
+ * @returns Measure
+ */
+export const createMeasureFromRankingFilterJaql = (jaql) => {
+    const { dim, table, column, level, datatype: dataType, agg } = jaql;
+    return createMeasureHelper(dim, table, column, level, dataType, agg);
+};

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

@@ -0,0 +1,19 @@
+import { ConditionFilterJaql, ConditionFilterType } from './types.js';
+import { Attribute, BaseMeasure, Filter } from '../../interfaces.js';
+export declare const getSelectedConditionOption: (filter: ConditionFilterJaql) => ConditionFilterType;
+/**
+ * Creates an attribute filter from the provided attribute and condition filter JAQL object
+ *
+ * @param attribute - Provided attribute
+ * @param conditionFilterJaql - Condition filter JAQL object
+ * @returns attribute filter
+ */
+export declare const createAttributeFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql) => Filter;
+/**
+ * Creates a measure filter from the provided measure and condition filter JAQL object
+ *
+ * @param measure - Provided measure
+ * @param conditionFilterJaql - Condition filter JAQL object
+ * @returns measure filter
+ */
+export declare const createMeasureFilterFromConditionFilterJaql: (measure: BaseMeasure, conditionFilterJaql: ConditionFilterJaql) => Filter;

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

@@ -0,0 +1,162 @@
+import { ConditionFilterType } from './types.js';
+import { withComposeCode } from './filter-code-util.js';
+import * as filterFactory from '../factory.js';
+import { createMeasureFromRankingFilterJaql } from './attribute-measure-util.js';
+const isTopCondition = (filter) => filter.top !== undefined;
+const isBottomCondition = (filter) => filter.bottom !== undefined;
+const isExcludeCondition = (filter) => { var _a; return !!((_a = filter.exclude) === null || _a === void 0 ? void 0 : _a.members); };
+const isMembersCondition = (filter) => !!filter.members && !!filter.isCondition;
+const isWithinCondition = (filter) => { var _a, _b; return ((_a = filter.last) === null || _a === void 0 ? void 0 : _a.anchor) !== undefined || ((_b = filter.next) === null || _b === void 0 ? void 0 : _b.anchor) !== undefined; };
+const isGreaterThanCondition = (filter) => filter.fromNotEqual !== undefined;
+const isGreaterThanOrEqualCondition = (filter) => filter.from !== undefined && !filter.isBetween;
+const isLessThanCondition = (filter) => filter.toNotEqual !== undefined;
+const isLessThanOrEqualCondition = (filter) => filter.to !== undefined && !filter.isBetween;
+const isEqualsCondition = (filter) => filter.equals !== undefined;
+const isNotEqualCondition = (filter) => filter.doesntEqual !== undefined;
+const isEmptyCondition = (filter) => !!(filter.equals === '' && filter.isEmpty);
+const isNotEmptyCondition = (filter) => !!(filter.doesntEqual === '' && filter.isEmpty);
+const isContainsCondition = (filter) => filter.contains !== undefined;
+const isDoesntContainCondition = (filter) => filter.doesntContain !== undefined;
+const isStartsWithCondition = (filter) => filter.startsWith !== undefined;
+const isDoesntStartsWithCondition = (filter) => filter.doesntStartWith !== undefined;
+const isEndsWithCondition = (filter) => filter.endsWith !== undefined;
+const isDoesntEndWithCondition = (filter) => filter.doesntEndWith !== undefined;
+const isBetweenCondition = (filter) => filter.from !== undefined && filter.to !== undefined;
+const isNotBetweenCondition = (filter) => { var _a, _b; return ((_a = filter.exclude) === null || _a === void 0 ? void 0 : _a.from) !== undefined && ((_b = filter.exclude) === null || _b === void 0 ? void 0 : _b.to) !== undefined; };
+const isMultipleCondition = (filter) => !!(filter.or || filter.and);
+export const getSelectedConditionOption = (filter) => {
+    if (isBottomCondition(filter))
+        return ConditionFilterType.BOTTOM;
+    if (isTopCondition(filter))
+        return ConditionFilterType.TOP;
+    if (isExcludeCondition(filter))
+        return ConditionFilterType.IS_NOT;
+    if (isWithinCondition(filter))
+        return ConditionFilterType.IS_WITHIN;
+    if (isGreaterThanCondition(filter))
+        return ConditionFilterType.GREATER_THAN;
+    if (isGreaterThanOrEqualCondition(filter))
+        return ConditionFilterType.GREATER_THAN_OR_EQUAL;
+    if (isLessThanCondition(filter))
+        return ConditionFilterType.LESS_THAN;
+    if (isLessThanOrEqualCondition(filter))
+        return ConditionFilterType.LESS_THAN_OR_EQUAL;
+    if (isEqualsCondition(filter))
+        return ConditionFilterType.EQUALS;
+    if (isNotEqualCondition(filter))
+        return ConditionFilterType.DOESNT_EQUAL;
+    if (isEmptyCondition(filter))
+        return ConditionFilterType.IS_EMPTY;
+    if (isNotEmptyCondition(filter))
+        return ConditionFilterType.IS_NOT_EMPTY;
+    if (isContainsCondition(filter))
+        return ConditionFilterType.CONTAINS;
+    if (isDoesntContainCondition(filter))
+        return ConditionFilterType.DOESNT_CONTAIN;
+    if (isDoesntEndWithCondition(filter))
+        return ConditionFilterType.DOESNT_END_WITH;
+    if (isDoesntStartsWithCondition(filter))
+        return ConditionFilterType.DOESNT_START_WITH;
+    if (isEndsWithCondition(filter))
+        return ConditionFilterType.ENDS_WITH;
+    if (isStartsWithCondition(filter))
+        return ConditionFilterType.STARTS_WITH;
+    if (isBetweenCondition(filter))
+        return ConditionFilterType.BETWEEN;
+    if (isNotBetweenCondition(filter))
+        return ConditionFilterType.IS_NOT_BETWEEN;
+    if (isMembersCondition(filter))
+        return ConditionFilterType.IS;
+    if (isMultipleCondition(filter))
+        return ConditionFilterType.MULTIPLE_CONDITION;
+    return ConditionFilterType.NONE;
+};
+/**
+ * Creates an attribute filter from the provided attribute and condition filter JAQL object
+ *
+ * @param attribute - Provided attribute
+ * @param conditionFilterJaql - Condition filter JAQL object
+ * @returns attribute filter
+ */
+export const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilterJaql) => {
+    var _a, _b;
+    const conditionType = getSelectedConditionOption(conditionFilterJaql);
+    switch (conditionType) {
+        case ConditionFilterType.BOTTOM:
+            if (conditionFilterJaql.by && 'agg' in conditionFilterJaql.by) {
+                return withComposeCode(filterFactory.bottomRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by), conditionFilterJaql[ConditionFilterType.BOTTOM]);
+            }
+            break;
+        case ConditionFilterType.EQUALS:
+            return withComposeCode(filterFactory.equals)(attribute, conditionFilterJaql[ConditionFilterType.EQUALS]);
+        case ConditionFilterType.GREATER_THAN:
+            return withComposeCode(filterFactory.greaterThan)(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN]);
+        case ConditionFilterType.GREATER_THAN_OR_EQUAL:
+            return withComposeCode(filterFactory.greaterThanOrEqual)(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL]);
+        case ConditionFilterType.TOP:
+            if (conditionFilterJaql.by) {
+                return withComposeCode(filterFactory.topRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by), conditionFilterJaql[ConditionFilterType.TOP]);
+            }
+            break;
+        case ConditionFilterType.STARTS_WITH:
+            return withComposeCode(filterFactory.startsWith)(attribute, conditionFilterJaql[ConditionFilterType.STARTS_WITH]);
+        case ConditionFilterType.DOESNT_START_WITH:
+            return withComposeCode(filterFactory.doesntStartWith)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_START_WITH]);
+        case ConditionFilterType.ENDS_WITH:
+            return withComposeCode(filterFactory.endsWith)(attribute, conditionFilterJaql[ConditionFilterType.ENDS_WITH]);
+        case ConditionFilterType.DOESNT_END_WITH:
+            return withComposeCode(filterFactory.doesntEndWith)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_END_WITH]);
+        case ConditionFilterType.CONTAINS:
+            return withComposeCode(filterFactory.contains)(attribute, conditionFilterJaql[ConditionFilterType.CONTAINS]);
+        case ConditionFilterType.DOESNT_CONTAIN:
+            return withComposeCode(filterFactory.doesntContain)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_CONTAIN]);
+        case ConditionFilterType.LESS_THAN:
+            return withComposeCode(filterFactory.lessThan)(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN]);
+        case ConditionFilterType.LESS_THAN_OR_EQUAL:
+            return withComposeCode(filterFactory.lessThanOrEqual)(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL]);
+        case ConditionFilterType.BETWEEN:
+            return withComposeCode(filterFactory.between)(attribute, conditionFilterJaql.from, conditionFilterJaql.to);
+        case ConditionFilterType.IS_NOT_BETWEEN:
+            return withComposeCode(filterFactory.exclude)(withComposeCode(filterFactory.between)(attribute, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to));
+        case ConditionFilterType.MULTIPLE_CONDITION:
+            if (conditionFilterJaql.and) {
+                return withComposeCode(filterFactory.intersection)(conditionFilterJaql.and.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c)));
+            }
+            if (conditionFilterJaql.or) {
+                return withComposeCode(filterFactory.union)(conditionFilterJaql.or.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c)));
+            }
+            break;
+        case ConditionFilterType.AFTER:
+        case ConditionFilterType.BEFORE:
+        case ConditionFilterType.IS_EMPTY:
+        case ConditionFilterType.IS_NOT_EMPTY:
+            // TODO Handle these cases later; may need filterFactory function added first
+            break;
+    }
+    throw 'Jaql contains unsupported condition filter: ' + JSON.stringify(conditionFilterJaql);
+};
+/**
+ * Creates a measure filter from the provided measure and condition filter JAQL object
+ *
+ * @param measure - Provided measure
+ * @param conditionFilterJaql - Condition filter JAQL object
+ * @returns measure filter
+ */
+export const createMeasureFilterFromConditionFilterJaql = (measure, conditionFilterJaql) => {
+    const conditionType = getSelectedConditionOption(conditionFilterJaql);
+    switch (conditionType) {
+        case ConditionFilterType.EQUALS:
+            return withComposeCode(filterFactory.measureEquals)(measure, conditionFilterJaql[ConditionFilterType.EQUALS]);
+        case ConditionFilterType.GREATER_THAN:
+            return withComposeCode(filterFactory.measureGreaterThan)(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN]);
+        case ConditionFilterType.GREATER_THAN_OR_EQUAL:
+            return withComposeCode(filterFactory.measureGreaterThanOrEqual)(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL]);
+        case ConditionFilterType.LESS_THAN:
+            return withComposeCode(filterFactory.measureLessThan)(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN]);
+        case ConditionFilterType.LESS_THAN_OR_EQUAL:
+            return withComposeCode(filterFactory.measureLessThanOrEqual)(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL]);
+        case ConditionFilterType.BETWEEN:
+            return withComposeCode(filterFactory.measureBetween)(measure, conditionFilterJaql.from, conditionFilterJaql.to);
+    }
+    throw 'Jaql contains unsupported condition filter: ' + JSON.stringify(conditionFilterJaql);
+};

package/dist/dimensional-model/filters/utils/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/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/filter-code-util.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Stringifies the argument
+ *
+ * @param arg - argument to stringify
+ * @returns stringified argument
+ */
+export declare function stringifyHelper(arg: any): string;
+/**
+ * High order function to construct compose code for filter factory functions
+ *
+ * @param func - filter factory function
+ */
+export declare function withComposeCode(func: (...args: any[]) => any): (...args: any[]) => any;