@sisense/sdk-data 0.15.0 → 1.0.0

package/dist/dimensional-model/analytics/factory.d.ts

@@ -0,0 +1,47 @@
+import type { Attribute, Measure } from '../interfaces.js';
+/** @internal */
+export declare const BOX_WHISKER: {
+    BOX_MIN_VALUE_NAME: string;
+    BOX_MEDIAN_VALUE_NAME: string;
+    BOX_MAX_VALUE_NAME: string;
+    WHISKER_MIN_VALUE_NAME: string;
+    WHISKER_MAX_VALUE_NAME: string;
+    OUTLIER_COUNT_VALUE_NAME: string;
+    OUTLIER_MIN_VALUE_NAME: string;
+    OUTLIER_MAX_VALUE_NAME: string;
+};
+/**
+ * Returns an array of values for box whisker plot using interquartile range (IQR) calculations.
+ *
+ * @param {Attribute} target - The target attribute for calculations.
+ * @returns {Measure[]} An array of measures representing IQR values for box whisker plots.
+ */
+export declare function boxWhiskerIqrValues(target: Attribute): Measure[];
+/**
+ * Returns an array of extremum values for box whisker plot.
+ *
+ * @param {Attribute} target - The target attribute for calculations.
+ * @returns {Measure[]} An array of measures representing extremum values for box whisker plots.
+ */
+export declare function boxWhiskerExtremumsValues(target: Attribute): Measure[];
+/**
+ * Returns an array of values for box whisker plot using standard deviation calculations.
+ *
+ * @param {Attribute} target - The target attribute for calculations.
+ * @returns {Measure[]} An array of measures representing standard deviation values for box whisker plots.
+ */
+export declare function boxWhiskerStdDevValues(target: Attribute): Measure[];
+/**
+ * Returns an attribute representing outlier points based on interquartile range (IQR) calculations.
+ *
+ * @param {Attribute} target - The target attribute for calculations.
+ * @returns {Attribute} An attribute representing outliers for box whisker plots using IQR.
+ */
+export declare const boxWhiskerIqrOutliers: (target: Attribute) => Attribute;
+/**
+ * Returns an attribute representing outlier points based on standard deviation calculations.
+ *
+ * @param {Attribute} target - The target attribute for calculations.
+ * @returns {Attribute} An attribute representing outliers for box whisker plots using standard deviation.
+ */
+export declare const boxWhiskerStdDevOutliers: (target: Attribute) => Attribute;

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

