@sisense/sdk-data 1.24.0 → 1.25.0

package/dist/dimensional-model/filters/filter-config-utils.js

@@ -0,0 +1,39 @@
+import isEqual from 'lodash-es/isEqual.js';
+import { guidFast } from '../../utils.js';
+/**
+ * Returns a default configuration for a base filter.
+ * @internal
+ */
+export const getDefaultBaseFilterConfig = () => ({
+    guid: guidFast(13),
+    disabled: false,
+    locked: false,
+});
+/**
+ * Returns a default configuration for a members filter.
+ * @internal
+ */
+export const getDefaultMembersFilterConfig = () => (Object.assign(Object.assign({}, getDefaultBaseFilterConfig()), { excludeMembers: false, enableMultiSelection: true, deactivatedMembers: [] }));
+/**
+ * Checks whether the given configuration is a members filter configuration.
+ * @param config - The filter configuration.
+ * @returns Whether the configuration is a members filter configuration.
+ * @internal
+ */
+export function isMembersFilterConfig(config) {
+    return 'excludeMembers' in config;
+}
+/**
+ * Simplifies the filter configuration by removing default values.
+ * @param config - The filter configuration.
+ * @returns The simplified filter configuration.
+ * @internal
+ */
+export const simplifyFilterConfig = (config) => {
+    const defaultConfig = isMembersFilterConfig(config)
+        ? getDefaultMembersFilterConfig()
+        : getDefaultBaseFilterConfig();
+    // Filter out properties that match their default values
+    const simplifiedConfig = Object.fromEntries(Object.entries(config).filter(([key, value]) => !isEqual(value, defaultConfig[key])));
+    return simplifiedConfig;
+};

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

@@ -1,4 +1,4 @@
-import { LevelAttribute, Attribute, Measure, Filter } from '../interfaces.js';
+import { LevelAttribute, Attribute, Measure, Filter, MembersFilterConfig, CompleteMembersFilterConfig, CompleteBaseFilterConfig, BaseFilterConfig } from '../interfaces.js';
 import { DimensionalElement } from '../base.js';
 import { AnyObject } from '../types.js';
 /**
@@ -92,26 +92,10 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
      */
     readonly filterType: string;
     /**
-     * Global filter identifier
+     * Filter configuration
      */
-    readonly guid: string;
-    private _disabled;
-    private _locked;
-    /**
-     * Boolean flag whether the filter is disabled
-     *
-     * @internal
-     */
-    get disabled(): boolean;
-    set disabled(value: boolean);
-    /**
-     * Boolean flag whether the filter is locked
-     *
-     * @internal
-     */
-    get locked(): boolean;
-    set locked(value: boolean);
-    constructor(att: Attribute, filterType: string, guid?: string);
+    config: CompleteBaseFilterConfig;
+    constructor(att: Attribute, filterType: string, config?: BaseFilterConfig);
     get name(): string;
     /**
      * Gets JAQL representing this Filter instance
@@ -144,7 +128,7 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
 export declare class LogicalAttributeFilter extends AbstractFilter {
     readonly filters: Filter[];
     readonly operator: string;
-    constructor(filters: Filter[], operator: string, guid?: string);
+    constructor(filters: Filter[], operator: string, config?: BaseFilterConfig);
     /**
      * gets the element's ID
      */
