@sisense/sdk-data 2.11.0 → 2.13.0

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

@@ -1,7 +1,7 @@
 "use strict";
+/* eslint-disable max-params */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeAttributeName = exports.createLevel = exports.createAttribute = exports.isDimensionalLevelAttribute = exports.DimensionalLevelAttribute = exports.isDimensionalAttribute = exports.DimensionalAttribute = exports.jaqlSimpleColumnType = void 0;
-/* eslint-disable max-params */
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */

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

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-return */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeName = exports.DimensionalElement = void 0;
 /**

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

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DimensionalDataModel = void 0;
 const translatable_error_js_1 = require("../translation/translatable-error.js");

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";
-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;
 /* eslint-disable max-lines */
+Object.defineProperty(exports, "__esModule", { value: true });
+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/filter-relations.d.ts

@@ -1,4 +1,4 @@
-import { Filter, FilterRelations, FilterRelationsJaql, FilterRelationsModel, FilterRelationsModelNode } from '../../index.js';
+import { Filter, FilterRelations, FilterRelationsJaql, FilterRelationsModel, FilterRelationsModelNode } from '../interfaces.js';
 /**
  * Type guard for checking if the provided filters are FilterRelations.
  *

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

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,8 +30,10 @@ exports.convertFilterRelationsModelToJaql = exports.getFilterRelationsFromJaql =
 /* eslint-disable @typescript-eslint/default-param-last */
 const cloneDeep_js_1 = __importDefault(require("lodash-es/cloneDeep.js"));
 const isArray_js_1 = __importDefault(require("lodash-es/isArray.js"));
-const index_js_1 = require("../../index.js");
 const translatable_error_js_1 = require("../../translation/translatable-error.js");
+const attributes_js_1 = require("../attributes.js");
+const filterFactory = __importStar(require("./factory.js"));
+const filters_js_1 = require("./filters.js");
 /**
  * Type guard for checking if the provided filters are FilterRelations.
  *
@@ -104,7 +129,7 @@ function combineFiltersAndRelations(filters, relations) {
             return filters.find((filter) => filter.config.guid === node.instanceid);
         }
         if (isRelationsRule(node)) {
-            const func = node.operator === 'AND' ? index_js_1.filterFactory.logic.and : index_js_1.filterFactory.logic.or;
+            const func = node.operator === 'AND' ? filterFactory.logic.and : filterFactory.logic.or;
             return func(traverse(node.left), traverse(node.right));
         }
         throw new UnknownRelationsNodeError();
@@ -277,7 +302,7 @@ function convertFilterRelationsModelToRelationRules(filterRelationsModel, filter
         if (isModelCascadeNode(node)) {
             // CSDK filter relations model work with cascading filters as with a single node.
             const cascadingFilterForThisCascade = filters.find((filter) => {
-                if (!(0, index_js_1.isCascadingFilter)(filter)) {
+                if (!(0, filters_js_1.isCascadingFilter)(filter)) {
                     return false;
                 }
                 const levelIds = filter.filters.map((f) => f.config.guid);
@@ -335,7 +360,7 @@ function filterRelationRulesToFilterRelationsModel(filterRelationRules, filters)
         if (isRelationsRuleIdNode(node)) {
             // Check if this instanceid corresponds to a cascading filter
             const filter = filters.find((f) => f.config.guid === node.instanceid);
-            if (filter && (0, index_js_1.isCascadingFilter)(filter)) {
+            if (filter && (0, filters_js_1.isCascadingFilter)(filter)) {
                 // Build a CascadingIdentifier node
                 const levels = filter.filters.map((levelFilter) => ({
                     type: 'Identifier',
@@ -424,7 +449,7 @@ exports.isOperatorDescriptionNode = isOperatorDescriptionNode;
  * @internal
  */
 function getFilterCompareId(filter) {
-    if ((0, index_js_1.isCascadingFilter)(filter)) {
+    if ((0, filters_js_1.isCascadingFilter)(filter)) {
         return filter.filters.map(getFilterCompareId).join('-');
     }
     // TODO: remove fallback on 'filter.jaql()' after removing temporal 'jaql()' workaround from filter translation layer
@@ -433,7 +458,7 @@ function getFilterCompareId(filter) {
     const expression = filterAttribute.expression || filterJaql.dim;
     const granularity = filterAttribute.granularity ||
         ((filterJaql === null || filterJaql === void 0 ? void 0 : filterJaql.datatype) === 'datetime'
-            ? index_js_1.DimensionalLevelAttribute.translateJaqlToGranularity(filterJaql)
+            ? attributes_js_1.DimensionalLevelAttribute.translateJaqlToGranularity(filterJaql)
             : '');
     return `${expression}${granularity}`;
 }

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/helpers.d.ts

@@ -1,4 +1,4 @@
-import { Filter, FilterRelations } from '../../index.js';
+import { Filter, FilterRelations } from '../interfaces.js';
 /**
  * Returns a function that adds a filter to existing filters or filter relations.
  *