@@ -0,0 +1,140 @@
+import cloneDeep from 'lodash/cloneDeep.js';
+import { customFormula } from '../measures/factory.js';
+/** @internal */
+export const BOX_WHISKER = {
+    BOX_MIN_VALUE_NAME: 'Box Min',
+    BOX_MEDIAN_VALUE_NAME: 'Box Median',
+    BOX_MAX_VALUE_NAME: 'Box Max',
+    WHISKER_MIN_VALUE_NAME: 'Whisker Min',
+    WHISKER_MAX_VALUE_NAME: 'Whisker Max',
+    OUTLIER_COUNT_VALUE_NAME: 'Outlier Count',
+    OUTLIER_MIN_VALUE_NAME: 'Outlier Min',
+    OUTLIER_MAX_VALUE_NAME: 'Outlier Max',
+};
+function boxWhiskerCommonValues(target) {
+    return [
+        customFormula(BOX_WHISKER.BOX_MIN_VALUE_NAME, 'QUARTILE([Attr], 1)', {
+            Attr: target,
+        }),
+        customFormula(BOX_WHISKER.BOX_MEDIAN_VALUE_NAME, 'MEDIAN([Attr])', {
+            Attr: target,
+        }),
+        customFormula(BOX_WHISKER.BOX_MAX_VALUE_NAME, 'QUARTILE([Attr], 3)', {
+            Attr: target,
+        }),
+    ];
+}
+/**
+ * Returns an array of values for box whisker plot using interquartile range (IQR) calculations.
+ *
+ * @param {Attribute} target - The target attribute for calculations.
+ * @returns {Measure[]} An array of measures representing IQR values for box whisker plots.
+ */
+export function boxWhiskerIqrValues(target) {
+    return [
+        ...boxWhiskerCommonValues(target),
+        customFormula(BOX_WHISKER.WHISKER_MIN_VALUE_NAME, 'LOWERWHISKERMAX_IQR([Attr])', {
+            Attr: target,
+        }),
+        customFormula(BOX_WHISKER.WHISKER_MAX_VALUE_NAME, 'UPPERWHISKERMIN_IQR([Attr])', {
+            Attr: target,
+        }),
+        customFormula(BOX_WHISKER.OUTLIER_COUNT_VALUE_NAME, 'OUTLIERSCOUNT_IQR([Attr])', {
+            Attr: target,
+        }),
+    ];
+}
+/**
+ * Returns an array of extremum values for box whisker plot.
+ *
+ * @param {Attribute} target - The target attribute for calculations.
+ * @returns {Measure[]} An array of measures representing extremum values for box whisker plots.
+ */
+export function boxWhiskerExtremumsValues(target) {
+    return [
+        ...boxWhiskerCommonValues(target),
+        customFormula(BOX_WHISKER.WHISKER_MIN_VALUE_NAME, 'MIN([Attr])', {
+            Attr: target,
+        }),
+        customFormula(BOX_WHISKER.WHISKER_MAX_VALUE_NAME, 'MAX([Attr])', {
+            Attr: target,
+        }),
+    ];
+}
+/**
+ * Returns an array of values for box whisker plot using standard deviation calculations.
+ *
+ * @param {Attribute} target - The target attribute for calculations.
+ * @returns {Measure[]} An array of measures representing standard deviation values for box whisker plots.
+ */
+export function boxWhiskerStdDevValues(target) {
+    return [
+        ...boxWhiskerCommonValues(target),
+        customFormula(BOX_WHISKER.WHISKER_MIN_VALUE_NAME, 'LOWERWHISKERMAX_STDEVP([Attr])', {
+            Attr: target,
+        }),
+        customFormula(BOX_WHISKER.WHISKER_MAX_VALUE_NAME, 'UPPERWHISKERMIN_STDEVP([Attr])', {
+            Attr: target,
+        }),
+        customFormula(BOX_WHISKER.OUTLIER_COUNT_VALUE_NAME, 'OUTLIERSCOUNT_STDEVP([Attr])', {
+            Attr: target,
+        }),
+    ];
+}
+/**
+ * Returns an attribute representing outlier points based on interquartile range (IQR) calculations.
+ *
+ * @param {Attribute} target - The target attribute for calculations.
+ * @returns {Attribute} An attribute representing outliers for box whisker plots using IQR.
+ */
+export const boxWhiskerIqrOutliers = (target) => {
+    const outliersAttrWithInnerFilter = cloneDeep(target);
+    const outliersMax = customFormula(BOX_WHISKER.OUTLIER_MAX_VALUE_NAME, '(UPPERWHISKERMIN_IQR([Attr]), all([Attr]))', {
+        Attr: target,
+    });
+    const outliersMin = customFormula(BOX_WHISKER.OUTLIER_MIN_VALUE_NAME, '(LOWERWHISKERMAX_IQR([Attr]), all([Attr]))', {
+        Attr: target,
+    });
+    outliersAttrWithInnerFilter.name = `${outliersAttrWithInnerFilter.name} (Outliers)`;
+    outliersAttrWithInnerFilter.jaql = () => {
+        return Object.assign(Object.assign({}, target.jaql()), { filter: {
+                or: [
+                    {
+                        fromNotEqual: outliersMax.jaql(true),
+                    },
+                    {
+                        toNotEqual: outliersMin.jaql(true),
+                    },
+                ],
+            } });
+    };
+    return outliersAttrWithInnerFilter;
+};
+/**
+ * Returns an attribute representing outlier points based on standard deviation calculations.
+ *
+ * @param {Attribute} target - The target attribute for calculations.
+ * @returns {Attribute} An attribute representing outliers for box whisker plots using standard deviation.
+ */
+export const boxWhiskerStdDevOutliers = (target) => {
+    const outliersAttrWithInnerFilter = cloneDeep(target);
+    const outliersMax = customFormula(BOX_WHISKER.OUTLIER_MAX_VALUE_NAME, '(UPPERWHISKERMIN_STDEVP([Attr]), all([Attr]))', {
+        Attr: target,
+    });
+    const outliersMin = customFormula(BOX_WHISKER.OUTLIER_MIN_VALUE_NAME, '(LOWERWHISKERMAX_STDEVP([Attr]), all([Attr]))', {
+        Attr: target,
+    });
+    outliersAttrWithInnerFilter.jaql = () => {
+        return Object.assign(Object.assign({}, target.jaql()), { filter: {
+                or: [
+                    {
+                        fromNotEqual: outliersMax.jaql(true),
+                    },
+                    {
+                        toNotEqual: outliersMin.jaql(true),
+                    },
+                ],
+            } });
+    };
+    return outliersAttrWithInnerFilter;
+};

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

@@ -1,4 +1,5 @@
 import { create } from './factory.js';
+import { TranslatableError } from '../translation/translatable-error.js';
 /**
  * @internal
  */
