@sisense/sdk-data 0.16.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/factory.js

@@ -46,5 +46,5 @@ export function create(item) {
         item.dimtype) {
         return createDimension(item);
     }
-    throw new TranslatableError('errors.unsupportedDimesionalElement');
+    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

@@ -14,6 +14,7 @@ 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());

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;
+};