@sisense/sdk-data 2.11.0 → 2.13.0

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

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withoutGuids = exports.findFilter = exports.withReplacedFilter = exports.withoutFilters = exports.withoutFilter = exports.withAddedFilters = exports.withAddedFilter = void 0;
 const omit_js_1 = __importDefault(require("lodash-es/omit.js"));
-const index_js_1 = require("../../index.js");
 const filter_relations_js_1 = require("./filter-relations.js");
 /**
  * Returns a function that adds a filter to existing filters or filter relations.
@@ -28,7 +27,7 @@ const filter_relations_js_1 = require("./filter-relations.js");
  */
 function withAddedFilter(filter) {
     return (filters) => {
-        if ((0, index_js_1.isFilterRelations)(filters)) {
+        if ((0, filter_relations_js_1.isFilterRelations)(filters)) {
             const { filters: existingFilters, relations } = (0, filter_relations_js_1.splitFiltersAndRelations)(filters);
             const newFilters = [...existingFilters, filter];
             const newRelations = (0, filter_relations_js_1.calculateNewRelations)(existingFilters, relations, newFilters);
@@ -59,7 +58,7 @@ exports.withAddedFilter = withAddedFilter;
  */
 function withAddedFilters(filtersToAdd) {
     return (filters) => {
-        if ((0, index_js_1.isFilterRelations)(filters)) {
+        if ((0, filter_relations_js_1.isFilterRelations)(filters)) {
             const { filters: existingFilters, relations } = (0, filter_relations_js_1.splitFiltersAndRelations)(filters);
             const newFilters = [...existingFilters, ...filtersToAdd];
             const newRelations = (0, filter_relations_js_1.calculateNewRelations)(existingFilters, relations, newFilters);
@@ -90,7 +89,7 @@ exports.withAddedFilters = withAddedFilters;
  */
 function withoutFilter(filterToRemove) {
     return (filters) => {
-        if ((0, index_js_1.isFilterRelations)(filters)) {
+        if ((0, filter_relations_js_1.isFilterRelations)(filters)) {
             const { filters: existingFilters, relations } = (0, filter_relations_js_1.splitFiltersAndRelations)(filters);
             const newFilters = existingFilters.filter((filter) => filter.config.guid !== filterToRemove.config.guid);
             const newRelations = (0, filter_relations_js_1.calculateNewRelations)(existingFilters, relations, newFilters);
@@ -121,7 +120,7 @@ exports.withoutFilter = withoutFilter;
  */
 function withoutFilters(filtersToRemove) {
     return (filters) => {
-        if ((0, index_js_1.isFilterRelations)(filters)) {
+        if ((0, filter_relations_js_1.isFilterRelations)(filters)) {
             const { filters: existingFilters, relations } = (0, filter_relations_js_1.splitFiltersAndRelations)(filters);
             const newFilters = existingFilters.filter((filter) => !filtersToRemove.some((filterToRemove) => filter.config.guid === filterToRemove.config.guid));
             const newRelations = (0, filter_relations_js_1.calculateNewRelations)(existingFilters, relations, newFilters);
@@ -153,7 +152,7 @@ exports.withoutFilters = withoutFilters;
  */
 function withReplacedFilter(filterToReplace, newFilter) {
     return (filters) => {
-        if ((0, index_js_1.isFilterRelations)(filters)) {
+        if ((0, filter_relations_js_1.isFilterRelations)(filters)) {
             const { filters: existingFilters, relations } = (0, filter_relations_js_1.splitFiltersAndRelations)(filters);
             const newFilters = existingFilters.map((filter) => filter.config.guid === filterToReplace.config.guid ? newFilter : filter);
             const newRelations = (0, filter_relations_js_1.getRelationsWithReplacedFilter)(relations, filterToReplace, newFilter);
@@ -176,7 +175,7 @@ function findFilter(filters, searchFn) {
     if (!filters) {
         return undefined;
     }
-    const filtersArray = (0, index_js_1.isFilterRelations)(filters) ? (0, filter_relations_js_1.getFiltersArray)(filters) : filters;
+    const filtersArray = (0, filter_relations_js_1.isFilterRelations)(filters) ? (0, filter_relations_js_1.getFiltersArray)(filters) : filters;
     return filtersArray.find(searchFn);
 }
 exports.findFilter = findFilter;
@@ -197,7 +196,7 @@ function filterRelationsWithoutGuids(filterRelations) {
         if (isFilter(node)) {
             return filterWithoutGuid(node);
         }
-        if ((0, index_js_1.isFilterRelations)(node)) {
+        if ((0, filter_relations_js_1.isFilterRelations)(node)) {
             return Object.assign(Object.assign({}, node), { left: traverse(node.left), right: traverse(node.right) });
         }
         return node;
@@ -215,7 +214,7 @@ function filterRelationsWithoutGuids(filterRelations) {
  * @internal
  */
 function withoutGuids(filters) {
-    if ((0, index_js_1.isFilterRelations)(filters)) {
+    if ((0, filter_relations_js_1.isFilterRelations)(filters)) {
         return filterRelationsWithoutGuids(filters);
     }
     else {

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/measures/factory.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable max-lines */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rank = exports.forecast = exports.trend = exports.contribution = exports.pastYear = exports.pastQuarter = exports.pastMonth = exports.pastWeek = exports.pastDay = exports.diffPastYear = exports.diffPastQuarter = exports.diffPastMonth = exports.diffPastWeek = exports.difference = exports.growthPastYear = exports.growthPastQuarter = exports.growthPastMonth = exports.growthPastWeek = exports.growthRate = exports.growth = exports.runningSum = exports.weekToDateSum = exports.monthToDateSum = exports.quarterToDateSum = exports.yearToDateSum = exports.divide = exports.multiply = exports.subtract = exports.add = exports.measuredValue = exports.countDistinct = exports.count = exports.median = exports.max = exports.min = exports.avg = exports.average = exports.sum = exports.constant = exports.aggregate = exports.customFormula = exports.RankingSortTypes = exports.RankingTypes = void 0;
 const base_js_1 = require("../base.js");

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

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable max-params */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -24,7 +25,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMeasure = exports.isDimensionalMeasureTemplate = exports.DimensionalMeasureTemplate = exports.isDimensionalCalculatedMeasure = exports.DimensionalCalculatedMeasure = exports.isDimensionalBaseMeasure = exports.DimensionalBaseMeasure = exports.AbstractMeasure = 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/types.d.ts

@@ -157,6 +157,10 @@ export declare const DateLevels: {
     readonly AggMinutesRoundTo1: "AggMinutesRoundTo1";
     /** @internal */
     readonly all: string[];
+    /** @internal */
+    readonly dateOnly: string[];
+    /** @internal */
+    readonly timeOnly: string[];
 };
 /** @internal */
 export declare type DateLevel = Exclude<(typeof DateLevels)[keyof typeof DateLevels], typeof DateLevels.all>;

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

@@ -1,10 +1,5 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/*
- * Types
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CurrencyPosition = exports.JaqlSortDirection = exports.DataType = exports.DateLevels = exports.MetadataTypes = exports.Sort = exports.AggregationTypes = void 0;
 /**
@@ -289,6 +284,30 @@ exports.DateLevels = {
             exports.DateLevels.AggMinutesRoundTo1,
         ];
     },
+    /** @internal */
+    get dateOnly() {
+        return [
+            exports.DateLevels.Years,
+            exports.DateLevels.Quarters,
+            exports.DateLevels.Months,
+            exports.DateLevels.Weeks,
+            exports.DateLevels.Days,
+        ];
+    },
+    /** @internal */
+    get timeOnly() {
+        return [
+            exports.DateLevels.Hours,
+            exports.DateLevels.MinutesRoundTo30,
+            exports.DateLevels.MinutesRoundTo15,
+            exports.DateLevels.Minutes,
+            exports.DateLevels.Seconds,
+            exports.DateLevels.AggHours,
+            exports.DateLevels.AggMinutesRoundTo30,
+            exports.DateLevels.AggMinutesRoundTo15,
+            exports.DateLevels.AggMinutesRoundTo1,
+        ];
+    },
 };
 /** @internal */
 var DataType;

package/dist/cjs/utils.js

@@ -314,7 +314,7 @@ exports.getSortType = getSortType;
 const createAttributeHelper = ({ expression, dataType, granularity, format, sort, title, panel, dataSource, }) => {
     const column = parseExpression(expression).column;
     const sortEnum = convertSort(sort);
-    const isDataTypeDatetime = dataType === types_js_1.DataType.DATETIME;
+    const isDataTypeDatetime = dataType !== undefined && (0, simple_column_types_js_1.isDatetime)(dataType);
     if (isDataTypeDatetime) {
         const levelAttribute = new attributes_js_1.DimensionalLevelAttribute(title !== null && title !== void 0 ? title : column, expression, granularity || types_js_1.DateLevels.Years, format ||
             attributes_js_1.DimensionalLevelAttribute.getDefaultFormatForGranularity(granularity || types_js_1.DateLevels.Years), undefined, sortEnum, dataSource, undefined, panel);

package/dist/dimensional-model/base.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
 /**
  * @internal
  */

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

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { TranslatableError } from '../translation/translatable-error.js';
 import { create } from './factory.js';
 /**

package/dist/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/dimensional-model/filters/factory.js

@@ -2,7 +2,7 @@
 /* eslint-disable max-params */
 /* eslint-disable @typescript-eslint/no-shadow */
 import { withComposeCodeForFilter, withComposeCodeForFilterRelations, } from '../compose-code-utils.js';
-import { CascadingFilter, CustomFilter, DateOperators, DateRangeFilter, ExcludeFilter, LogicalAttributeFilter, LogicalOperators, MeasureFilter, MembersFilter, NumericFilter, NumericOperators, RankingFilter, RankingOperators, RelativeDateFilter, TextFilter, TextOperators, } from './filters.js';
+import { CascadingFilter, CustomFilter, DateOperators, DateRangeFilter, ExcludeFilter, LogicalAttributeFilter, LogicalOperators, MeasureFilter, MeasureRankingFilter, MembersFilter, NumericFilter, NumericOperators, RankingFilter, RankingOperators, RelativeDateFilter, TextFilter, TextOperators, } from './filters.js';
 // LOGICAL FILTERS
 /**
  * Creates a filter representing the union of multiple filters on the same attribute. The resulting
@@ -746,19 +746,146 @@ export const topRanking = withComposeCodeForFilter((attribute, measure, count, c
  * @returns A filter instance
  */
 export const bottomRanking = withComposeCodeForFilter((attribute, measure, count, config) => new RankingFilter(attribute, measure, 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
+ */
+export const measureTopRanking = withComposeCodeForFilter((measure, count, config) => new MeasureRankingFilter(measure, 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
+ */
+export const measureBottomRanking = withComposeCodeForFilter((measure, count, config) => new MeasureRankingFilter(measure, RankingOperators.Bottom, count, config), 'measureBottomRanking');
 // CASCADING FILTERS
 /**
  * Creates a filter that contains a list of dependent/cascading filters,
@@ -815,6 +942,26 @@ export const cascading = withComposeCodeForFilter((filters, config) => new Casca
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export 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/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/dimensional-model/filters/filter-relations.js

@@ -1,8 +1,10 @@
 /* eslint-disable @typescript-eslint/default-param-last */
 import cloneDeep from 'lodash-es/cloneDeep.js';
 import isArray from 'lodash-es/isArray.js';
-import { DimensionalLevelAttribute, filterFactory, isCascadingFilter, } from '../../index.js';
 import { TranslatableError } from '../../translation/translatable-error.js';
+import { DimensionalLevelAttribute } from '../attributes.js';
+import * as filterFactory from './factory.js';
+import { isCascadingFilter } from './filters.js';
 /**
  * Type guard for checking if the provided filters are FilterRelations.
  *

package/dist/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.
  *