@sisense/sdk-data 2.12.0 → 2.14.0

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

@@ -721,6 +721,146 @@ export declare const topRanking: (attribute: Attribute, measure: Measure, count:
  * @returns A filter instance
  */
 export declare const bottomRanking: (attribute: Attribute, measure: Measure, count: number, config?: BaseFilterConfig) => Filter;
+/**
+ * Creates a filter that returns the top N values of the last dimension,
+ * independently for each unique combination of all preceding dimensions.
+ *
+ * This filter applies ranking within groups rather than globally. It shows the top N values
+ * of the rightmost dimension for every unique combination of the other dimensions to its left.
+ * The order of dimensions in your query determines the grouping behavior.
+ *
+ * **Key Differences from {@link topRanking}:**
+ * - `topRanking`: Filters a specific dimension globally (you specify which dimension)
+ * - `measureTopRanking`: Always filters the last/rightmost dimension, grouped by all others
+ *
+ * **How it works:**
+ * - With 1 dimension: Returns the top N values of that dimension
+ * - With 2+ dimensions: Returns the top N values of the LAST dimension for each combination of the others
+ *
+ * @example
+ * **Example 1: Single dimension (equivalent to topRanking) - Query with one dimension [Category]**
+ * ```ts
+ * // Returns top 5 Categories by total revenue
+ * filterFactory.measureTopRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   5
+ * )
+ * ```
+ * Result: 5 categories (e.g., Cell Phones, Computers, TVs, etc.)
+ *
+ * This produces the same result as:
+ * ```ts
+ * filterFactory.topRanking(
+ *   DM.Commerce.Category,
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   5
+ * )
+ * ```
+ *
+ * **Note:** With only one dimension, there are no groups to rank within,
+ * so the behavior is identical to `topRanking`.
+ *
+ * @example
+ * **Example 2: Two dimensions - Query with dimensions [Gender, Category]**
+ * ```ts
+ * // Returns top 2 Categories for each Gender
+ * filterFactory.measureTopRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   2
+ * )
+ * ```
+ * Result: 3 genders × 2 categories each = 6 rows
+ * - Male: Top 2 categories by revenue
+ * - Female: Top 2 categories by revenue
+ * - Unspecified: Top 2 categories by revenue
+ *
+ * @example
+ * **Example 3: Three dimensions - Query with dimensions [Gender, Age Range, Category]**
+ * ```ts
+ * // Returns top 2 Categories for each (Gender, Age Range) combination
+ * filterFactory.measureTopRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   2
+ * )
+ * ```
+ * Result: 3 genders × 7 age ranges × 2 categories per combination = ~42 rows
+ *
+ * @param measure - Base measure to rank by
+ * @param count - Number of items to return per group (applies to the last dimension)
+ * @param config - Optional configuration for the filter
+ * @returns A filter instance
+ */
+export declare const measureTopRanking: (measure: BaseMeasure, count: number, config?: BaseFilterConfig) => Filter;
+/**
+ * Creates a filter that returns the bottom N values of the last dimension,
+ * independently for each unique combination of all preceding dimensions.
+ *
+ * This filter applies ranking within groups rather than globally. It shows the bottom N values
+ * of the rightmost dimension for every unique combination of the other dimensions to its left.
+ * The order of dimensions in your query determines the grouping behavior.
+ *
+ * **Key Differences from {@link bottomRanking}:**
+ * - `bottomRanking`: Filters a specific dimension globally (you specify which dimension)
+ * - `measureBottomRanking`: Always filters the last/rightmost dimension, grouped by all others
+ *
+ * **How it works:**
+ * - With 1 dimension: Returns the bottom N values of that dimension
+ * - With 2+ dimensions: Returns the bottom N values of the LAST dimension for each combination of the others
+ *
+ * @example
+ * **Example 1: Single dimension (equivalent to bottomRanking) - Query with one dimension [Category]**
+ * ```ts
+ * // Returns bottom 5 Categories by revenue
+ * filterFactory.measureBottomRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   5
+ * )
+ * ```
+ * Result: 5 categories with lowest revenue (e.g., Accessories, Cables, etc.)
+ *
+ * This produces the same result as:
+ * ```ts
+ * filterFactory.bottomRanking(
+ *   DM.Commerce.Category,
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   5
+ * )
+ * ```
+ *
+ * **Note:** With only one dimension, there are no groups to rank within,
+ * so the behavior is identical to `bottomRanking`.
+ *
+ * @example
+ * **Example 2: Two dimensions - Query with dimensions [Gender, Category]**
+ * ```ts
+ * // Returns bottom 2 Categories for each Gender
+ * filterFactory.measureBottomRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   2
+ * )
+ * ```
+ * Result: 3 genders × 2 categories each = 6 rows
+ * - Male: Bottom 2 categories by revenue
+ * - Female: Bottom 2 categories by revenue
+ * - Unspecified: Bottom 2 categories by revenue
+ *
+ * @example
+ * **Example 3: Three dimensions - Query with dimensions [Gender, Age Range, Category]**
+ * ```ts
+ * // Returns bottom 2 Categories for each (Gender, Age Range) combination
+ * filterFactory.measureBottomRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   2
+ * )
+ * ```
+ * Result: 3 genders × 7 age ranges × 2 categories per combination = ~42 rows
+ *
+ * @param measure - Base measure to rank by
+ * @param count - Number of items to return per group (applies to the last dimension)
+ * @param config - Optional configuration for the filter
+ * @returns A filter instance
+ */
+export declare const measureBottomRanking: (measure: BaseMeasure, count: number, config?: BaseFilterConfig) => Filter;
 /**
  * Creates a filter that contains a list of dependent/cascading filters,
  * where each filter depends on the results or state of the previous ones in the array.

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

@@ -1,7 +1,7 @@
 "use strict";
 /* eslint-disable max-lines */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.customFilter = exports.logic = exports.cascading = exports.bottomRanking = exports.topRanking = exports.measureBetweenNotEqual = exports.measureBetween = exports.measureLessThan = exports.measureLessThanOrEqual = exports.measureGreaterThanOrEqual = exports.measureGreaterThan = exports.measureEquals = exports.measureBase = exports.today = exports.thisQuarter = exports.thisMonth = exports.thisYear = exports.dateRelativeTo = exports.dateRelativeFrom = exports.dateRelative = exports.dateRange = exports.dateTo = exports.dateFrom = exports.members = exports.numeric = exports.betweenNotEqual = exports.between = exports.lessThanOrEqual = exports.lessThan = exports.greaterThanOrEqual = exports.greaterThan = exports.equals = exports.doesntEqual = exports.like = exports.startsWith = exports.endsWith = exports.contains = exports.doesntStartWith = exports.doesntEndWith = exports.doesntContain = exports.exclude = exports.intersection = exports.union = void 0;
+exports.customFilter = exports.logic = exports.cascading = exports.measureBottomRanking = exports.measureTopRanking = exports.bottomRanking = exports.topRanking = exports.measureBetweenNotEqual = exports.measureBetween = exports.measureLessThan = exports.measureLessThanOrEqual = exports.measureGreaterThanOrEqual = exports.measureGreaterThan = exports.measureEquals = exports.measureBase = exports.today = exports.thisQuarter = exports.thisMonth = exports.thisYear = exports.dateRelativeTo = exports.dateRelativeFrom = exports.dateRelative = exports.dateRange = exports.dateTo = exports.dateFrom = exports.members = exports.numeric = exports.betweenNotEqual = exports.between = exports.lessThanOrEqual = exports.lessThan = exports.greaterThanOrEqual = exports.greaterThan = exports.equals = exports.doesntEqual = exports.like = exports.startsWith = exports.endsWith = exports.contains = exports.doesntStartWith = exports.doesntEndWith = exports.doesntContain = exports.exclude = exports.intersection = exports.union = void 0;
 /* eslint-disable max-params */
 /* eslint-disable @typescript-eslint/no-shadow */
 const compose_code_utils_js_1 = require("../compose-code-utils.js");
@@ -750,19 +750,146 @@ exports.topRanking = (0, compose_code_utils_js_1.withComposeCodeForFilter)((attr
  * @returns A filter instance
  */
 exports.bottomRanking = (0, compose_code_utils_js_1.withComposeCodeForFilter)((attribute, measure, count, config) => new filters_js_1.RankingFilter(attribute, measure, filters_js_1.RankingOperators.Bottom, count, config), 'bottomRanking');
-const relate = (node) => {
-    if (Array.isArray(node)) {
-        const [first, ...rest] = node;
-        return rest.length === 0
-            ? relate(first)
-            : {
-                operator: 'AND',
-                left: relate(first),
-                right: relate(rest),
-            };
-    }
-    return node;
-};
+/**
+ * Creates a filter that returns the top N values of the last dimension,
+ * independently for each unique combination of all preceding dimensions.
+ *
+ * This filter applies ranking within groups rather than globally. It shows the top N values
+ * of the rightmost dimension for every unique combination of the other dimensions to its left.
+ * The order of dimensions in your query determines the grouping behavior.
+ *
+ * **Key Differences from {@link topRanking}:**
+ * - `topRanking`: Filters a specific dimension globally (you specify which dimension)
+ * - `measureTopRanking`: Always filters the last/rightmost dimension, grouped by all others
+ *
+ * **How it works:**
+ * - With 1 dimension: Returns the top N values of that dimension
+ * - With 2+ dimensions: Returns the top N values of the LAST dimension for each combination of the others
+ *
+ * @example
+ * **Example 1: Single dimension (equivalent to topRanking) - Query with one dimension [Category]**
+ * ```ts
+ * // Returns top 5 Categories by total revenue
+ * filterFactory.measureTopRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   5
+ * )
+ * ```
+ * Result: 5 categories (e.g., Cell Phones, Computers, TVs, etc.)
+ *
+ * This produces the same result as:
+ * ```ts
+ * filterFactory.topRanking(
+ *   DM.Commerce.Category,
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   5
+ * )
+ * ```
+ *
+ * **Note:** With only one dimension, there are no groups to rank within,
+ * so the behavior is identical to `topRanking`.
+ *
+ * @example
+ * **Example 2: Two dimensions - Query with dimensions [Gender, Category]**
+ * ```ts
+ * // Returns top 2 Categories for each Gender
+ * filterFactory.measureTopRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   2
+ * )
+ * ```
+ * Result: 3 genders × 2 categories each = 6 rows
+ * - Male: Top 2 categories by revenue
+ * - Female: Top 2 categories by revenue
+ * - Unspecified: Top 2 categories by revenue
+ *
+ * @example
+ * **Example 3: Three dimensions - Query with dimensions [Gender, Age Range, Category]**
+ * ```ts
+ * // Returns top 2 Categories for each (Gender, Age Range) combination
+ * filterFactory.measureTopRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   2
+ * )
+ * ```
+ * Result: 3 genders × 7 age ranges × 2 categories per combination = ~42 rows
+ *
+ * @param measure - Base measure to rank by
+ * @param count - Number of items to return per group (applies to the last dimension)
+ * @param config - Optional configuration for the filter
+ * @returns A filter instance
+ */
+exports.measureTopRanking = (0, compose_code_utils_js_1.withComposeCodeForFilter)((measure, count, config) => new filters_js_1.MeasureRankingFilter(measure, filters_js_1.RankingOperators.Top, count, config), 'measureTopRanking');
+/**
+ * Creates a filter that returns the bottom N values of the last dimension,
+ * independently for each unique combination of all preceding dimensions.
+ *
+ * This filter applies ranking within groups rather than globally. It shows the bottom N values
+ * of the rightmost dimension for every unique combination of the other dimensions to its left.
+ * The order of dimensions in your query determines the grouping behavior.
+ *
+ * **Key Differences from {@link bottomRanking}:**
+ * - `bottomRanking`: Filters a specific dimension globally (you specify which dimension)
+ * - `measureBottomRanking`: Always filters the last/rightmost dimension, grouped by all others
+ *
+ * **How it works:**
+ * - With 1 dimension: Returns the bottom N values of that dimension
+ * - With 2+ dimensions: Returns the bottom N values of the LAST dimension for each combination of the others
+ *
+ * @example
+ * **Example 1: Single dimension (equivalent to bottomRanking) - Query with one dimension [Category]**
+ * ```ts
+ * // Returns bottom 5 Categories by revenue
+ * filterFactory.measureBottomRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   5
+ * )
+ * ```
+ * Result: 5 categories with lowest revenue (e.g., Accessories, Cables, etc.)
+ *
+ * This produces the same result as:
+ * ```ts
+ * filterFactory.bottomRanking(
+ *   DM.Commerce.Category,
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   5
+ * )
+ * ```
+ *
+ * **Note:** With only one dimension, there are no groups to rank within,
+ * so the behavior is identical to `bottomRanking`.
+ *
+ * @example
+ * **Example 2: Two dimensions - Query with dimensions [Gender, Category]**
+ * ```ts
+ * // Returns bottom 2 Categories for each Gender
+ * filterFactory.measureBottomRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   2
+ * )
+ * ```
+ * Result: 3 genders × 2 categories each = 6 rows
+ * - Male: Bottom 2 categories by revenue
+ * - Female: Bottom 2 categories by revenue
+ * - Unspecified: Bottom 2 categories by revenue
+ *
+ * @example
+ * **Example 3: Three dimensions - Query with dimensions [Gender, Age Range, Category]**
+ * ```ts
+ * // Returns bottom 2 Categories for each (Gender, Age Range) combination
+ * filterFactory.measureBottomRanking(
+ *   measureFactory.sum(DM.Commerce.Revenue),
+ *   2
+ * )
+ * ```
+ * Result: 3 genders × 7 age ranges × 2 categories per combination = ~42 rows
+ *
+ * @param measure - Base measure to rank by
+ * @param count - Number of items to return per group (applies to the last dimension)
+ * @param config - Optional configuration for the filter
+ * @returns A filter instance
+ */
+exports.measureBottomRanking = (0, compose_code_utils_js_1.withComposeCodeForFilter)((measure, count, config) => new filters_js_1.MeasureRankingFilter(measure, filters_js_1.RankingOperators.Bottom, count, config), 'measureBottomRanking');
 // CASCADING FILTERS
 /**
  * Creates a filter that contains a list of dependent/cascading filters,
@@ -819,6 +946,26 @@ exports.cascading = (0, compose_code_utils_js_1.withComposeCodeForFilter)((filte
 // eslint-disable-next-line @typescript-eslint/no-namespace
 var logic;
 (function (logic) {
+    /**
+     * Relates a filter or filter relations node
+     *
+     * @param node - Filter or filter relations node
+     * @returns Related filter or filter relations node
+     * @internal
+     */
+    const relate = (node) => {
+        if (Array.isArray(node)) {
+            const [first, ...rest] = node;
+            return rest.length === 0
+                ? relate(first)
+                : {
+                    operator: 'AND',
+                    left: relate(first),
+                    right: relate(rest),
+                };
+        }
+        return node;
+    };
     /**
      * Creates an 'AND' filter relations
      *

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

@@ -1,5 +1,5 @@
 import { DimensionalElement } from '../base.js';
-import { Attribute, BaseFilterConfig, CompleteBaseFilterConfig, CompleteMembersFilterConfig, Filter, LevelAttribute, Measure, MembersFilterConfig } from '../interfaces.js';
+import { Attribute, BaseFilterConfig, BaseMeasure, CompleteBaseFilterConfig, CompleteMembersFilterConfig, Filter, LevelAttribute, Measure, MembersFilterConfig } from '../interfaces.js';
 import { AnyObject, JSONObject } from '../types.js';
 /**
  * Different text operators that can be used with text filters
@@ -70,6 +70,7 @@ export declare const FilterTypes: {
     readonly exclude: "exclude";
     readonly measure: "measure";
     readonly ranking: "ranking";
+    readonly measureRanking: "measure-ranking";
     readonly text: "text";
     readonly numeric: "numeric";
     readonly dateRange: "dateRange";
@@ -298,6 +299,32 @@ export declare class RankingFilter extends AbstractFilter {
      */
     filterJaql(): any;
 }
+/**
+ * @internal
+ */
+export declare class MeasureRankingFilter extends AbstractFilter {
+    /**
+     * @internal
+     */
+    readonly __serializable: string;
+    count: number;
+    operator: string;
+    measure: BaseMeasure;
+    constructor(measure: BaseMeasure, operator: string, count: number, config?: BaseFilterConfig, composeCode?: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize(): JSONObject;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+    jaql(nested?: boolean | undefined): any;
+}
 /**
  * @internal
  */
@@ -427,6 +454,13 @@ export declare function isNumericFilter(filter: Filter & AnyObject): filter is N
  * @internal
  */
 export declare function isRankingFilter(filter: Filter & AnyObject): filter is RankingFilter;
+/**
+ * Checks if a filter is a MeasureRankingFilter.
+ *
+ * @param filter - The filter to check.
+ * @internal
+ */
+export declare function isMeasureRankingFilter(filter: Filter & AnyObject): filter is MeasureRankingFilter;
 /**
  * Checks if a filter is a MeasureFilter.
  *

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFilter = exports.isDateRangeFilter = exports.isTextFilter = exports.isRelativeDateFilter = exports.isCascadingFilter = exports.isLogicalAttributeFilter = exports.isExcludeFilter = exports.isMeasureFilter = exports.isRankingFilter = exports.isNumericFilter = exports.isMembersFilter = exports.isCustomFilter = exports.CustomFilter = exports.RelativeDateFilter = exports.DateRangeFilter = exports.TextFilter = exports.NumericFilter = exports.RankingFilter = exports.MeasureFilter = exports.DoubleOperatorFilter = exports.ExcludeFilter = exports.CascadingFilter = exports.MembersFilter = exports.LogicalAttributeFilter = exports.FilterTypes = exports.RankingOperators = exports.LogicalOperators = exports.DateOperators = exports.NumericOperators = exports.TextOperators = void 0;
+exports.createFilter = exports.isDateRangeFilter = exports.isTextFilter = exports.isRelativeDateFilter = exports.isCascadingFilter = exports.isLogicalAttributeFilter = exports.isExcludeFilter = exports.isMeasureFilter = exports.isMeasureRankingFilter = exports.isRankingFilter = exports.isNumericFilter = exports.isMembersFilter = exports.isCustomFilter = exports.CustomFilter = exports.RelativeDateFilter = exports.DateRangeFilter = exports.TextFilter = exports.NumericFilter = exports.MeasureRankingFilter = exports.RankingFilter = exports.MeasureFilter = exports.DoubleOperatorFilter = exports.ExcludeFilter = exports.CascadingFilter = exports.MembersFilter = exports.LogicalAttributeFilter = exports.FilterTypes = exports.RankingOperators = exports.LogicalOperators = exports.DateOperators = exports.NumericOperators = exports.TextOperators = void 0;
 /* eslint-disable max-lines */
 const hash_it_1 = __importDefault(require("hash-it"));
 const merge_js_1 = __importDefault(require("lodash-es/merge.js"));
@@ -83,6 +83,7 @@ exports.FilterTypes = {
     exclude: 'exclude',
     measure: 'measure',
     ranking: 'ranking',
+    measureRanking: 'measure-ranking',
     text: 'text',
     numeric: 'numeric',
     dateRange: 'dateRange',
@@ -530,6 +531,60 @@ class RankingFilter extends AbstractFilter {
     }
 }
 exports.RankingFilter = RankingFilter;
+/**
+ * @internal
+ */
+class MeasureRankingFilter extends AbstractFilter {
+    constructor(measure, operator, count, config, composeCode) {
+        super(measure.attribute, exports.FilterTypes.measureRanking, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'MeasureRankingFilter';
+        this.count = count;
+        this.operator = operator;
+        this.measure = measure;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `${this.operator}_${this.count}_measure_${this.measure.id}`;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize() {
+        const result = super.serialize();
+        result.measure = this.measure.serialize();
+        result.count = this.count;
+        result.operator = this.operator;
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        const result = {};
+        result[this.operator] = this.count;
+        return result;
+    }
+    jaql(nested) {
+        if (this.config.disabled) {
+            return AbstractFilter.disabledJaql(nested);
+        }
+        const result = super.jaql(nested);
+        if ((0, measures_js_1.isDimensionalBaseMeasure)(this.measure)) {
+            Object.entries(this.measure.jaql().jaql).forEach(([key, value]) => {
+                result.jaql[key] = value;
+            });
+        }
+        // Add type: 'measure' for measure-based filters
+        result.jaql.type = 'measure';
+        return result;
+    }
+}
+exports.MeasureRankingFilter = MeasureRankingFilter;
 /**
  * @internal
  */
@@ -756,6 +811,16 @@ function isRankingFilter(filter) {
     return filter && filter.__serializable === 'RankingFilter';
 }
 exports.isRankingFilter = isRankingFilter;
+/**
+ * Checks if a filter is a MeasureRankingFilter.
+ *
+ * @param filter - The filter to check.
+ * @internal
+ */
+function isMeasureRankingFilter(filter) {
+    return filter && filter.__serializable === 'MeasureRankingFilter';
+}
+exports.isMeasureRankingFilter = isMeasureRankingFilter;
 /**
  * Checks if a filter is a MeasureFilter.
  *
@@ -834,31 +899,24 @@ function createFilter(json) {
     switch (json.filterType) {
         case exports.FilterTypes.logicalAttribute:
             return new LogicalAttributeFilter(json.filters.map((f) => createFilter(f)), json.operator);
-            break;
         case exports.FilterTypes.members:
             return new MembersFilter((0, factory_js_1.create)(json.attribute), json.members);
-            break;
         case exports.FilterTypes.exclude:
             return new ExcludeFilter(createFilter(json.filter), json.input && createFilter(json.input));
-            break;
         case exports.FilterTypes.measure:
             return new MeasureFilter((0, factory_js_1.create)(json.attribute), (0, factory_js_1.create)(json.measure), json.operatorA, json.valueA, json.operatorB, json.valueB);
-            break;
         case exports.FilterTypes.ranking:
             return new RankingFilter((0, factory_js_1.create)(json.attribute), (0, factory_js_1.create)(json.measure), json.operator, json.count);
-            break;
+        case exports.FilterTypes.measureRanking:
+            return new MeasureRankingFilter((0, factory_js_1.create)(json.measure), json.operator, json.count);
         case exports.FilterTypes.numeric:
             return new NumericFilter((0, factory_js_1.create)(json.attribute), json.operatorA, json.valueA, json.operatorB, json.valueB);
-            break;
         case exports.FilterTypes.text:
             return new TextFilter((0, factory_js_1.create)(json.attribute), json.operatorA, json.valueA);
-            break;
         case exports.FilterTypes.relativeDate:
             return new RelativeDateFilter((0, factory_js_1.create)(json.attribute), json.offset, json.count, json.operator, json.anchor);
-            break;
         case exports.FilterTypes.dateRange:
             return new DateRangeFilter((0, factory_js_1.create)(json.attribute), json.valueA, json.valueB);
-            break;
     }
     throw new translatable_error_js_1.TranslatableError('errors.filter.unsupportedType', {
         filterType: json.filterType,

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

@@ -209,6 +209,10 @@ const createMeasureFilterFromConditionFilterJaql = (measure, conditionFilterJaql
             return filterFactory.measureBetween(measure, conditionFilterJaql.from, conditionFilterJaql.to, { guid });
         case types_js_1.ConditionFilterType.IS_NOT_BETWEEN:
             return filterFactory.exclude(filterFactory.measureBetween(measure, (_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 types_js_1.ConditionFilterType.TOP:
+            return filterFactory.measureTopRanking(measure, conditionFilterJaql[types_js_1.ConditionFilterType.TOP], { guid });
+        case types_js_1.ConditionFilterType.BOTTOM:
+            return filterFactory.measureBottomRanking(measure, conditionFilterJaql[types_js_1.ConditionFilterType.BOTTOM], { guid });
     }
     throw new translatable_error_js_1.TranslatableError('errors.filter.unsupportedConditionFilter', {
         filter: JSON.stringify(conditionFilterJaql),

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

@@ -498,6 +498,11 @@ export interface PivotAttribute {
     attribute: Attribute;
     includeSubTotals?: boolean;
     sort?: PivotRowsSort;
+    /**
+     * Custom name to override the default attribute name in pivot table headers.
+     * If provided, this will be used as the display title in the pivot table.
+     */
+    name?: string;
 }
 /**
  * Runs type guard check for PivotAttribute.