@sisense/sdk-data 1.28.0 → 1.30.0

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

@@ -0,0 +1,169 @@
+import { splitFiltersAndRelations, calculateNewRelations, combineFiltersAndRelations, getRelationsWithReplacedFilter, getFiltersArray, } from './filter-relations.js';
+import { isFilterRelations } from '../../index.js';
+/**
+ * Returns a function that adds a filter to existing filters or filter relations.
+ *
+ * @param filter - The filter to add.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations with the new filter added.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange];
+ * const updatedFilters = withAddedFilter(filterByCost)(originalFilters);
+ * // [filterByAgeRange, filterByCost]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFilterRelations = withAddedFilter(filterByCost)(originalFilterRelations);
+ * // (filterByAgeRange OR filterByRevenue) AND filterByCost
+ * ```
+ */
+export function withAddedFilter(filter) {
+    return (filters) => {
+        if (isFilterRelations(filters)) {
+            const { filters: existingFilters, relations } = splitFiltersAndRelations(filters);
+            const newFilters = [...existingFilters, filter];
+            const newRelations = calculateNewRelations(existingFilters, relations, newFilters);
+            return combineFiltersAndRelations(newFilters, newRelations);
+        }
+        return [...(filters || []), filter];
+    };
+}
+/**
+ * Returns a function that adds multiple filters to existing filters or filter relations.
+ *
+ * @param filtersToAdd - An array of filters to add.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations with the new filters added.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange];
+ * const updatedFilters = withAddedFilters([filterByCost, filterByRevenue])(originalFilters);
+ * // [filterByAgeRange, filterByCost, filterByRevenue]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFilterRelations = withAddedFilters([filterByCost, filterByRevenue])(originalFilterRelations);
+ * // (filterByAgeRange OR filterByRevenue) AND filterByCost AND filterByRevenue
+ * ```
+ */
+export function withAddedFilters(filtersToAdd) {
+    return (filters) => {
+        if (isFilterRelations(filters)) {
+            const { filters: existingFilters, relations } = splitFiltersAndRelations(filters);
+            const newFilters = [...existingFilters, ...filtersToAdd];
+            const newRelations = calculateNewRelations(existingFilters, relations, newFilters);
+            return combineFiltersAndRelations(newFilters, newRelations);
+        }
+        return [...(filters || []), ...filtersToAdd];
+    };
+}
+/**
+ * Returns a function that removes a filter from existing filters or filter relations.
+ *
+ * @param filterToRemove - The filter to remove.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations without the specified filter.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange, filterByRevenue, filterByCost];
+ * const updatedFilters = withoutFilter(filterByCost)(originalFilters);
+ * // [filterByAgeRange, filterByRevenue]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFiltersRelations = withoutFilter(filterByRevenue)(originalFilterRelations);
+ * // filterByAgeRange
+ * ```
+ */
+export function withoutFilter(filterToRemove) {
+    return (filters) => {
+        if (isFilterRelations(filters)) {
+            const { filters: existingFilters, relations } = splitFiltersAndRelations(filters);
+            const newFilters = existingFilters.filter((filter) => filter.config.guid !== filterToRemove.config.guid);
+            const newRelations = calculateNewRelations(existingFilters, relations, newFilters);
+            return combineFiltersAndRelations(newFilters, newRelations);
+        }
+        return (filters || []).filter((filter) => filter.config.guid !== filterToRemove.config.guid);
+    };
+}
+/**
+ * Returns a function that removes multiple filters from existing filters or filter relations.
+ *
+ * @param filtersToRemove - An array of filters to remove.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations without the specified filters.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange, filterByRevenue, filterByCost];
+ * const updatedFilters = withRemovedFilters([filterByRevenue, filterByCost])(originalFilters);
+ * // [filterByAgeRange]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFiltersRelations = withRemovedFilters([filterByRevenue])(originalFilterRelations);
+ * // filterByAgeRange
+ * ```
+ */
+export function withoutFilters(filtersToRemove) {
+    return (filters) => {
+        if (isFilterRelations(filters)) {
+            const { filters: existingFilters, relations } = splitFiltersAndRelations(filters);
+            const newFilters = existingFilters.filter((filter) => !filtersToRemove.some((filterToRemove) => filter.config.guid === filterToRemove.config.guid));
+            const newRelations = calculateNewRelations(existingFilters, relations, newFilters);
+            return combineFiltersAndRelations(newFilters, newRelations);
+        }
+        return (filters || []).filter((filter) => !filtersToRemove.some((filterToRemove) => filter.config.guid === filterToRemove.config.guid));
+    };
+}
+/**
+ * Returns a function that replaces a filter with a new filter in existing filters or filter relations.
+ *
+ * @param filterToReplace - The filter to replace.
+ * @param newFilter - The new filter to use as a replacement.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations with the filter replaced.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange, filterByRevenue];
+ * const updatedFilters = withReplacedFilter(filterByRevenue, filterByCost)(originalFilters);
+ * // [filterByAgeRange, filterByCost]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFilterRelations = withReplacedFilter(filterByRevenue, filterByCost)(originalFilterRelations);
+ * // (filterByAgeRange OR filterByCost)
+ * ```
+ */
+export function withReplacedFilter(filterToReplace, newFilter) {
+    return (filters) => {
+        if (isFilterRelations(filters)) {
+            const { filters: existingFilters, relations } = splitFiltersAndRelations(filters);
+            const newFilters = existingFilters.map((filter) => filter.config.guid === filterToReplace.config.guid ? newFilter : filter);
+            const newRelations = getRelationsWithReplacedFilter(relations, filterToReplace, newFilter);
+            return combineFiltersAndRelations(newFilters, newRelations);
+        }
+        return (filters || []).map((filter) => filter.config.guid === filterToReplace.config.guid ? newFilter : filter);
+    };
+}
+/**
+ * Finds a filter in an array of filters or filter relations.
+ * Returns the first filter that satisfies the provided search function.
+ * @group Filter Utilities
+ * @param filters - An array of filters or filter relations to search.
+ * @param searchFn - A function that takes a filter and returns a boolean indicating whether the filter satisfies the search criteria.
+ * @returns The first filter that satisfies the search function, or `undefined` if no filter is found.
+ *
+ */
+export function findFilter(filters, searchFn) {
+    if (!filters) {
+        return undefined;
+    }
+    const filtersArray = isFilterRelations(filters) ? getFiltersArray(filters) : filters;
+    return filtersArray.find(searchFn);
+}

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

