@sisense/sdk-data 1.21.0 → 1.23.0

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

@@ -427,10 +427,12 @@ export function numeric(attribute, operatorA, valueA, operatorB, valueB, guid) {
  * @param guid - Optional GUID for the filter
  * @param deactivatedMembers - Array of deactivated member values
  * @param backgroundFilter - Optional background filter
+ * @param multiSelection - Optional flag to disable multi-selection
  * @returns A filter instance
+ * @shortDescription Creates filter on attribute to match certain string values
  */
-export function members(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter) {
-    return new MembersFilter(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter);
+export function members(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter, multiSelection) {
+    return new MembersFilter(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter, multiSelection);
 }
 // DATE FILTERS
 /**

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

@@ -166,10 +166,12 @@ export declare class MembersFilter extends AbstractFilter {
     /** @internal */
     excludeMembers: boolean;
     /** @internal */
+    multiSelection: boolean;
+    /** @internal */
     deactivatedMembers: any[];
     /** @internal */
     backgroundFilter?: Filter;
-    constructor(attribute: Attribute, members?: any[], excludeMembers?: boolean, guid?: string, deactivatedMembers?: any[], backgroundFilter?: Filter);
+    constructor(attribute: Attribute, members?: any[], excludeMembers?: boolean, guid?: string, deactivatedMembers?: any[], backgroundFilter?: Filter, multiSelection?: boolean);
     /**
      * gets the element's ID
      */

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

@@ -220,10 +220,11 @@ export class LogicalAttributeFilter extends AbstractFilter {
  * @internal
  */
 export class MembersFilter extends AbstractFilter {
-    constructor(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter) {
+    constructor(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter, multiSelection = true) {
         super(attribute, FilterTypes.members, guid);
         this.members = members !== null && members !== void 0 ? members : [];
         this.excludeMembers = excludeMembers !== null && excludeMembers !== void 0 ? excludeMembers : false;
+        this.multiSelection = multiSelection;
         this.deactivatedMembers = deactivatedMembers !== null && deactivatedMembers !== void 0 ? deactivatedMembers : [];
         this.backgroundFilter = backgroundFilter;
         if (this.members.filter((m) => m === null || m === undefined).length > 0) {
@@ -256,10 +257,7 @@ export class MembersFilter extends AbstractFilter {
         const membersFilterJaql = {
             members: this.members.map((m) => m.toString()),
         };
-        // if there's no members to exclude, do not add the exclude property
-        const filterJaql = this.excludeMembers && this.members.length
-            ? { exclude: membersFilterJaql }
-            : membersFilterJaql;
+        const filterJaql = this.excludeMembers ? { exclude: membersFilterJaql } : membersFilterJaql;
         if (this.backgroundFilter) {
             return {
                 and: [filterJaql, this.backgroundFilter.filterJaql()],

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

@@ -55,4 +55,4 @@ export declare const createMeasureFromFilterJaql: (jaql: FilterJaqlInternal) =>
  * @param jaql - Ranking filter Jaql object
  * @returns Measure
  */
-export declare const createMeasureFromRankingFilterJaql: (jaql: RankingFilterJaql | CustomFormulaJaql) => BaseMeasure | CalculatedMeasure;
+export declare const createMeasureFromRankingFilterJaql: (jaql: RankingFilterJaql | CustomFormulaJaql, rankingMessage?: string) => BaseMeasure | CalculatedMeasure;

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

@@ -3,6 +3,7 @@ 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
@@ -58,7 +59,7 @@ export const createAttributeFromFilterJaql = (jaql) => {
  */
 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);
+    const measure = measureFactory.aggregate(attribute, agg, title);
     measure.composeCode = `measureFactory.${agg}(${attribute.composeCode})`;
     return measure;
 };
@@ -85,7 +86,7 @@ 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, agg, title, dataSource);
+    return createMeasureHelper(dim, table, column, level, dataType, DimensionalBaseMeasure.aggregationFromJAQL(agg), title, dataSource);
 };
 /**
  * Creates a measure from the provided ranking filter JAQL object
@@ -93,9 +94,9 @@ export const createMeasureFromFilterJaql = (jaql) => {
  * @param jaql - Ranking filter Jaql object
  * @returns Measure
  */
-export const createMeasureFromRankingFilterJaql = (jaql) => {
+export const createMeasureFromRankingFilterJaql = (jaql, rankingMessage) => {
     if ('formula' in jaql)
         return createCalculatedMeasureFromJaql(jaql);
     const { dim, table, column, level, datatype: dataType, agg } = jaql;
-    return createMeasureHelper(dim, table, column, level, dataType, agg);
+    return createMeasureHelper(dim, table, column, level, dataType, DimensionalBaseMeasure.aggregationFromJAQL(agg), rankingMessage);
 };

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

@@ -2,6 +2,7 @@ import { ConditionFilterType } from './types.js';
 import { withComposeCode } from './filter-code-util.js';
 import * as filterFactory from '../factory.js';
 import { createMeasureFromRankingFilterJaql } from './attribute-measure-util.js';
+import { TranslatableError } from '../../../translation/translatable-error.js';
 const isTopCondition = (filter) => filter.top !== undefined;
 const isBottomCondition = (filter) => filter.bottom !== undefined;
 const isExcludeCondition = (filter) => { var _a; return !!((_a = filter.exclude) === null || _a === void 0 ? void 0 : _a.members); };
@@ -81,12 +82,12 @@ export const getSelectedConditionOption = (filter) => {
  * @returns attribute filter
  */
 export const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, guid) => {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f;
     const conditionType = getSelectedConditionOption(conditionFilterJaql);
     switch (conditionType) {
         case ConditionFilterType.BOTTOM:
             if (conditionFilterJaql.by) {
-                return withComposeCode(filterFactory.bottomRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by), conditionFilterJaql[ConditionFilterType.BOTTOM], guid);
+                return withComposeCode(filterFactory.bottomRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.BOTTOM], guid);
             }
             break;
         case ConditionFilterType.EQUALS:
@@ -99,7 +100,7 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
             return withComposeCode(filterFactory.greaterThanOrEqual)(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], guid);
         case ConditionFilterType.TOP:
             if (conditionFilterJaql.by) {
-                return withComposeCode(filterFactory.topRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by), conditionFilterJaql[ConditionFilterType.TOP], guid);
+                return withComposeCode(filterFactory.topRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.TOP], guid);
             }
             break;
         case ConditionFilterType.STARTS_WITH:
@@ -130,9 +131,13 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
                 return withComposeCode(filterFactory.union)(conditionFilterJaql.or.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), guid);
             }
             break;
-        case ConditionFilterType.IS_NOT:
+        case ConditionFilterType.IS_NOT: {
+            const deactivatedMembers = (((_c = conditionFilterJaql.filter) === null || _c === void 0 ? void 0 : _c.turnedOff) && ((_d = conditionFilterJaql.filter.exclude) === null || _d === void 0 ? void 0 : _d.members)) ||
+                [];
+            const selectedMembers = ((_f = (_e = conditionFilterJaql.exclude) === null || _e === void 0 ? void 0 : _e.members) === null || _f === void 0 ? void 0 : _f.filter((member) => !deactivatedMembers.includes(member))) || [];
             // use members filter with exclude instead of exclude filter
-            return withComposeCode(filterFactory.members)(attribute, ((_c = conditionFilterJaql.exclude) === null || _c === void 0 ? void 0 : _c.members) || [], true, guid);
+            return withComposeCode(filterFactory.members)(attribute, selectedMembers, true, guid, deactivatedMembers, undefined, conditionFilterJaql.multiSelection);
+        }
         case ConditionFilterType.AFTER:
         case ConditionFilterType.BEFORE:
         case ConditionFilterType.IS_EMPTY:
@@ -140,7 +145,9 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
             // TODO Handle these cases later; may need filterFactory function added first
             break;
     }
-    throw 'Jaql contains unsupported condition filter: ' + JSON.stringify(conditionFilterJaql);
+    throw new TranslatableError('errors.filter.unsupportedConditionFilter', {
+        filter: JSON.stringify(conditionFilterJaql),
+    });
 };
 /**
  * Creates a measure filter from the provided measure and condition filter JAQL object
@@ -166,5 +173,7 @@ export const createMeasureFilterFromConditionFilterJaql = (measure, conditionFil
         case ConditionFilterType.BETWEEN:
             return withComposeCode(filterFactory.measureBetween)(measure, conditionFilterJaql.from, conditionFilterJaql.to, guid);
     }
-    throw 'Jaql contains unsupported condition filter: ' + JSON.stringify(conditionFilterJaql);
+    throw new TranslatableError('errors.filter.unsupportedConditionFilter', {
+        filter: JSON.stringify(conditionFilterJaql),
+    });
 };

package/dist/dimensional-model/filters/utils/filter-from-jaql-util.d.ts

@@ -25,7 +25,7 @@ export declare const createFilterIncludeAll: (attribute: Attribute, guid?: strin
  * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql, guid?: string) => Filter;
+export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql, guid?: string, multiSelection?: boolean) => Filter;
 /**
  * Creates a filter from a date range filter JAQL object.
  *

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

@@ -5,6 +5,7 @@ import { extractFilterTypeFromFilterJaql } from './filter-types-util.js';
 import { withComposeCode } from './filter-code-util.js';
 import { createAttributeFromFilterJaql, createMeasureFromFilterJaql, } from './attribute-measure-util.js';
 import { guidFast } from '../../../utils.js';
+import { TranslatableError } from '../../../translation/translatable-error.js';
 /**
  * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
  *
@@ -56,11 +57,11 @@ export const createFilterIncludeAll = (attribute, guid) => {
  * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJaql, guid) => {
+export const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJaql, guid, multiSelection) => {
     const deactivatedMembers = getDeactivatedMembersFromFilterJaql(specificItemsFilterJaql);
     const activeMembers = getActiveMembersFromFilterJaql(specificItemsFilterJaql, deactivatedMembers);
     return withComposeCode(filterFactory.members)(attribute, activeMembers, undefined, // use undefined instead of false to avoid including the property in composeCode
-    guid, deactivatedMembers);
+    guid, deactivatedMembers, undefined, multiSelection);
 };
 function getDeactivatedMembersFromFilterJaql(filterJaql) {
     var _a, _b, _c;
@@ -149,7 +150,9 @@ export const createFilterFromJaqlInternal = (jaql, guid) => {
     try {
         if ('formula' in jaql) {
             // generic pass-through JAQL filter will be used instead
-            throw 'Formula-based filter not supported yet: ' + JSON.stringify(jaql);
+            throw new TranslatableError('errors.filter.formulaFiltersNotSupported', {
+                filter: JSON.stringify(jaql),
+            });
         }
         const filterJaqlWrapperWithType = extractFilterTypeFromFilterJaql(jaql, jaql.datatype);
         const { filter: filterJaqlWithType } = filterJaqlWrapperWithType;
@@ -160,7 +163,7 @@ export const createFilterFromJaqlInternal = (jaql, guid) => {
             case FILTER_TYPES.INCLUDE_ALL:
                 return createFilterIncludeAll(attribute, guid);
             case FILTER_TYPES.SPECIFIC_ITEMS:
-                return createFilterFromSpecificItemsFilterJaql(attribute, filterJaqlWithType, guid);
+                return createFilterFromSpecificItemsFilterJaql(attribute, filterJaqlWithType, guid, filterJaqlWithType.multiSelection);
             case FILTER_TYPES.CONDITION:
                 return createFilterFromConditionFilterJaql(attribute, filterJaqlWithType, measure, guid);
             case FILTER_TYPES.DATE_RANGE:

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

@@ -485,6 +485,7 @@ export declare type FilterRelationsJaqlIdNode = {
 };
 /**
  * A node of a {@link FilterRelationsModel} tree that represents a filter
+ *
  * @internal
  */
 export declare type FilterRelationsModelIdNode = {

package/dist/dimensional-model/jaql-element.d.ts

@@ -0,0 +1,36 @@
+import { DimensionalElement } from './base.js';
+import { SortDirection } from './interfaces.js';
+import { MetadataItem } from './types.js';
+/**
+ * This implementation wraps metadata for a JAQL query. The metadata could be
+ * for a dimension, measure, or filter. We do little to no interpretation of
+ * the JAQL as it is designed to be "passed through" to the query execution
+ * step.
+ *
+ * This will typically be used for JAQL metadata that is coming from a Sisense
+ * instance and is assumed to be correct (e.g. dashboard widget, NLQ
+ * suggestion).
+ *
+ * @param item - the metadata item in a JAQL query
+ * @param type - the data type of the dimension
+ * @internal
+ */
+export declare class JaqlElement extends DimensionalElement {
+    private readonly metadataItem;
+    expression: string;
+    skipValidation: boolean;
+    aggregation?: string;
+    formula?: string;
+    sortType?: SortDirection;
+    constructor(item: MetadataItem, type: string);
+    get id(): string;
+    jaql(): MetadataItem;
+}
+/**
+ * Create a JaqlElement from a MetadataItem
+ *
+ * @param item - the metadata item in a JAQL query
+ * @returns a JaqlElement
+ * @internal
+ */
+export declare function createJaqlElement(item: MetadataItem): JaqlElement;

package/dist/dimensional-model/jaql-element.js

@@ -0,0 +1,68 @@
+import { DimensionalElement } from './base.js';
+import { getSortType } from '../utils.js';
+import { MetadataTypes } from './types.js';
+/**
+ * This implementation wraps metadata for a JAQL query. The metadata could be
+ * for a dimension, measure, or filter. We do little to no interpretation of
+ * the JAQL as it is designed to be "passed through" to the query execution
+ * step.
+ *
+ * This will typically be used for JAQL metadata that is coming from a Sisense
+ * instance and is assumed to be correct (e.g. dashboard widget, NLQ
+ * suggestion).
+ *
+ * @param item - the metadata item in a JAQL query
+ * @param type - the data type of the dimension
+ * @internal
+ */
+export class JaqlElement extends DimensionalElement {
+    constructor(item, type) {
+        var _a;
+        super((_a = item.jaql.title) !== null && _a !== void 0 ? _a : '', type);
+        this.expression = (item.jaql.dim || item.jaql.formula);
+        this.metadataItem = item;
+        if (item.jaql.agg) {
+            this.aggregation = item.jaql.agg;
+        }
+        else {
+            delete this.aggregation;
+        }
+        if (item.jaql.formula) {
+            this.formula = item.jaql.formula;
+        }
+        else {
+            delete this.formula;
+        }
+        if (item.jaql.sort) {
+            this.sortType = getSortType(item.jaql.sort);
+        }
+        else {
+            delete this.sortType;
+        }
+        this.skipValidation = true;
+    }
+    get id() {
+        return this.expression;
+    }
+    jaql() {
+        return this.metadataItem;
+    }
+}
+const toMetadataType = {
+    text: MetadataTypes.TextAttribute,
+    numeric: MetadataTypes.NumericAttribute,
+    datetime: MetadataTypes.DateLevel,
+};
+/**
+ * Create a JaqlElement from a MetadataItem
+ *
+ * @param item - the metadata item in a JAQL query
+ * @returns a JaqlElement
+ * @internal
+ */
+export function createJaqlElement(item) {
+    var _a;
+    // TODO: measures with a "formula" may not have a datatype. force this to be numeric because aggregations
+    // will always be of type number. check if there is a more correct way to do this
+    return new JaqlElement(item, (_a = toMetadataType[item.jaql.datatype]) !== null && _a !== void 0 ? _a : 'numeric');
+}

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

@@ -5,6 +5,7 @@ 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 { TranslatableError } from '../../translation/translatable-error.js';
 /**
  * Defines the different numeric operators that can be used with numeric filters
  *
@@ -109,7 +110,7 @@ export function transformCustomFormulaJaql(jaql) {
     var _a;
     const isFormulaJaql = 'formula' in jaql;
     if (!isFormulaJaql) {
-        throw new Error('Jaql is not a formula');
+        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) : {});

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

@@ -223,12 +223,14 @@ export declare type IncludeAllFilter = {
 /** @internal */
 export declare type IncludeMembersFilter = {
     members: string[];
+    multiSelection?: boolean;
 };
 /** @internal */
 export declare type ExcludeMembersFilter = {
     exclude: {
         members: string[];
     };
+    multiSelection?: boolean;
 };
 /** @internal */
 export declare type TurnOffMembersFilter = ExcludeMembersFilter & {
@@ -266,3 +268,149 @@ export declare type OrFilter<FilterItem> = {
  * Abstract object with any unknown values
  */
 export declare type AnyObject = Record<string, any>;
+/**
+ * @internal
+ */
+interface DecimalAbbreviations {
+    k: boolean;
+    m: boolean;
+    b: boolean;
+    t: boolean;
+}
+/**
+ * @internal
+ */
+export declare enum CurrencyPosition {
+    PRE = "pre",
+    POST = "post"
+}
+/**
+ * @internal
+ */
+export declare type NumericMask = {
+    isdefault?: boolean;
+    abbreviations?: DecimalAbbreviations;
+    decimals?: 'auto' | number | string;
+    currency?: {
+        symbol: string;
+        position: CurrencyPosition;
+    };
+    percent?: boolean;
+    number?: {
+        separated: boolean;
+    };
+    separated?: boolean;
+    type?: string;
+};
+/**
+ * @internal
+ */
+export declare type DatetimeMask = {
+    isdefault?: boolean;
+    years: string;
+    quarters: string;
+    months: string;
+    weeks: string;
+    minutes: string;
+    days: string;
+    type: string;
+    dateAndTime?: string;
+};
+/**
+ * @internal
+ */
+export declare type MetadataItem = {
+    instanceid?: string;
+    measure?: MetadataItemJaql;
+    jaql: MetadataItemJaql;
+    panel?: string;
+    isScope?: boolean;
+    format?: {
+        mask?: Partial<DatetimeMask> | Partial<NumericMask>;
+        number?: string;
+        subtotal?: boolean;
+        width?: number;
+        databars?: boolean;
+        color?: {
+            type: string;
+            color?: string;
+            conditions?: Array<{
+                color: string;
+                operator: string;
+                expression: string | Record<string, any>;
+            }>;
+        };
+    };
+    field?: {
+        id?: string;
+        index?: number;
+    };
+    filter?: MetadataItem;
+    exclude?: MetadataItem;
+    by?: MetadataItemJaql;
+    level?: string;
+    anchor?: string;
+    from?: string;
+    to?: string;
+};
+/**
+ * @internal
+ */
+export declare type MetadataItemJaql = {
+    dim?: string;
+    agg?: string;
+    datatype?: string;
+    table?: string;
+    column?: string;
+    level?: string;
+    dateTimeLevel?: string;
+    bucket?: string;
+    sort?: string;
+    in?: {
+        selected: {
+            jaql: MetadataItemJaql;
+        };
+    };
+    title?: string;
+    type?: string;
+    formula?: string;
+    context?: {
+        [itemId: string]: MetadataItemJaql;
+    };
+    filter?: MetadataItem;
+    sortDetails?: {
+        dir: string;
+        field?: number;
+        measurePath?: Record<number, string | number>;
+        sortingLastDimension?: boolean;
+        initialized?: boolean;
+    };
+};
+/**
+ * @internal
+ */
+export declare type DataSourceField = {
+    column: string;
+    dimtype: string;
+    id: string;
+    indexed: boolean;
+    merged: boolean;
+    table: string;
+    title: string;
+    type: string;
+};
+/**
+ * @internal
+ */
+export declare type DataSourceSchema = {
+    title: string;
+    type: 'extract' | 'live';
+} & AnyObject;
+/**
+ * @internal
+ */
+export declare type DataSourceMetadata = {
+    title: string;
+    fullname: string;
+    live: boolean;
+};

package/dist/dimensional-model/types.js

@@ -104,7 +104,8 @@ export const MetadataTypes = {
             const type = o;
             return type.toLowerCase() === MetadataTypes.BaseMeasure;
         }
-        return (o.agg || o.aggregation) && o.attribute && !this.isMeasureTemplate(o);
+        // JaqlElement doesn't have property attribute. Check for jaql instead
+        return (o.agg || o.aggregation) && (o.attribute || o.jaql) && !this.isMeasureTemplate(o);
     },
     /**
      * Checks whether the given object or type is a measure - of any type
@@ -297,3 +298,11 @@ export var JaqlSortDirection;
     JaqlSortDirection["ASC"] = "asc";
     JaqlSortDirection["DESC"] = "desc";
 })(JaqlSortDirection = JaqlSortDirection || (JaqlSortDirection = {}));
+/**
+ * @internal
+ */
+export var CurrencyPosition;
+(function (CurrencyPosition) {
+    CurrencyPosition["PRE"] = "pre";
+    CurrencyPosition["POST"] = "post";
+})(CurrencyPosition = CurrencyPosition || (CurrencyPosition = {}));

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export * from './dimensional-model/data-model.js';
 export * from './dimensional-model/attributes.js';
 export * from './dimensional-model/dimensions.js';
 export * from './dimensional-model/factory.js';
+export * from './dimensional-model/jaql-element.js';
 export * from './dimensional-model/filters/filters.js';
 export { createFilterMatcher } from './dimensional-model/filters/utils/filter-matcher-utils.js';
 /**
@@ -91,3 +92,4 @@ export * from './dimensional-model/simple-column-types.js';
  */
 export * as analyticsFactory from './dimensional-model/analytics/factory.js';
 export * from './utils.js';
+export { type TranslationDictionary, PACKAGE_NAMESPACE as translationNamespace, } from './translation/resources/index.js';

package/dist/index.js

@@ -14,6 +14,7 @@ export * from './dimensional-model/data-model.js';
 export * from './dimensional-model/attributes.js';
 export * from './dimensional-model/dimensions.js';
 export * from './dimensional-model/factory.js';
+export * from './dimensional-model/jaql-element.js';
 export * from './dimensional-model/filters/filters.js';
 export { createFilterMatcher } from './dimensional-model/filters/utils/filter-matcher-utils.js';
 /**
@@ -91,3 +92,4 @@ export * from './dimensional-model/simple-column-types.js';
  */
 export * as analyticsFactory from './dimensional-model/analytics/factory.js';
 export * from './utils.js';
+export { PACKAGE_NAMESPACE as translationNamespace, } from './translation/resources/index.js';

package/dist/translation/resources/en.d.ts

@@ -12,6 +12,7 @@ export declare const translation: {
                 noAttributeDimExpression: string;
                 noAggAggregation: string;
             };
+            notAFormula: string;
         };
         dataModelConfig: {
             noName: string;
@@ -21,8 +22,24 @@ export declare const translation: {
             unsupportedType: string;
             unsupportedDatetimeLevel: string;
             membersFilterNullMember: string;
+            unsupportedConditionFilter: string;
+            formulaFiltersNotSupported: string;
         };
         unsupportedDimensionalElement: string;
     };
 };
+/**
+ * A reference type containing all currently used translation keys.
+ * This type serves as a complete resource for creating custom translations,
+ * ensuring that all required keys are present and included.
+ * It can also be used as Partial to make sure custom translation does not contain any typos.
+ *
+ * @example
+ * ```typescript
+ * import { TranslationDictionary } from '@sisense/sdk-data';
+ *
+ * const customTranslationResources: Partial<TranslationDictionary> = {
+ * ```
+ * @internal
+ */
 export declare type TranslationDictionary = typeof translation;

package/dist/translation/resources/en.js

@@ -12,6 +12,7 @@ export const translation = {
                 noAttributeDimExpression: "DimensionalBaseMeasure must have 'attribute'/'dim'/'expression' property",
                 noAggAggregation: "DimensionalBaseMeasure must have 'agg' or 'aggregation' property",
             },
+            notAFormula: 'Jaql is not a formula',
         },
         dataModelConfig: {
             noName: "'name' must be specified in config for DataModel",
@@ -21,6 +22,8 @@ export const translation = {
             unsupportedType: 'Unsupported filter type: {{filterType}}',
             unsupportedDatetimeLevel: 'Filters do not support the next "datetime" levels: Hours, MinutesRoundTo30, MinutesRoundTo15, Minutes, Seconds',
             membersFilterNullMember: 'MembersFilter of {{attributeId}} - member cannot be null',
+            unsupportedConditionFilter: 'Jaql contains unsupported condition filter: {{filter}}',
+            formulaFiltersNotSupported: 'Formula-based filter not supported yet: {{filter}}',
         },
         unsupportedDimensionalElement: 'Unsupported dimensional element type',
     },