@@ -162,16 +146,9 @@ export declare class LogicalAttributeFilter extends AbstractFilter {
  * @internal
  */
 export declare class MembersFilter extends AbstractFilter {
-    readonly members: any[];
-    /** @internal */
-    excludeMembers: boolean;
-    /** @internal */
-    multiSelection: boolean;
-    /** @internal */
-    deactivatedMembers: any[];
-    /** @internal */
-    backgroundFilter?: Filter;
-    constructor(attribute: Attribute, members?: any[], excludeMembers?: boolean, guid?: string, deactivatedMembers?: any[], backgroundFilter?: Filter, multiSelection?: boolean);
+    readonly members: string[];
+    config: CompleteMembersFilterConfig;
+    constructor(attribute: Attribute, members?: string[], config?: MembersFilterConfig);
     /**
      * gets the element's ID
      */
@@ -190,15 +167,15 @@ export declare class MembersFilter extends AbstractFilter {
  */
 export declare class CascadingFilter extends AbstractFilter {
     readonly filters: Filter[];
-    constructor(filters: Filter[], guid?: string);
+    constructor(filters: Filter[], config?: BaseFilterConfig);
+    /**
+     * Propagates the parent config to all level filters
+     */
+    propagateConfig(): void;
     /**
      * gets the element's ID
      */
     get id(): string;
-    get disabled(): boolean;
-    set disabled(value: boolean);
-    get locked(): boolean;
-    set locked(value: boolean);
     /**
      * Gets a serializable representation of the element
      */
@@ -215,7 +192,7 @@ export declare class CascadingFilter extends AbstractFilter {
 export declare class ExcludeFilter extends AbstractFilter {
     readonly filter: Filter;
     readonly input?: Filter;
-    constructor(filter: Filter, input?: Filter, guid?: string);
+    constructor(filter: Filter, input?: Filter, config?: BaseFilterConfig);
     /**
      * gets the element's ID
      */
@@ -237,7 +214,7 @@ export declare class DoubleOperatorFilter<Type> extends AbstractFilter {
     operatorB?: string;
     valueA?: Type;
     valueB?: Type;
-    constructor(att: Attribute, filterType: string, operatorA?: string, valueA?: Type, operatorB?: string, valueB?: Type, guid?: string);
+    constructor(att: Attribute, filterType: string, operatorA?: string, valueA?: Type, operatorB?: string, valueB?: Type, config?: BaseFilterConfig);
     /**
      * gets the element's ID
      */
@@ -256,7 +233,7 @@ export declare class DoubleOperatorFilter<Type> extends AbstractFilter {
  */
 export declare class MeasureFilter extends DoubleOperatorFilter<number> {
     measure: Measure;
-    constructor(att: Attribute, measure: Measure, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number, guid?: string);
+    constructor(att: Attribute, measure: Measure, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number, config?: BaseFilterConfig);
     /**
      * gets the element's ID
      */
@@ -274,7 +251,7 @@ export declare class RankingFilter extends AbstractFilter {
     count: number;
     operator: string;
     measure: Measure;
-    constructor(att: Attribute, measure: Measure, operator: string, count: number, guid?: string);
+    constructor(att: Attribute, measure: Measure, operator: string, count: number, config?: BaseFilterConfig);
     /**
      * gets the element's ID
      */
@@ -292,19 +269,19 @@ export declare class RankingFilter extends AbstractFilter {
  * @internal
  */
 export declare class NumericFilter extends DoubleOperatorFilter<number> {
-    constructor(att: Attribute, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number, guid?: string);
+    constructor(att: Attribute, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number, config?: BaseFilterConfig);
 }
 /**
  * @internal
  */
 export declare class TextFilter extends DoubleOperatorFilter<string> {
-    constructor(att: Attribute, operator: string, value: string, guid?: string);
+    constructor(att: Attribute, operator: string, value: string, config?: BaseFilterConfig);
 }
 /**
  * @internal
  */
 export declare class DateRangeFilter extends DoubleOperatorFilter<Date | string> {
-    constructor(l: LevelAttribute, valueFrom?: Date | string, valueTo?: Date | string, guid?: string);
+    constructor(l: LevelAttribute, valueFrom?: Date | string, valueTo?: Date | string, config?: BaseFilterConfig);
     get level(): LevelAttribute;
     get from(): string;
     get to(): string;
@@ -321,7 +298,7 @@ export declare class RelativeDateFilter extends AbstractFilter {
     readonly count: number;
     readonly operator: typeof DateOperators.Last | typeof DateOperators.Next;
     readonly anchor?: Date | string;
-    constructor(l: LevelAttribute, offset: number, count: number, operator?: typeof DateOperators.Last | typeof DateOperators.Next, anchor?: Date | string, guid?: string);
+    constructor(l: LevelAttribute, offset: number, count: number, operator?: typeof DateOperators.Last | typeof DateOperators.Next, anchor?: Date | string, config?: BaseFilterConfig);
     get level(): LevelAttribute;
     /**
      * gets the element's ID
@@ -342,7 +319,7 @@ export declare class RelativeDateFilter extends AbstractFilter {
  */
 export declare class CustomFilter extends AbstractFilter {
     readonly jaqlExpression: any;
-    constructor(att: Attribute, jaql: any, guid?: string);
+    constructor(att: Attribute, jaql: any, config?: BaseFilterConfig);
     /**
      * gets the element's ID
      */

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

@@ -1,18 +1,11 @@
-/* eslint-disable max-lines */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* 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-params */
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
 import hash from 'hash-it';
 import { DimensionalElement } from '../base.js';
 import { DateLevels, MetadataTypes } from '../types.js';
 import { create } from '../factory.js';
 import { DimensionalBaseMeasure } from '../measures/measures.js';
 import { TranslatableError } from '../../translation/translatable-error.js';
-import { guidFast } from '../../utils.js';
+import { getDefaultBaseFilterConfig, getDefaultMembersFilterConfig, } from './filter-config-utils.js';
+import merge from 'lodash-es/merge.js';
 /**
  * Different text operators that can be used with text filters
  *
@@ -96,36 +89,12 @@ export const FilterTypes = {
  * @internal
  */
 class AbstractFilter extends DimensionalElement {
-    constructor(att, filterType, guid) {
+    constructor(att, filterType, config) {
         super('filter', MetadataTypes.Filter);
         this.filterType = filterType;
         AbstractFilter.checkAttributeSupport(att);
         this.attribute = att;
-        this.guid = guid || guidFast(13);
-        this.disabled = false;
-        this.locked = false;
-    }
-    /**
-     * Boolean flag whether the filter is disabled
-     *
-     * @internal
-     */
-    get disabled() {
-        return this._disabled;
-    }
-    set disabled(value) {
-        this._disabled = value;
-    }
-    /**
-     * Boolean flag whether the filter is locked
-     *
-     * @internal
-     */
-    get locked() {
-        return this._locked;
-    }
-    set locked(value) {
-        this._locked = value;
+        this.config = merge({}, getDefaultBaseFilterConfig(), config !== null && config !== void 0 ? config : {});
     }
     get name() {
         // to hexadecimal string
@@ -146,7 +115,7 @@ class AbstractFilter extends DimensionalElement {
      * @param nested - defines whether the JAQL is nested within parent JAQL statement or a root JAQL element
      */
     jaql(nested) {
-        if (this.disabled) {
+        if (this.config.disabled) {
             return AbstractFilter.disabledJaql(nested);
         }
         const result = this.attribute.jaql(false);
@@ -187,8 +156,8 @@ class AbstractFilter extends DimensionalElement {
  * @internal
  */
 export class LogicalAttributeFilter extends AbstractFilter {
-    constructor(filters, operator, guid) {
-        super(filters[0].attribute, FilterTypes.logicalAttribute, guid);
+    constructor(filters, operator, config) {
+        super(filters[0].attribute, FilterTypes.logicalAttribute, config);
         this.operator = operator;
         this.filters = filters;
     }
@@ -220,18 +189,17 @@ export class LogicalAttributeFilter extends AbstractFilter {
  * @internal
  */
 export class MembersFilter extends AbstractFilter {
-    constructor(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter, multiSelection = true) {
-        super(attribute, FilterTypes.members, guid);
+    constructor(attribute, members, config) {
+        super(attribute, FilterTypes.members);
         this.members = members !== null && members !== void 0 ? members : [];
-        this.excludeMembers = excludeMembers !== null && excludeMembers !== void 0 ? excludeMembers : false;
-        this.multiSelection = multiSelection;
-        this.deactivatedMembers = deactivatedMembers !== null && deactivatedMembers !== void 0 ? deactivatedMembers : [];
-        this.backgroundFilter = backgroundFilter;
         if (this.members.filter((m) => m === null || m === undefined).length > 0) {
             throw new TranslatableError('errors.filter.membersFilterNullMember', {
                 attributeId: attribute.id,
             });
         }
+        // merge default config and input config into a new object
+        // to avoid mutation
+        this.config = merge({}, getDefaultMembersFilterConfig(), config !== null && config !== void 0 ? config : {});
     }
     /**
      * gets the element's ID
@@ -245,9 +213,6 @@ export class MembersFilter extends AbstractFilter {
     serializable() {
         const result = super.serializable();
         result.members = this.members;
-        if (this.backgroundFilter) {
-            result.backgroundFilter = this.backgroundFilter.serializable();
-        }
         return result;
     }
     /**
@@ -257,10 +222,12 @@ export class MembersFilter extends AbstractFilter {
         const membersFilterJaql = {
             members: this.members.map((m) => m.toString()),
         };
-        const filterJaql = this.excludeMembers ? { exclude: membersFilterJaql } : membersFilterJaql;
-        if (this.backgroundFilter) {
+        const filterJaql = this.config.excludeMembers
+            ? { exclude: membersFilterJaql }
+            : membersFilterJaql;
+        if (this.config.backgroundFilter) {
             return {
-                and: [filterJaql, this.backgroundFilter.filterJaql()],
+                and: [filterJaql, this.config.backgroundFilter.filterJaql()],
             };
         }
         return filterJaql;
@@ -270,9 +237,20 @@ export class MembersFilter extends AbstractFilter {
  * @internal
  */
 export class CascadingFilter extends AbstractFilter {
-    constructor(filters, guid) {
-        super(filters[0].attribute, FilterTypes.cascading, guid);
+    constructor(filters, config) {
+        super(filters[0].attribute, FilterTypes.cascading, config);
         this.filters = filters;
+        this.propagateConfig();
+    }
+    /**
+     * Propagates the parent config to all level filters
+     */
+    propagateConfig() {
+        const { disabled, locked } = this.config;
+        this.filters.forEach((f) => {
+            f.config.disabled = disabled;
+            f.config.locked = locked;
+        });
     }
     /**
      * gets the element's ID
@@ -280,28 +258,6 @@ export class CascadingFilter extends AbstractFilter {
     get id() {
         return `${this.filterType}_${this.filters.map((f) => f.id).join()}`;
     }
-    get disabled() {
-        return super.disabled;
-    }
-    set disabled(value) {
-        super.disabled = value;
-        if (this.filters) {
-            this.filters.forEach((filter) => {
-                filter.disabled = value;
-            });
-        }
-    }
-    get locked() {
-        return super.locked;
-    }
-    set locked(value) {
-        super.locked = value;
-        if (this.filters) {
-            this.filters.forEach((filter) => {
-                filter.locked = value;
-            });
-        }
-    }
     /**
      * Gets a serializable representation of the element
      */
@@ -318,7 +274,7 @@ export class CascadingFilter extends AbstractFilter {
         return {};
     }
     jaql(nested) {
-        if (this.disabled) {
+        if (this.config.disabled) {
             return AbstractFilter.disabledJaql(nested);
         }
         // return jaql of all level filters treated as scope filters
@@ -332,8 +288,8 @@ export class CascadingFilter extends AbstractFilter {
  * @internal
  */
 export class ExcludeFilter extends AbstractFilter {
-    constructor(filter, input, guid) {
-        super(filter.attribute, FilterTypes.exclude, guid);
+    constructor(filter, input, config) {
+        super(filter.attribute, FilterTypes.exclude, config);
         this.input = input;
         this.filter = filter;
     }
@@ -378,8 +334,8 @@ export class ExcludeFilter extends AbstractFilter {
  * @internal
  */
 export class DoubleOperatorFilter extends AbstractFilter {
-    constructor(att, filterType, operatorA, valueA, operatorB, valueB, guid) {
-        super(att, filterType, guid);
+    constructor(att, filterType, operatorA, valueA, operatorB, valueB, config) {
+        super(att, filterType, config);
         if (operatorA && valueA !== undefined) {
             this.valueA = valueA;
             this.operatorA = operatorA;
@@ -439,8 +395,8 @@ export class DoubleOperatorFilter extends AbstractFilter {
  * @internal
  */
 export class MeasureFilter extends DoubleOperatorFilter {
-    constructor(att, measure, operatorA, valueA, operatorB, valueB, guid) {
-        super(att, FilterTypes.measure, operatorA, valueA, operatorB, valueB, guid);
+    constructor(att, measure, operatorA, valueA, operatorB, valueB, config) {
+        super(att, FilterTypes.measure, operatorA, valueA, operatorB, valueB, config);
         this.measure = measure;
     }
     /**
@@ -465,7 +421,7 @@ export class MeasureFilter extends DoubleOperatorFilter {
         return result;
     }
     jaql(nested) {
-        if (this.disabled) {
+        if (this.config.disabled) {
             return AbstractFilter.disabledJaql(nested);
         }
         const result = super.jaql(nested);
@@ -481,8 +437,8 @@ export class MeasureFilter extends DoubleOperatorFilter {
  * @internal
  */
 export class RankingFilter extends AbstractFilter {
-    constructor(att, measure, operator, count, guid) {
-        super(att, FilterTypes.ranking, guid);
+    constructor(att, measure, operator, count, config) {
+        super(att, FilterTypes.ranking, config);
         this.count = count;
         this.operator = operator;
         this.measure = measure;
@@ -517,24 +473,24 @@ export class RankingFilter extends AbstractFilter {
  * @internal
  */
 export class NumericFilter extends DoubleOperatorFilter {
-    constructor(att, operatorA, valueA, operatorB, valueB, guid) {
-        super(att, FilterTypes.numeric, operatorA, valueA, operatorB, valueB, guid);
+    constructor(att, operatorA, valueA, operatorB, valueB, config) {
+        super(att, FilterTypes.numeric, operatorA, valueA, operatorB, valueB, config);
     }
 }
 /**
  * @internal
  */
 export class TextFilter extends DoubleOperatorFilter {
-    constructor(att, operator, value, guid) {
-        super(att, FilterTypes.text, operator, value, undefined, undefined, guid);
+    constructor(att, operator, value, config) {
+        super(att, FilterTypes.text, operator, value, undefined, undefined, config);
     }
 }
 /**
  * @internal
  */
 export class DateRangeFilter extends DoubleOperatorFilter {
-    constructor(l, valueFrom, valueTo, guid) {
-        super(l, FilterTypes.dateRange, DateOperators.From, valueFrom, DateOperators.To, valueTo, guid);
+    constructor(l, valueFrom, valueTo, config) {
+        super(l, FilterTypes.dateRange, DateOperators.From, valueFrom, DateOperators.To, valueTo, config);
         if (typeof valueFrom === 'object') {
             this.valueA = valueFrom.toISOString();
         }
@@ -562,8 +518,8 @@ export class DateRangeFilter extends DoubleOperatorFilter {
  * @internal
  */
 export class RelativeDateFilter extends AbstractFilter {
-    constructor(l, offset, count, operator, anchor, guid) {
-        super(l, FilterTypes.relativeDate, guid);
+    constructor(l, offset, count, operator, anchor, config) {
+        super(l, FilterTypes.relativeDate, config);
         if (!operator) {
             operator = DateOperators.Next;
         }
@@ -628,8 +584,8 @@ export class RelativeDateFilter extends AbstractFilter {
  * @internal
  */
 export class CustomFilter extends AbstractFilter {
-    constructor(att, jaql, guid) {
-        super(att, FilterTypes.advanced, guid);
+    constructor(att, jaql, config) {
+        super(att, FilterTypes.advanced, config);
         // remove filterType from jaql as it is not needed
         delete jaql.filterType;
         this.jaqlExpression = jaql;
@@ -638,7 +594,7 @@ export class CustomFilter extends AbstractFilter {
      * gets the element's ID
      */
     get id() {
-        return `custom_${this.attribute.id}_${this.guid}`;
+        return `custom_${this.attribute.id}_${this.config.guid}`;
     }
     /**
      * Gets JAQL representing this Filter instance

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

@@ -6,16 +6,16 @@ export declare const getSelectedConditionOption: (filter: ConditionFilterJaql) =
  *
  * @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 declare const createAttributeFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql, guid?: string) => Filter;
+export declare const createAttributeFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql, guid: string) => Filter;
 /**
  * Creates a measure filter from the provided measure and condition filter JAQL object
  *
  * @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 declare const createMeasureFilterFromConditionFilterJaql: (measure: BaseMeasure, conditionFilterJaql: ConditionFilterJaql, guid?: string) => Filter;
+export declare const createMeasureFilterFromConditionFilterJaql: (measure: BaseMeasure, conditionFilterJaql: ConditionFilterJaql, guid: string) => Filter;

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),