@@ -0,0 +1,2 @@
+export * from './filter-relations.js';
+export * from './helpers.js';

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

@@ -0,0 +1,2 @@
+export * from './filter-relations.js';
+export * from './helpers.js';

package/dist/dimensional-model/filters/utils/attribute-measure-util.d.ts

@@ -1,19 +1,6 @@
 import { Attribute, BaseMeasure, CalculatedMeasure, LevelAttribute } from '../../interfaces.js';
 import { FilterJaql } from '../../types.js';
-import { CustomFormulaJaql, FilterJaqlInternal, JaqlDataSource, RankingFilterJaql } from './types.js';
-/**
- * Creates an attribute or level attribute from the provided parameters
- *
- * @param dim - Dimension expression
- * @param table - Table name
- * @param column - Column name
- * @param level - Date level
- * @param dataType - Data type
- * @param title - Attribute title
- * @param dataSource - Jaql data source
- * @returns attribute or level attribute
- */
-export declare const createAttributeHelper: (dim: string, table: string | undefined, column: string | undefined, level: string | undefined, dataType: string, title?: string, dataSource?: JaqlDataSource) => Attribute | LevelAttribute;
+import { CustomFormulaJaql, FilterJaqlInternal, RankingFilterJaql } from './types.js';
 /**
  * Creates an attribute or level attribute from the provided filter JAQL object
  *
@@ -21,27 +8,6 @@ export declare const createAttributeHelper: (dim: string, table: string | undefi
  * @returns attribute or level attribute
  */
 export declare const createAttributeFromFilterJaql: (jaql: FilterJaql | FilterJaqlInternal) => Attribute | LevelAttribute;
