@sisense/sdk-data 1.23.0 → 1.25.0

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

@@ -3,6 +3,7 @@ import { withComposeCode } from './filter-code-util.js';
 import * as filterFactory from '../factory.js';
 import { createMeasureFromRankingFilterJaql } from './attribute-measure-util.js';
 import { TranslatableError } from '../../../translation/translatable-error.js';
+import { simplifyFilterConfig } from '../filter-config-utils.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); };
@@ -78,57 +79,57 @@ export const getSelectedConditionOption = (filter) => {
  *
  * @param attribute - Provided attribute
  * @param conditionFilterJaql - Condition filter JAQL object
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns attribute filter
  */
 export const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, guid) => {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     const conditionType = getSelectedConditionOption(conditionFilterJaql);
     switch (conditionType) {
         case ConditionFilterType.BOTTOM:
             if (conditionFilterJaql.by) {
-                return withComposeCode(filterFactory.bottomRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.BOTTOM], guid);
+                return withComposeCode(filterFactory.bottomRanking, 'bottomRanking')(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.BOTTOM], { guid });
             }
             break;
         case ConditionFilterType.EQUALS:
-            return withComposeCode(filterFactory.equals)(attribute, conditionFilterJaql[ConditionFilterType.EQUALS], guid);
+            return withComposeCode(filterFactory.equals, 'equals')(attribute, conditionFilterJaql[ConditionFilterType.EQUALS], { guid });
         case ConditionFilterType.DOESNT_EQUAL:
-            return withComposeCode(filterFactory.doesntEqual)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_EQUAL], guid);
+            return withComposeCode(filterFactory.doesntEqual, 'doesntEqual')(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_EQUAL], { guid });
         case ConditionFilterType.GREATER_THAN:
-            return withComposeCode(filterFactory.greaterThan)(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN], guid);
+            return withComposeCode(filterFactory.greaterThan, 'greaterThan')(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN], { guid });
         case ConditionFilterType.GREATER_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.greaterThanOrEqual)(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], guid);
+            return withComposeCode(filterFactory.greaterThanOrEqual, 'greaterThanOrEqual')(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], { guid });
         case ConditionFilterType.TOP:
             if (conditionFilterJaql.by) {
-                return withComposeCode(filterFactory.topRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.TOP], guid);
+                return withComposeCode(filterFactory.topRanking, 'topRanking')(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.TOP], { guid });
             }
             break;
         case ConditionFilterType.STARTS_WITH:
-            return withComposeCode(filterFactory.startsWith)(attribute, conditionFilterJaql[ConditionFilterType.STARTS_WITH], guid);
+            return withComposeCode(filterFactory.startsWith, 'startsWith')(attribute, conditionFilterJaql[ConditionFilterType.STARTS_WITH], { guid });
         case ConditionFilterType.DOESNT_START_WITH:
-            return withComposeCode(filterFactory.doesntStartWith)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_START_WITH], guid);
+            return withComposeCode(filterFactory.doesntStartWith, 'doesntStartWith')(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_START_WITH], { guid });
         case ConditionFilterType.ENDS_WITH:
-            return withComposeCode(filterFactory.endsWith)(attribute, conditionFilterJaql[ConditionFilterType.ENDS_WITH], guid);
+            return withComposeCode(filterFactory.endsWith, 'endsWith')(attribute, conditionFilterJaql[ConditionFilterType.ENDS_WITH], { guid });
         case ConditionFilterType.DOESNT_END_WITH:
-            return withComposeCode(filterFactory.doesntEndWith)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_END_WITH], guid);
+            return withComposeCode(filterFactory.doesntEndWith, 'doesntEndWith')(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_END_WITH], { guid });
         case ConditionFilterType.CONTAINS:
-            return withComposeCode(filterFactory.contains)(attribute, conditionFilterJaql[ConditionFilterType.CONTAINS], guid);
+            return withComposeCode(filterFactory.contains, 'contains')(attribute, conditionFilterJaql[ConditionFilterType.CONTAINS], { guid });
         case ConditionFilterType.DOESNT_CONTAIN:
-            return withComposeCode(filterFactory.doesntContain)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_CONTAIN], guid);
+            return withComposeCode(filterFactory.doesntContain, 'doesntContain')(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_CONTAIN], { guid });
         case ConditionFilterType.LESS_THAN:
-            return withComposeCode(filterFactory.lessThan)(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN], guid);
+            return withComposeCode(filterFactory.lessThan, 'lessThan')(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN], { guid });
         case ConditionFilterType.LESS_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.lessThanOrEqual)(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL], guid);
+            return withComposeCode(filterFactory.lessThanOrEqual, 'lessThanOrEqual')(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL], { guid });
         case ConditionFilterType.BETWEEN:
-            return withComposeCode(filterFactory.between)(attribute, conditionFilterJaql.from, conditionFilterJaql.to, guid);
+            return withComposeCode(filterFactory.between, 'between')(attribute, conditionFilterJaql.from, conditionFilterJaql.to, { guid });
         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, guid), undefined, guid);
+            return withComposeCode(filterFactory.exclude, 'exclude')(withComposeCode(filterFactory.between, 'between')(attribute, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to, { guid }), undefined, { guid });
         case ConditionFilterType.MULTIPLE_CONDITION:
             if (conditionFilterJaql.and) {
-                return withComposeCode(filterFactory.intersection)(conditionFilterJaql.and.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), guid);
+                return withComposeCode(filterFactory.intersection, 'intersection')(conditionFilterJaql.and.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), { guid });
             }
             if (conditionFilterJaql.or) {
-                return withComposeCode(filterFactory.union)(conditionFilterJaql.or.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), guid);
+                return withComposeCode(filterFactory.union, 'union')(conditionFilterJaql.or.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), { guid });
             }
             break;
         case ConditionFilterType.IS_NOT: {
@@ -136,7 +137,13 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
                 [];
             const selectedMembers = ((_f = (_e = conditionFilterJaql.exclude) === null || _e === void 0 ? void 0 : _e.members) === null || _f === void 0 ? void 0 : _f.filter((member) => !deactivatedMembers.includes(member))) || [];
             // use members filter with exclude instead of exclude filter
-            return withComposeCode(filterFactory.members)(attribute, selectedMembers, true, guid, deactivatedMembers, undefined, conditionFilterJaql.multiSelection);
+            const config = simplifyFilterConfig({
+                guid,
+                excludeMembers: true,
+                enableMultiSelection: (_g = conditionFilterJaql.multiSelection) !== null && _g !== void 0 ? _g : true,
+                deactivatedMembers,
+            });
+            return withComposeCode(filterFactory.members, 'members')(attribute, selectedMembers, config);
         }
         case ConditionFilterType.AFTER:
         case ConditionFilterType.BEFORE:
@@ -154,24 +161,24 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
  *
  * @param measure - Provided measure
  * @param conditionFilterJaql - Condition filter JAQL object
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns measure filter
  */
 export const createMeasureFilterFromConditionFilterJaql = (measure, conditionFilterJaql, guid) => {
     const conditionType = getSelectedConditionOption(conditionFilterJaql);
     switch (conditionType) {
         case ConditionFilterType.EQUALS:
-            return withComposeCode(filterFactory.measureEquals)(measure, conditionFilterJaql[ConditionFilterType.EQUALS], guid);
+            return withComposeCode(filterFactory.measureEquals, 'measureEquals')(measure, conditionFilterJaql[ConditionFilterType.EQUALS], { guid });
         case ConditionFilterType.GREATER_THAN:
-            return withComposeCode(filterFactory.measureGreaterThan)(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN], guid);
+            return withComposeCode(filterFactory.measureGreaterThan, 'measureGreaterThan')(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN], { guid });
         case ConditionFilterType.GREATER_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.measureGreaterThanOrEqual)(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], guid);
