@sisense/sdk-data 2.11.0 → 2.13.0

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

@@ -77,6 +77,7 @@ export const FilterTypes = {
     exclude: 'exclude',
     measure: 'measure',
     ranking: 'ranking',
+    measureRanking: 'measure-ranking',
     text: 'text',
     numeric: 'numeric',
     dateRange: 'dateRange',
@@ -517,6 +518,59 @@ export class RankingFilter extends AbstractFilter {
         return result;
     }
 }
+/**
+ * @internal
+ */
+export class MeasureRankingFilter extends AbstractFilter {
+    constructor(measure, operator, count, config, composeCode) {
+        super(measure.attribute, 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 (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;
+    }
+}
 /**
  * @internal
  */
@@ -734,6 +788,15 @@ export function isNumericFilter(filter) {
 export function isRankingFilter(filter) {
     return filter && filter.__serializable === 'RankingFilter';
 }
+/**
+ * Checks if a filter is a MeasureRankingFilter.
+ *
+ * @param filter - The filter to check.
+ * @internal
+ */
+export function isMeasureRankingFilter(filter) {
+    return filter && filter.__serializable === 'MeasureRankingFilter';
+}
 /**
  * Checks if a filter is a MeasureFilter.
  *
@@ -805,31 +868,24 @@ export function createFilter(json) {
     switch (json.filterType) {
         case FilterTypes.logicalAttribute:
             return new LogicalAttributeFilter(json.filters.map((f) => createFilter(f)), json.operator);
-            break;
         case FilterTypes.members:
             return new MembersFilter(create(json.attribute), json.members);
-            break;
         case FilterTypes.exclude:
             return new ExcludeFilter(createFilter(json.filter), json.input && createFilter(json.input));
-            break;
         case FilterTypes.measure:
             return new MeasureFilter(create(json.attribute), create(json.measure), json.operatorA, json.valueA, json.operatorB, json.valueB);
-            break;
         case FilterTypes.ranking:
             return new RankingFilter(create(json.attribute), create(json.measure), json.operator, json.count);
-            break;
+        case FilterTypes.measureRanking:
+            return new MeasureRankingFilter(create(json.measure), json.operator, json.count);
         case FilterTypes.numeric:
             return new NumericFilter(create(json.attribute), json.operatorA, json.valueA, json.operatorB, json.valueB);
-            break;
         case FilterTypes.text:
             return new TextFilter(create(json.attribute), json.operatorA, json.valueA);
-            break;
         case FilterTypes.relativeDate:
             return new RelativeDateFilter(create(json.attribute), json.offset, json.count, json.operator, json.anchor);
-            break;
         case FilterTypes.dateRange:
             return new DateRangeFilter(create(json.attribute), json.valueA, json.valueB);
-            break;
     }
     throw new TranslatableError('errors.filter.unsupportedType', {
         filterType: json.filterType,

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

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

@@ -1,6 +1,5 @@
 import omit from 'lodash-es/omit.js';
-import { isFilterRelations } from '../../index.js';
-import { calculateNewRelations, combineFiltersAndRelations, getFiltersArray, getRelationsWithReplacedFilter, splitFiltersAndRelations, } from './filter-relations.js';
+import { calculateNewRelations, combineFiltersAndRelations, getFiltersArray, getRelationsWithReplacedFilter, isFilterRelations, splitFiltersAndRelations, } from './filter-relations.js';
 /**
  * Returns a function that adds a filter to existing filters or filter relations.
  *

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

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

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

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import { normalizeName } from '../base.js';
 import { withComposeCodeForMeasure } from '../compose-code-utils.js';
 import { AggregationTypes, MetadataTypes } from '../types.js';

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

@@ -1,9 +1,4 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/*
- * Types
- */
 /**
  * Different aggregation types
  */
@@ -286,6 +281,30 @@ export const DateLevels = {
             DateLevels.AggMinutesRoundTo1,
         ];
     },
+    /** @internal */
+    get dateOnly() {
+        return [
+            DateLevels.Years,
+            DateLevels.Quarters,
+            DateLevels.Months,
+            DateLevels.Weeks,
+            DateLevels.Days,
+        ];
+    },
+    /** @internal */
+    get timeOnly() {
+        return [
+            DateLevels.Hours,
+            DateLevels.MinutesRoundTo30,
+            DateLevels.MinutesRoundTo15,
+            DateLevels.Minutes,
+            DateLevels.Seconds,
+            DateLevels.AggHours,
+            DateLevels.AggMinutesRoundTo30,
+            DateLevels.AggMinutesRoundTo15,
+            DateLevels.AggMinutesRoundTo1,
+        ];
+    },
 };
 /** @internal */
 export var DataType;