package/dist/translation/resources/index.d.ts

@@ -1,5 +1,11 @@
 import { TranslationDictionary } from './en.js';
 export type { TranslationDictionary };
+/**
+ * A reference to the namespace of the translation resources.
+ * This namespace is used to access the translation resources in the i18next instance.
+ *
+ * @internal
+ */
 export declare const PACKAGE_NAMESPACE: "sdkData";
 export declare const resources: {
     en: {
@@ -13,6 +19,7 @@ export declare const resources: {
                     noAttributeDimExpression: string;
                     noAggAggregation: string;
                 };
+                notAFormula: string;
             };
             dataModelConfig: {
                 noName: string;
@@ -22,6 +29,8 @@ export declare const resources: {
                 unsupportedType: string;
                 unsupportedDatetimeLevel: string;
                 membersFilterNullMember: string;
+                unsupportedConditionFilter: string;
+                formulaFiltersNotSupported: string;
             };
             unsupportedDimensionalElement: string;
         };
@@ -37,6 +46,7 @@ export declare const resources: {
                     noAttributeDimExpression: string;
                     noAggAggregation: string;
                 };
+                notAFormula: string;
             };
             dataModelConfig: {
                 noName: string;
@@ -46,6 +56,8 @@ export declare const resources: {
                 unsupportedType: string;
                 unsupportedDatetimeLevel: string;
                 membersFilterNullMember: string;
+                unsupportedConditionFilter: string;
+                formulaFiltersNotSupported: string;
             };
             unsupportedDimensionalElement: string;
         };