@@ -17,11 +18,11 @@ export class DimensionalDataModel {
         }
     }
     static fromConfig(config) {
-        if (!config && config.name) {
-            throw new Error('name must be specified');
+        if (config && !config.name) {
+            throw new TranslatableError('errors.dataModel.noName');
         }
-        if (!config && config.metadata) {
-            throw new Error('metadata must be specified');
+        if (config && !config.metadata) {
+            throw new TranslatableError('errors.dataModel.noMetadata');
         }
         const metadata = new Array();
         for (let i = 0; i < config.metadata.length; i++) {

package/dist/dimensional-model/factory.js

@@ -1,11 +1,11 @@
 /* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-throw-literal */
 import { MetadataTypes } from './types.js';
 import { createMeasure } from './measures/measures.js';
 import { createFilter } from './filters/filters.js';
 import { createDimension } from './dimensions.js';
 import { createAttribute } from './attributes.js';
+import { TranslatableError } from '../translation/translatable-error.js';
 /**
  * Generate an array of dimension model instances out of the given JSON array
  *
@@ -46,5 +46,5 @@ export function create(item) {
         item.dimtype) {
         return createDimension(item);
     }
-    throw 'unsupported';
+    throw new TranslatableError('errors.unsupportedDimensionalElement');
 }

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

@@ -1,4 +1,4 @@
-import { DateDimension, LevelAttribute, Attribute, Measure, Filter, BaseMeasure } from '../interfaces.js';
+import { DateDimension, LevelAttribute, Attribute, Measure, Filter, BaseMeasure, FilterRelationNode, FilterRelation } from '../interfaces.js';
 /**
  * Creates a filter representing a union of multiple filters of the same attribute.
  *
@@ -313,3 +313,36 @@ export declare function topRanking(attribute: Attribute, measure: Measure, count
  * @returns A filter representing a bottom ranking logic on the given attribute by the given measure
  */
 export declare function bottomRanking(attribute: Attribute, measure: Measure, count: number): Filter;
+/**
+ * Set of logic operators for filter relation construction
+ *
+ * These operators are still in beta.
+ *
+ * @example
+ ```tsx
+ import { filters } from '@sisense/sdk-data';
+
+ // define filters
+ const revenueFilter = filters.greaterThan(DM.Commerce.Revenue, 1000);
+ const countryFilter = filters.members(DM.Commerce.Country, ['USA', 'Canada']);
+ const genderFilter = filters.doesntContain(DM.Commerce.Gender, 'Unspecified');
+ const costFilter = filters.between(DM.Commerce.Cost, 1000, 2000);
+
+ // create filter relation of two filters
+ const orFilerRelations = filterFactory.logic.or(revenueFilter, countryFilter);
+ // revenueFilter OR countryFilter
+
+ // filter relations can have nested filter relations
+ const mixedFilterRelations = filterFactory.logic.and(genderFilter, orFilerRelations);
+ // genderFilter AND (revenueFilter OR countryFilter)
+
+ // array, specified in filter relations, will be converted to an intersection of filters automatically
+ const arrayFilterRelations = filterFactory.logic.or([genderFilter, costFilter], mixedFilterRelations);
+ // (genderFilter AND costFilter) OR (genderFilter AND (revenueFilter OR countryFilter))
+ ```
+ * @beta
+ */
+export declare namespace logic {
+    const and: (left: FilterRelationNode, right: FilterRelationNode) => FilterRelation;
+    const or: (left: FilterRelationNode, right: FilterRelationNode) => FilterRelation;
+}

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

@@ -402,3 +402,59 @@ export function topRanking(attribute, measure, count) {
 export function bottomRanking(attribute, measure, count) {
     return new RankingFilter(attribute, measure, RankingOperators.Bottom, count);
 }
+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;
+};
+/**
+ * Set of logic operators for filter relation construction
+ *
+ * These operators are still in beta.
+ *
+ * @example
+ ```tsx
+ import { filters } from '@sisense/sdk-data';
+
+ // define filters
+ const revenueFilter = filters.greaterThan(DM.Commerce.Revenue, 1000);
+ const countryFilter = filters.members(DM.Commerce.Country, ['USA', 'Canada']);
+ const genderFilter = filters.doesntContain(DM.Commerce.Gender, 'Unspecified');
+ const costFilter = filters.between(DM.Commerce.Cost, 1000, 2000);
+
+ // create filter relation of two filters
+ const orFilerRelations = filterFactory.logic.or(revenueFilter, countryFilter);
+ // revenueFilter OR countryFilter
+
+ // filter relations can have nested filter relations
+ const mixedFilterRelations = filterFactory.logic.and(genderFilter, orFilerRelations);
+ // genderFilter AND (revenueFilter OR countryFilter)
+
+ // array, specified in filter relations, will be converted to an intersection of filters automatically
+ const arrayFilterRelations = filterFactory.logic.or([genderFilter, costFilter], mixedFilterRelations);
+ // (genderFilter AND costFilter) OR (genderFilter AND (revenueFilter OR countryFilter))
+ ```
+ * @beta
+ */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var logic;
+(function (logic) {
+    logic.and = (left, right) => ({
+        operator: 'AND',
+        left: relate(left),
+        right: relate(right),
+    });
+    logic.or = (left, right) => ({
+        operator: 'OR',
+        left: relate(left),
+        right: relate(right),
+    });
+})(logic = logic || (logic = {}));

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

@@ -88,6 +88,10 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
      * Filter type
      */
     readonly filterType: string;
+    /**
+     * Global filter identifier
+     */
+    readonly guid: string;
     constructor(att: Attribute, filterType: string);
     get name(): string;
     /**

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

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-throw-literal */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable max-lines */
 /* eslint-disable max-params */
@@ -14,6 +13,8 @@ import { DimensionalElement } from '../base.js';
 import { DateLevels, MetadataTypes } from '../types.js';
 import { create } from '../factory.js';
 import { DimensionalBaseMeasure } from '../measures/measures.js';
+import { TranslatableError } from '../../translation/translatable-error.js';
+import { guidFast } from '../../utils.js';
 /**
  * Different text operators that can be used with text filters
  *
@@ -100,6 +101,7 @@ class AbstractFilter extends DimensionalElement {
         this.filterType = filterType;
         AbstractFilter.checkAttributeSupport(att);
         this.attribute = att;
+        this.guid = guidFast(13);
     }
     get name() {
         return hash(this.jaql());
@@ -140,7 +142,7 @@ class AbstractFilter extends DimensionalElement {
         if (granularity === DateLevels.Hours ||
             granularity === DateLevels.MinutesRoundTo30 ||
             granularity === DateLevels.MinutesRoundTo15) {
-            throw new Error('Filters do not support the next "datetime" levels: Hours, MinutesRoundTo30, MinutesRoundTo15');
+            throw new TranslatableError('errors.filter.unsupportedDatetimeLevel');
         }
     }
 }
@@ -185,7 +187,9 @@ export class MembersFilter extends AbstractFilter {
         super(attribute, FilterTypes.members);
         this.members = members !== null && members !== void 0 ? members : [];
         if (this.members.filter((m) => m === null || m === undefined).length > 0) {
-            throw `MembersFilter of ${attribute.id} - member cannot be null`;
+            throw new TranslatableError('errors.filter.membersFilterNullMember', {
+                attributeId: attribute.id,
+            });
         }
     }
     /**
@@ -399,9 +403,6 @@ export class RankingFilter extends AbstractFilter {
 export class NumericFilter extends DoubleOperatorFilter {
     constructor(att, operatorA, valueA, operatorB, valueB) {
         super(att, FilterTypes.numeric, operatorA, valueA, operatorB, valueB);
-        // if (att.dimension && !MetadataTypes.isTextDimension(att.dimension.type)) {
-        //     throw 'Dimension must be of Text type to be applied with Text filter';
-        // }
     }
 }
 /**
@@ -410,9 +411,6 @@ export class NumericFilter extends DoubleOperatorFilter {
 export class TextFilter extends DoubleOperatorFilter {
     constructor(att, operator, value) {
         super(att, FilterTypes.text, operator, value);
-        // if (att.dimension && !MetadataTypes.isTextDimension(att.dimension.type)) {
-        //     throw 'Dimension must be of Text type to be applied with Text filter';
-        // }
     }
 }
 /**
@@ -544,5 +542,7 @@ export function createFilter(json) {
             return new DateRangeFilter(create(json.attribute), json.valueA, json.valueB);
             break;
     }
-    throw 'unsupported filter type';
+    throw new TranslatableError('errors.filter.unsupportedType', {
+        filterType: json.filterType,
+    });
 }

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

@@ -62,7 +62,7 @@ export interface Element {
 }
 /**
  * Base interface for measure, which is typically numeric aggregation over {@link Attribute}(s).
- * See {@link measures} for how to create measures.
+ * See {@link measureFactory} for how to create measures.
  *
  */
 export interface Measure extends Element {
@@ -321,9 +321,13 @@ export interface LevelAttribute extends Attribute {
     };
 }
 /**
- * Base interface for filter. See {@link filters} for how to create filters.
+ * Base interface for filter. See {@link filterFactory} for how to create filters.
  */
 export interface Filter extends Element {
+    /**
+     * Global filter identifier
+     */
+    readonly guid: string;
     /**
      * Attribute this filter instance is filtering
      */
@@ -342,3 +346,12 @@ export interface Filter extends Element {
 export interface CustomFormulaContext {
     [key: string]: Attribute | Measure;
 }
+export declare type FilterRelationNode = Filter | Filter[] | FilterRelation | FilterRelationJaqlNode;
+export interface FilterRelation {
+    left: FilterRelationNode;
+    right: FilterRelationNode;
+    operator: 'AND' | 'OR';
+}
+export declare type FilterRelationJaqlNode = {
+    instanceid: string;
+};