-/**
- * Creates a measure from the provided parameters
- *
- * @param dim - Dimension expression
- * @param table - Table name
- * @param column - Column name
- * @param level - Date level
- * @param dataType - Data type
- * @param agg - Aggregation function
- * @param title - Measure title
- * @param dataSource - data source provided in JAQL
- * @returns measure
- */
-export declare const createMeasureHelper: (dim: string, table: string | undefined, column: string, level: string | undefined, dataType: string, agg: string, title?: string, dataSource?: JaqlDataSource) => BaseMeasure;
-/**
- * Creates a calculated measure from the provided filter JAQL object
- *
- * @param jaql - custom formula jaql
- * @returns calculated measure
- */
-export declare const createCalculatedMeasureFromJaql: (jaql: CustomFormulaJaql) => CalculatedMeasure;
 /**
  * Creates a measure from the provided filter JAQL object
  *

package/dist/dimensional-model/filters/utils/attribute-measure-util.js

@@ -1,41 +1,4 @@
-import { DimensionalAttribute, DimensionalLevelAttribute, normalizeAttributeName, } from '../../attributes.js';
-import { isNumber } from '../../simple-column-types.js';
-import { MetadataTypes } from '../../types.js';
-import * as measureFactory from '../../measures/factory.js';
-import { transformCustomFormulaJaql } from '../../measures/factory.js';
-import { DimensionalBaseMeasure } from '../../measures/measures.js';
-const DATA_MODEL_MODULE_NAME = 'DM';
-/**
- * Creates an attribute or level attribute from the provided parameters
- *
- * @param dim - Dimension expression
- * @param table - Table name
- * @param column - Column name
- * @param level - Date level
- * @param dataType - Data type
- * @param title - Attribute title
- * @param dataSource - Jaql data source
- * @returns attribute or level attribute
- */
-export const createAttributeHelper = (dim, table, column, level, dataType, title, dataSource) => {
-    // if table is undefined, extract it from dim
-    const dimTable = table !== null && table !== void 0 ? table : dim.slice(1, -1).split('.')[0];
-    // if column is undefined, extract it from dim
-    const dimColumn = column !== null && column !== void 0 ? column : dim.slice(1, -1).split('.')[1];
-    if (level) {
-        const dateLevel = DimensionalLevelAttribute.translateJaqlToGranularity({ level });
-        const format = DimensionalLevelAttribute.getDefaultFormatForGranularity(dateLevel);
-        const levelAttribute = new DimensionalLevelAttribute(title !== null && title !== void 0 ? title : dimColumn, dim, dateLevel, format, undefined, undefined, dataSource);
-        levelAttribute.composeCode = normalizeAttributeName(dimTable, dimColumn, level, DATA_MODEL_MODULE_NAME);
-        return levelAttribute;
-    }
-    const attributeType = isNumber(dataType)
-        ? MetadataTypes.NumericAttribute
-        : MetadataTypes.TextAttribute;
-    const attribute = new DimensionalAttribute(title !== null && title !== void 0 ? title : dimColumn, dim, attributeType, undefined, undefined, dataSource);
-    attribute.composeCode = normalizeAttributeName(dimTable, dimColumn, undefined, DATA_MODEL_MODULE_NAME);
-    return attribute;
-};
+import { createAttributeHelper, createCalculatedMeasureHelper, createMeasureHelper, } from '../../../utils.js';
 /**
  * Creates an attribute or level attribute from the provided filter JAQL object
  *
@@ -44,39 +7,17 @@ export const createAttributeHelper = (dim, table, column, level, dataType, title
  */
 export const createAttributeFromFilterJaql = (jaql) => {
     const { dim, table, column, level, datatype, title, datasource: dataSource } = jaql;
-    return createAttributeHelper(dim, table, column, level, datatype, title, dataSource);
-};
-/**
- * Creates a measure from the provided parameters
- *
- * @param dim - Dimension expression
- * @param table - Table name
- * @param column - Column name
- * @param level - Date level
- * @param dataType - Data type
- * @param agg - Aggregation function
- * @param title - Measure title
- * @param dataSource - data source provided in JAQL
- * @returns measure
- */
-export const createMeasureHelper = (dim, table, column, level, dataType, agg, title, dataSource) => {
-    const attribute = createAttributeHelper(dim, table, column, level, dataType, title, dataSource);
-    const measure = measureFactory.aggregate(attribute, agg, title);
-    measure.composeCode = `measureFactory.${agg}(${attribute.composeCode})`;
-    return measure;
-};
-/**
- * Creates a calculated measure from the provided filter JAQL object
- *
- * @param jaql - custom formula jaql
- * @returns calculated measure
- */
-export const createCalculatedMeasureFromJaql = (jaql) => {
-    const measure = transformCustomFormulaJaql(jaql);
-    // TBD (SNS-108945)
-    // Handle preparation of 'composeCode' for formula
-    measure.composeCode = `'Formula code to be implemented'`;
-    return measure;
+    return createAttributeHelper({
+        dim,
+        table,
+        column,
+        dataType: datatype,
+        level,
+        format: undefined,
+        sort: undefined,
+        title,
+        dataSource,
+    });
 };
 /**
  * Creates a measure from the provided filter JAQL object
@@ -88,7 +29,18 @@ export const createMeasureFromFilterJaql = (jaql) => {
     const { dim, table, column, title, level, datatype: dataType, agg, datasource: dataSource, } = jaql;
     if (!agg)
         return undefined;
-    return createMeasureHelper(dim, table, column, level, dataType, DimensionalBaseMeasure.aggregationFromJAQL(agg), title, dataSource);
+    return createMeasureHelper({
+        dim,
+        table,
+        column,
+        dataType,
+        agg,
+        level,
+        format: undefined,
+        sort: undefined,
+        title,
+        dataSource,
+    });
 };
 /**
  * Creates a measure from the provided ranking filter JAQL object
@@ -98,7 +50,17 @@ export const createMeasureFromFilterJaql = (jaql) => {
  */
 export const createMeasureFromRankingFilterJaql = (jaql, rankingMessage) => {
     if ('formula' in jaql)
-        return createCalculatedMeasureFromJaql(jaql);
+        return createCalculatedMeasureHelper(jaql);
     const { dim, table, column, level, datatype: dataType, agg } = jaql;
-    return createMeasureHelper(dim, table, column, level, dataType, DimensionalBaseMeasure.aggregationFromJAQL(agg), rankingMessage);
+    return createMeasureHelper({
+        dim,
+        table,
+        column,
+        level,
+        dataType,
+        agg,
+        format: undefined,
+        sort: undefined,
+        title: rankingMessage,
+    });
 };

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

@@ -438,6 +438,7 @@ export declare type FilterConfig = CompleteBaseFilterConfig | CompleteMembersFil
 export interface Filter extends Element {
     /**
      * Attribute this filter instance is filtering
+     *
      * @internal
      */
     readonly attribute: Attribute;
@@ -448,6 +449,7 @@ export interface Filter extends Element {
     /**
      * Boolean flag whether the filter is a scope filter
      * which is on a dimension that isn’t used in the query
+     *
      * @internal
      */
     isScope: boolean;
@@ -496,6 +498,10 @@ export interface PivotMeasure {
      * @internal
      */
     dataBars?: boolean;
+    /**
+     * @internal
+     */
+    shouldRequestMinMax?: boolean;
 }
 /**
  * Runs type guard check for PivotMeasure.
@@ -508,6 +514,9 @@ export declare function isPivotMeasure(arg: Measure | PivotMeasure): arg is Pivo
  * Data options for grand totals of a pivot table
  */
 export declare type PivotGrandTotals = {
+    /**
+     * @deprecated
+     */
     title?: string;
     rows?: boolean;
     columns?: boolean;

package/dist/dimensional-model/interfaces.js

@@ -20,7 +20,6 @@ export function isPivotMeasure(arg) {
  * @internal
  */
 export const DEFAULT_PIVOT_GRAND_TOTALS = {
-    title: 'Grand Total',
     rows: false,
     columns: false,
 };

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

@@ -1,10 +1,7 @@
 import { DimensionalBaseMeasure, DimensionalCalculatedMeasure } from './measures.js';
 import { AggregationTypes, MetadataTypes } from '../types.js';
 import { normalizeName } from '../base.js';
-import mapValues from 'lodash-es/mapValues.js';
-import { DimensionalAttribute, DimensionalLevelAttribute } from '../attributes.js';
-import { isDatetime, isNumber } from './../simple-column-types.js';
-import { convertSort, createFilterFromJaql } from '../../utils.js';
+import { createCalculatedMeasureHelper } from '../../utils.js';
 import { TranslatableError } from '../../translation/translatable-error.js';
 /**
  * Defines the different numeric operators that can be used with numeric filters
@@ -75,28 +72,6 @@ function measureFunction(measure, name, func, options) {
     builder.push(')');
     return new DimensionalCalculatedMeasure(name, builder.join(''), context);
 }
-function transformFormulaJaqlHelper(jaql) {
-    const isFormulaJaql = 'formula' in jaql;
-    if (isFormulaJaql) {
-        return transformCustomFormulaJaql(jaql);
-    }
-    const sort = convertSort(jaql.sort);
-    const hasAggregation = !!jaql.agg;
-    const isDatatypeDatetime = isDatetime(jaql.datatype);
-    const attributeType = isNumber(jaql.datatype)
-        ? MetadataTypes.NumericAttribute
-        : MetadataTypes.TextAttribute;
-    const attribute = isDatatypeDatetime
-        ? new DimensionalLevelAttribute(jaql.title, jaql.dim, DimensionalLevelAttribute.translateJaqlToGranularity(jaql), undefined, undefined, sort)
-        : new DimensionalAttribute(jaql.title, jaql.dim, attributeType, undefined, sort);
-    if (hasAggregation) {
-        return new DimensionalBaseMeasure(jaql.title, attribute, DimensionalBaseMeasure.aggregationFromJAQL(jaql.agg || ''), undefined, undefined, sort);
-    }
-    if ('filter' in jaql) {
-        return createFilterFromJaql(jaql);
-    }
-    return attribute;
-}
 /**
  * Transforms a custom formula jaql into a calculated measure instance.
  *
@@ -107,14 +82,11 @@ function transformFormulaJaqlHelper(jaql) {
  * @internal
  */
 export function transformCustomFormulaJaql(jaql) {
-    var _a;
     const isFormulaJaql = 'formula' in jaql;
     if (!isFormulaJaql) {
         throw new TranslatableError('errors.measure.notAFormula');
     }
-    const sort = convertSort(jaql.sort);
-    const context = mapValues((_a = jaql.context) !== null && _a !== void 0 ? _a : {}, (jaqlContextValue) => jaqlContextValue ? transformFormulaJaqlHelper(jaqlContextValue) : {});
-    return new DimensionalCalculatedMeasure(jaql.title, jaql.formula, context, undefined, undefined, sort);
+    return createCalculatedMeasureHelper(jaql);
 }
 /**
  * Creates a calculated measure for a valid custom formula built from [base functions](/guides/sdk/reference/functions.html#measured-value-functions).

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

@@ -7,7 +7,7 @@ import { DimensionalElement } from '../base.js';
 export declare abstract class AbstractMeasure extends DimensionalElement {
     protected _sort: Sort;
     protected _format: string | undefined;
-    constructor(name: string, type: string, format?: string, desc?: string, sort?: Sort);
+    constructor(name: string, type: string, format?: string, desc?: string, sort?: Sort, composeCode?: string);
     /**
      * gets the element's ID
      */
@@ -51,7 +51,7 @@ export declare abstract class AbstractMeasure extends DimensionalElement {
 export declare class DimensionalBaseMeasure extends AbstractMeasure implements BaseMeasure {
     static aggregationFromJAQL(agg: string): string;
     static aggregationToJAQL(agg: string): string;
-    constructor(name: string, attribute: Attribute, agg: string, format?: string, desc?: string, sort?: Sort);
+    constructor(name: string, attribute: Attribute, agg: string, format?: string, desc?: string, sort?: Sort, composeCode?: string);
     /**
      * Aggregating attribute
      */
@@ -93,7 +93,7 @@ export declare class DimensionalBaseMeasure extends AbstractMeasure implements B
  * @internal
  */
 export declare class DimensionalCalculatedMeasure extends AbstractMeasure implements CalculatedMeasure {
-    constructor(name: string, expression: string, context: MeasureContext, format?: string, desc?: string, sort?: Sort);
+    constructor(name: string, expression: string, context: MeasureContext, format?: string, desc?: string, sort?: Sort, composeCode?: string);
     /**
      * Defines the Calculated measure's expression
      */

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

@@ -15,12 +15,13 @@ import { TranslatableError } from '../../translation/translatable-error.js';
  * @internal
  */
 export class AbstractMeasure extends DimensionalElement {
-    constructor(name, type, format, desc, sort) {
+    constructor(name, type, format, desc, sort, composeCode) {
         super(name, type, desc);
         this._sort = Sort.None;
         this._format = '#,#.00';
         this._format = format;
         this._sort = sort || Sort.None;
+        this.composeCode = composeCode;
     }
     /**
      * Gets the sort definition of this instance
@@ -58,8 +59,8 @@ export class AbstractMeasure extends DimensionalElement {
  * @internal
  */
 export class DimensionalBaseMeasure extends AbstractMeasure {
-    constructor(name, attribute, agg, format, desc, sort) {
-        super(name, MetadataTypes.BaseMeasure, format, desc, sort);
+    constructor(name, attribute, agg, format, desc, sort, composeCode) {
+        super(name, MetadataTypes.BaseMeasure, format, desc, sort, composeCode);
         this.attribute = attribute;
         this.aggregation = agg;
     }
@@ -116,7 +117,7 @@ export class DimensionalBaseMeasure extends AbstractMeasure {
      * @returns An instance representing the sorted {@link Measure} of this instance
      */
     sort(sort) {
-        return new DimensionalBaseMeasure(this.name, this.attribute, this.aggregation, this._format, this.description, sort);
+        return new DimensionalBaseMeasure(this.name, this.attribute, this.aggregation, this._format, this.description, sort, this.composeCode);
     }
     /**
      * Gets a formatted {@link Measure} with the given definition
@@ -127,7 +128,7 @@ export class DimensionalBaseMeasure extends AbstractMeasure {
      * @returns An instance representing the formatted {@link Measure} of this instance
      */
     format(format) {
-        return new DimensionalBaseMeasure(this.name, this.attribute, this.aggregation, format, this.description, this._sort);
+        return new DimensionalBaseMeasure(this.name, this.attribute, this.aggregation, format, this.description, this._sort, this.composeCode);
     }
     /**
      * gets the element's ID
@@ -165,8 +166,8 @@ export class DimensionalBaseMeasure extends AbstractMeasure {
  * @internal
  */
 export class DimensionalCalculatedMeasure extends AbstractMeasure {
-    constructor(name, expression, context, format, desc, sort) {
-        super(name, MetadataTypes.CalculatedMeasure, format, desc, sort);
+    constructor(name, expression, context, format, desc, sort, composeCode) {
+        super(name, MetadataTypes.CalculatedMeasure, format, desc, sort, composeCode);
         this.expression = expression;
         this.context = context;
     }
@@ -177,7 +178,7 @@ export class DimensionalCalculatedMeasure extends AbstractMeasure {
      * @returns An instance representing the sorted {@link Measure} of this instance
      */
     sort(sort) {
-        return new DimensionalCalculatedMeasure(this.name, this.expression, this.context, this._format, this.description, sort);
+        return new DimensionalCalculatedMeasure(this.name, this.expression, this.context, this._format, this.description, sort, this.composeCode);
     }
     /**
      * Gets a formatted {@link Measure} with the given definition
@@ -188,7 +189,7 @@ export class DimensionalCalculatedMeasure extends AbstractMeasure {
      * @returns An instance representing the formatted {@link Measure} of this instance
      */
     format(format) {
-        return new DimensionalCalculatedMeasure(this.name, this.expression, this.context, format, this.description, this._sort);
+        return new DimensionalCalculatedMeasure(this.name, this.expression, this.context, format, this.description, this._sort, this.composeCode);
     }
     /**
      * gets the element's ID

package/dist/index.d.ts

@@ -86,7 +86,6 @@ export * from './dimensional-model/measures/measures.js';
  */
 export * as measureFactory from './dimensional-model/measures/factory.js';
 export * from './dimensional-model/simple-column-types.js';
-export * from './dimensional-model/filter-relations.js';
 /**
  * Functions to create elements for advanced analytics – for example, attributes and measures for constructing a custom Boxplot chart
  *
@@ -94,4 +93,5 @@ export * from './dimensional-model/filter-relations.js';
  */
 export * as analyticsFactory from './dimensional-model/analytics/factory.js';
 export * from './utils.js';
+export * from './dimensional-model/filters/index.js';
 export { type TranslationDictionary, PACKAGE_NAMESPACE as translationNamespace, } from './translation/resources/index.js';

package/dist/index.js

@@ -86,7 +86,6 @@ export * from './dimensional-model/measures/measures.js';
  */
 export * as measureFactory from './dimensional-model/measures/factory.js';
 export * from './dimensional-model/simple-column-types.js';
-export * from './dimensional-model/filter-relations.js';
 /**
  * Functions to create elements for advanced analytics – for example, attributes and measures for constructing a custom Boxplot chart
  *
@@ -94,4 +93,5 @@ export * from './dimensional-model/filter-relations.js';
  */
 export * as analyticsFactory from './dimensional-model/analytics/factory.js';
 export * from './utils.js';
+export * from './dimensional-model/filters/index.js';
 export { PACKAGE_NAMESPACE as translationNamespace, } from './translation/resources/index.js';

package/dist/interfaces.d.ts

@@ -134,11 +134,11 @@ export interface CalculatedMeasureColumn {
 export declare type DataSourceInfo = {
     /**
      * @internal
-     **/
+     */
     id?: string;
     /**
      * @internal
-     **/
+     */
     address?: string;
     title: string;
     type: 'live' | 'elasticube';