+            return withComposeCode(filterFactory.measureGreaterThanOrEqual, 'measureGreaterThanOrEqual')(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], { guid });
         case ConditionFilterType.LESS_THAN:
-            return withComposeCode(filterFactory.measureLessThan)(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN], guid);
+            return withComposeCode(filterFactory.measureLessThan, 'measureLessThan')(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN], { guid });
         case ConditionFilterType.LESS_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.measureLessThanOrEqual)(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL], guid);
+            return withComposeCode(filterFactory.measureLessThanOrEqual, 'measureLessThanOrEqual')(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL], { guid });
         case ConditionFilterType.BETWEEN:
-            return withComposeCode(filterFactory.measureBetween)(measure, conditionFilterJaql.from, conditionFilterJaql.to, guid);
+            return withComposeCode(filterFactory.measureBetween, 'measureBetween')(measure, conditionFilterJaql.from, conditionFilterJaql.to, { guid });
     }
     throw new TranslatableError('errors.filter.unsupportedConditionFilter', {
         filter: JSON.stringify(conditionFilterJaql),

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

@@ -1,13 +1,17 @@
 /**
- * Stringifies the argument
+ * Stringifies the argument, with an option to exclude specific properties.
  *
- * @param arg - argument to stringify
- * @returns stringified argument
+ * @param arg - The argument to stringify.
+ * @param excludeProps - Optional array of property names to exclude when stringifying objects.
+ * @returns The stringified representation of the argument.
  */
-export declare function stringifyHelper(arg: any): string;
+export declare function stringifyHelper(arg: any, excludeProps?: string[]): string;
 /**
  * High order function to construct compose code for filter factory functions
  *
  * @param func - filter factory function
+ * @param funcName - name of the filter factory function. Needed if the function name is minified.
+ * @param ignoreIndexes - Indexes of parameters to ignore in the generated composeCode
+ * @returns filter factory function with composeCode property added to the filter
  */
-export declare function withComposeCode(func: (...args: any[]) => any): (...args: any[]) => any;
+export declare function withComposeCode<T extends (...args: any[]) => any>(func: T, funcName?: string, ignoreIndexes?: number[]): T;

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

@@ -1,10 +1,11 @@
 /**
- * Stringifies the argument
+ * Stringifies the argument, with an option to exclude specific properties.
  *
- * @param arg - argument to stringify
- * @returns stringified argument
+ * @param arg - The argument to stringify.
+ * @param excludeProps - Optional array of property names to exclude when stringifying objects.
+ * @returns The stringified representation of the argument.
  */
-export function stringifyHelper(arg) {
+export function stringifyHelper(arg, excludeProps = []) {
     try {
         if (arg === null || arg === undefined) {
             return JSON.stringify(arg);
@@ -16,7 +17,7 @@ export function stringifyHelper(arg) {
             return ('[' +
                 arg
                     .map((e) => {
-                    return stringifyHelper(e);
+                    return stringifyHelper(e, excludeProps);
                 })
                     .join(', ') +
                 ']');
@@ -27,6 +28,19 @@ export function stringifyHelper(arg) {
         if (typeof arg === 'number' || !isNaN(arg)) {
             return arg;
         }
+        if (typeof arg === 'object') {
+            const filteredObject = Object.keys(arg)
+                .filter((key) => !excludeProps.includes(key))
+                .reduce((acc, key) => {
+                acc[key] = arg[key];
+                return acc;
+            }, {});
+            // Check if the filtered object is empty
+            if (Object.keys(filteredObject).length === 0) {
+                return '';
+            }
+            return JSON.stringify(filteredObject);
+        }
     }
     catch (e) {
         console.error(e);
@@ -37,16 +51,26 @@ export function stringifyHelper(arg) {
  * High order function to construct compose code for filter factory functions
  *
  * @param func - filter factory function
+ * @param funcName - name of the filter factory function. Needed if the function name is minified.
+ * @param ignoreIndexes - Indexes of parameters to ignore in the generated composeCode
+ * @returns filter factory function with composeCode property added to the filter
  */
-export function withComposeCode(func) {
+export function withComposeCode(func, funcName, ignoreIndexes = []) {
     return function (...args) {
         const argValues = args
-            .map(stringifyHelper)
+            .map((arg, index) => {
+            if (ignoreIndexes.includes(index)) {
+                return ''; // Placeholder for ignored parameters
+            }
+            return stringifyHelper(arg, ['guid']);
+        })
             .join(', ')
             // remove any number of trailing commas
             .replace(/(,\s*)+$/, '');
-        const signature = `filterFactory.${func.name}(${argValues})`;
+        const signature = `filterFactory.${funcName !== null && funcName !== void 0 ? funcName : func.name}(${argValues})`;
+        // Call the original function and get the filter
         const filter = func(...args);
+        // Add the composeCode property
         filter.composeCode = signature;
         return filter;
     };

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

@@ -1,5 +1,5 @@
-import { BaseFilterJaql, ConditionFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
-import { Attribute, BaseMeasure, Filter, LevelAttribute } from '../../interfaces.js';
+import { BaseFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
+import { Attribute, 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.
@@ -8,75 +8,65 @@ import { FilterJaql } from '../../types.js';
  * @param guid - Optional GUID for the filter
  * @returns A generic Filter object.
  */
-export declare const createGenericFilter: (jaql: FilterJaql | FilterJaqlInternal, guid?: string) => Filter;
+export declare const createGenericFilter: (jaql: FilterJaql | FilterJaqlInternal, guid: string) => Filter;
 /**
  * Creates a filter that includes all members of the attribute.
  *
  * @param attribute - The attribute.
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns The created Filter object.
  */
-export declare const createFilterIncludeAll: (attribute: Attribute, guid?: string) => Filter;
+export declare const createFilterIncludeAll: (attribute: Attribute, guid: string) => Filter;
 /**
  * Creates a filter from a specific items filter JAQL object.
  *
  * @param attribute - attribute
  * @param specificItemsFilterJaql - Specific Items Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql, guid?: string, multiSelection?: boolean) => Filter;
+export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql, guid: string, multiSelection?: boolean) => Filter;
 /**
  * Creates a filter from a date range filter JAQL object.
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromDateRangeFilterJaql: (attribute: LevelAttribute, rangeFilterJaql: RangeFilterJaql, guid?: string) => Filter;
+export declare const createFilterFromDateRangeFilterJaql: (attribute: LevelAttribute, rangeFilterJaql: RangeFilterJaql, guid: string) => Filter;
 /**
  * Creates a filter from a numeric range filter JAQL object.
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromNumericRangeJaql: (attribute: Attribute, rangeFilterJaql: RangeFilterJaql, guid?: string) => Filter;
+export declare const createFilterFromNumericRangeJaql: (attribute: Attribute, rangeFilterJaql: RangeFilterJaql, guid: string) => Filter;
 /**
  * Creates a filter from a period filter JAQL object.
  *
  * @param attribute - attribute
  * @param periodFilterJaql - Period Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromPeriodFilterJaql: (attribute: LevelAttribute, periodFilterJaql: PeriodFilterJaql, guid?: string) => Filter;
-/**
- * Creates a filter from a condition filter JAQL object.
- *
- * @param attribute - attribute
- * @param conditionFilterJaql - Condition Filter Jaql
- * @param measure - measure
- * @param guid - Optional GUID for the filter
- * @returns Filter object
- */
-export declare const createFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql, measure?: BaseMeasure, guid?: string) => Filter;
+export declare const createFilterFromPeriodFilterJaql: (attribute: LevelAttribute, periodFilterJaql: PeriodFilterJaql, guid: string) => Filter;
 /**
  * Creates a filter from a custom filter JAQL object.
  *
  * @param attribute - attribute
  * @param customFilterJaql - Custom Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromCustomFilterJaql: (attribute: Attribute, customFilterJaql: BaseFilterJaql, guid?: string) => Filter;
+export declare const createFilterFromCustomFilterJaql: (attribute: Attribute, customFilterJaql: BaseFilterJaql, guid: string) => Filter;
 /**
  * Creates a filter from a filter JAQL object.
  *
  * @param jaql - The filter JAQL object.
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object.
  */
-export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, guid?: string) => Filter;
+export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, guid: string) => Filter;

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

@@ -4,8 +4,8 @@ import { createAttributeFilterFromConditionFilterJaql, createMeasureFilterFromCo
 import { extractFilterTypeFromFilterJaql } from './filter-types-util.js';
 import { withComposeCode } from './filter-code-util.js';
 import { createAttributeFromFilterJaql, createMeasureFromFilterJaql, } from './attribute-measure-util.js';
-import { guidFast } from '../../../utils.js';
 import { TranslatableError } from '../../../translation/translatable-error.js';
+import { getDefaultBaseFilterConfig, simplifyFilterConfig } from '../filter-config-utils.js';
 /**
  * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
  *
@@ -15,7 +15,7 @@ import { TranslatableError } from '../../../translation/translatable-error.js';
  */
 export const createGenericFilter = (jaql, guid) => {
     return {
-        guid: guid || guidFast(13),
+        config: Object.assign(Object.assign({}, getDefaultBaseFilterConfig()), { guid, originalFilterJaql: jaql }),
         jaql: (nested) => {
             if (nested) {
                 return jaql;
@@ -41,31 +41,40 @@ export const createGenericFilter = (jaql, guid) => {
  * Creates a filter that includes all members of the attribute.
  *
  * @param attribute - The attribute.
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns The created Filter object.
  */
 export const createFilterIncludeAll = (attribute, guid) => {
     // including all members is equivalent to excluding none
     // so we can simply create a filter with no members and excludeMembers set to true
-    return withComposeCode(filterFactory.members)(attribute, [], true, guid);
+    const config = {
+        guid,
+        excludeMembers: true,
+    };
+    return withComposeCode(filterFactory.members, 'members')(attribute, [], config);
 };
 /**
  * Creates a filter from a specific items filter JAQL object.
  *
  * @param attribute - attribute
  * @param specificItemsFilterJaql - Specific Items Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
 export const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJaql, guid, multiSelection) => {
     const deactivatedMembers = getDeactivatedMembersFromFilterJaql(specificItemsFilterJaql);
     const activeMembers = getActiveMembersFromFilterJaql(specificItemsFilterJaql, deactivatedMembers);
-    return withComposeCode(filterFactory.members)(attribute, activeMembers, undefined, // use undefined instead of false to avoid including the property in composeCode
-    guid, deactivatedMembers, undefined, multiSelection);
+    const config = simplifyFilterConfig({
+        guid,
+        excludeMembers: false,
+        enableMultiSelection: multiSelection !== null && multiSelection !== void 0 ? multiSelection : true,
+        deactivatedMembers,
+    });
+    return withComposeCode(filterFactory.members, 'members')(attribute, activeMembers, config);
 };
 function getDeactivatedMembersFromFilterJaql(filterJaql) {
-    var _a, _b, _c;
-    return ((_a = filterJaql.filter) === null || _a === void 0 ? void 0 : _a.turnedOff) ? (_c = (_b = filterJaql.filter) === null || _b === void 0 ? void 0 : _b.exclude) === null || _c === void 0 ? void 0 : _c.members : undefined;
+    var _a, _b, _c, _d;
+    return ((_a = filterJaql.filter) === null || _a === void 0 ? void 0 : _a.turnedOff) ? (_d = (_c = (_b = filterJaql.filter) === null || _b === void 0 ? void 0 : _b.exclude) === null || _c === void 0 ? void 0 : _c.members) !== null && _d !== void 0 ? _d : [] : [];
 }
 function getActiveMembersFromFilterJaql(filterJaql, deactivatedMembers) {
     const allMembers = filterJaql.members;
@@ -78,54 +87,37 @@ function getActiveMembersFromFilterJaql(filterJaql, deactivatedMembers) {
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
 export const createFilterFromDateRangeFilterJaql = (attribute, rangeFilterJaql, guid) => {
-    return withComposeCode(filterFactory.dateRange)(attribute, rangeFilterJaql.from, rangeFilterJaql.to, guid);
+    return withComposeCode(filterFactory.dateRange, 'dateRange')(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
 };
 /**
  * Creates a filter from a numeric range filter JAQL object.
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
 export const createFilterFromNumericRangeJaql = (attribute, rangeFilterJaql, guid) => {
-    return withComposeCode(filterFactory.between)(attribute, rangeFilterJaql.from, rangeFilterJaql.to, guid);
+    return withComposeCode(filterFactory.between, 'between')(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
 };
 /**
  * Creates a filter from a period filter JAQL object.
  *
  * @param attribute - attribute
  * @param periodFilterJaql - Period Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
 export const createFilterFromPeriodFilterJaql = (attribute, periodFilterJaql, guid) => {
     if (periodFilterJaql.last) {
-        return withComposeCode(filterFactory.dateRelativeTo)(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor, guid);
-    }
-    else {
-        return withComposeCode(filterFactory.dateRelativeFrom)(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor, guid);
-    }
-};
-/**
- * Creates a filter from a condition filter JAQL object.
- *
- * @param attribute - attribute
- * @param conditionFilterJaql - Condition Filter Jaql
- * @param measure - measure
- * @param guid - Optional GUID for the filter
- * @returns Filter object
- */
-export const createFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, measure, guid) => {
-    if (measure) {
-        return createMeasureFilterFromConditionFilterJaql(measure, conditionFilterJaql, guid);
+        return withComposeCode(filterFactory.dateRelativeTo, 'dateRelativeTo')(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor, { guid });
     }
     else {
-        return createAttributeFilterFromConditionFilterJaql(attribute, conditionFilterJaql, guid);
+        return withComposeCode(filterFactory.dateRelativeFrom, 'dateRelativeFrom')(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor, { guid });
     }
 };
 /**
@@ -133,17 +125,19 @@ export const createFilterFromConditionFilterJaql = (attribute, conditionFilterJa
  *
  * @param attribute - attribute
  * @param customFilterJaql - Custom Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
 export const createFilterFromCustomFilterJaql = (attribute, customFilterJaql, guid) => {
-    return withComposeCode(filterFactory.customFilter)(attribute, customFilterJaql, guid);
+    return withComposeCode(filterFactory.customFilter, 'customFilter')(attribute, customFilterJaql, {
+        guid,
+    });
 };
 /**
  * Creates a filter from a filter JAQL object.
  *
  * @param jaql - The filter JAQL object.
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object.
  */
 export const createFilterFromJaqlInternal = (jaql, guid) => {
@@ -165,7 +159,12 @@ export const createFilterFromJaqlInternal = (jaql, guid) => {
             case FILTER_TYPES.SPECIFIC_ITEMS:
                 return createFilterFromSpecificItemsFilterJaql(attribute, filterJaqlWithType, guid, filterJaqlWithType.multiSelection);
             case FILTER_TYPES.CONDITION:
-                return createFilterFromConditionFilterJaql(attribute, filterJaqlWithType, measure, guid);
+                if (measure) {
+                    return createMeasureFilterFromConditionFilterJaql(measure, filterJaqlWithType, guid);
+                }
+                else {
+                    return createAttributeFilterFromConditionFilterJaql(attribute, filterJaqlWithType, guid);
+                }
             case FILTER_TYPES.DATE_RANGE:
                 return createFilterFromDateRangeFilterJaql(attribute, filterJaqlWithType, guid);
             case FILTER_TYPES.PERIOD: