@sisense/sdk-data 1.12.0 → 1.14.0

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

@@ -86,6 +86,7 @@ export const FilterTypes = {
     date: 'date',
     relativeDate: 'relativeDate',
     cascading: 'cascading',
+    advanced: 'advanced',
 };
 // CLASSES
 /**
@@ -101,6 +102,29 @@ class AbstractFilter extends DimensionalElement {
         this.attribute = att;
         this.guid = guid || guidFast(13);
         this.disabled = false;
+        this.locked = false;
+    }
+    /**
+     * Boolean flag whether the filter is disabled
+     *
+     * @internal
+     */
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = value;
+    }
+    /**
+     * Boolean flag whether the filter is locked
+     *
+     * @internal
+     */
+    get locked() {
+        return this._locked;
+    }
+    set locked(value) {
+        this._locked = value;
     }
     get name() {
         return hash(this.jaql());
@@ -143,7 +167,9 @@ class AbstractFilter extends DimensionalElement {
         const { granularity } = attribute;
         if (granularity === DateLevels.Hours ||
             granularity === DateLevels.MinutesRoundTo30 ||
-            granularity === DateLevels.MinutesRoundTo15) {
+            granularity === DateLevels.MinutesRoundTo15 ||
+            granularity === DateLevels.Minutes ||
+            granularity === DateLevels.Seconds) {
             throw new TranslatableError('errors.filter.unsupportedDatetimeLevel');
         }
     }
@@ -188,9 +214,11 @@ export class LogicalAttributeFilter extends AbstractFilter {
  * @internal
  */
 export class MembersFilter extends AbstractFilter {
-    constructor(attribute, members, guid) {
+    constructor(attribute, members, _deactivatedMembers, guid, backgroundFilter) {
         super(attribute, FilterTypes.members, guid);
         this.members = members !== null && members !== void 0 ? members : [];
+        this._deactivatedMembers = _deactivatedMembers !== null && _deactivatedMembers !== void 0 ? _deactivatedMembers : [];
+        this.backgroundFilter = backgroundFilter;
         if (this.members.filter((m) => m === null || m === undefined).length > 0) {
             throw new TranslatableError('errors.filter.membersFilterNullMember', {
                 attributeId: attribute.id,
@@ -209,15 +237,24 @@ export class MembersFilter extends AbstractFilter {
     serializable() {
         const result = super.serializable();
         result.members = this.members;
+        if (this.backgroundFilter) {
+            result.backgroundFilter = this.backgroundFilter.serializable();
+        }
         return result;
     }
     /**
      * Gets JAQL representing this Filter instance
      */
     filterJaql() {
-        return {
+        const filterJaql = {
             members: this.members.map((m) => m.toString()),
         };
+        if (this.backgroundFilter) {
+            return {
+                and: [filterJaql, this.backgroundFilter.filterJaql()],
+            };
+        }
+        return filterJaql;
     }
 }
 /**
@@ -234,6 +271,28 @@ export class CascadingFilter extends AbstractFilter {
     get id() {
         return `${this.filterType}_${this.filters.map((f) => f.id).join()}`;
     }
+    get disabled() {
+        return super.disabled;
+    }
+    set disabled(value) {
+        super.disabled = value;
+        if (this.filters) {
+            this.filters.forEach((filter) => {
+                filter.disabled = value;
+            });
+        }
+    }
+    get locked() {
+        return super.locked;
+    }
+    set locked(value) {
+        super.locked = value;
+        if (this.filters) {
+            this.filters.forEach((filter) => {
+                filter.locked = value;
+            });
+        }
+    }
     /**
      * Gets a serializable representation of the element
      */
@@ -556,6 +615,30 @@ export class RelativeDateFilter extends AbstractFilter {
         return result;
     }
 }
+/**
+ * @internal
+ */
+export class CustomFilter extends AbstractFilter {
+    constructor(att, jaql, guid) {
+        super(att, FilterTypes.advanced, guid);
+        // remove filterType from jaql as it is not needed
+        delete jaql.filterType;
+        this.jaqlExpression = jaql;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `custom_${this.attribute.id}_${this.guid}`;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     *
+     */
+    filterJaql() {
+        return this.jaqlExpression;
+    }
+}
 /**
  * @param json - Filter JSON representation
  * @internal

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

@@ -81,7 +81,7 @@ export const getSelectedConditionOption = (filter) => {
  * @returns attribute filter
  */
 export const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, guid) => {
-    var _a, _b;
+    var _a, _b, _c;
     const conditionType = getSelectedConditionOption(conditionFilterJaql);
     switch (conditionType) {
         case ConditionFilterType.BOTTOM:
@@ -119,7 +119,7 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
         case ConditionFilterType.BETWEEN:
             return withComposeCode(filterFactory.between)(attribute, conditionFilterJaql.from, conditionFilterJaql.to, guid);
         case ConditionFilterType.IS_NOT_BETWEEN:
-            return withComposeCode(filterFactory.exclude)(withComposeCode(filterFactory.between)(attribute, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to, guid));
+            return withComposeCode(filterFactory.exclude)(withComposeCode(filterFactory.between)(attribute, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to, guid), undefined, guid);
         case ConditionFilterType.MULTIPLE_CONDITION:
             if (conditionFilterJaql.and) {
                 return withComposeCode(filterFactory.intersection)(conditionFilterJaql.and.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), guid);
@@ -128,6 +128,8 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
                 return withComposeCode(filterFactory.union)(conditionFilterJaql.or.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), guid);
             }
             break;
+        case ConditionFilterType.IS_NOT:
+            return withComposeCode(filterFactory.exclude)(withComposeCode(filterFactory.members)(attribute, ((_c = conditionFilterJaql.exclude) === null || _c === void 0 ? void 0 : _c.members) || [], undefined, guid), undefined, guid);
         case ConditionFilterType.AFTER:
         case ConditionFilterType.BEFORE:
         case ConditionFilterType.IS_EMPTY:

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

@@ -40,7 +40,11 @@ export function stringifyHelper(arg) {
  */
 export function withComposeCode(func) {
     return function (...args) {
-        const argValues = args.map(stringifyHelper).join(', ').replace(/, $/, '');
+        const argValues = args
+            .map(stringifyHelper)
+            .join(', ')
+            // remove any number of trailing commas
+            .replace(/(,\s*)+$/, '');
         const signature = `filterFactory.${func.name}(${argValues})`;
         const filter = func(...args);
         filter.composeCode = signature;

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

@@ -1,4 +1,4 @@
-import { ConditionFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
+import { BaseFilterJaql, ConditionFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
 import { Attribute, BaseMeasure, Filter, LevelAttribute } from '../../interfaces.js';
 import { FilterJaql } from '../../types.js';
 /**
@@ -63,6 +63,15 @@ export declare const createFilterFromPeriodFilterJaql: (attribute: LevelAttribut
  * @returns Filter object
  */
 export declare const createFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql, measure?: BaseMeasure, guid?: string) => Filter;
+/**
+ * Creates a filter from a custom filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param customFilterJaql - Custom Filter Jaql
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+export declare const createFilterFromCustomFilterJaql: (attribute: Attribute, customFilterJaql: BaseFilterJaql, guid?: string) => Filter;
 /**
  * Creates a filter from a filter JAQL object.
  *

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

@@ -44,7 +44,7 @@ export const createGenericFilter = (jaql, guid) => {
  * @returns The created Filter object.
  */
 export const createFilterIncludeAll = (attribute, guid) => {
-    return withComposeCode(filterFactory.members)(attribute, [], guid);
+    return withComposeCode(filterFactory.members)(attribute, [], [], guid);
 };
 /**
  * Creates a filter from a specific items filter JAQL object.
@@ -55,8 +55,20 @@ export const createFilterIncludeAll = (attribute, guid) => {
  * @returns Filter object
  */
 export const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJaql, guid) => {
-    return withComposeCode(filterFactory.members)(attribute, specificItemsFilterJaql.members, guid);
+    const deactivatedMembers = getDeactivatedMembersFromFilterJaql(specificItemsFilterJaql);
+    const activeMembers = getActiveMembersFromFilterJaql(specificItemsFilterJaql, deactivatedMembers);
+    return withComposeCode(filterFactory.members)(attribute, activeMembers, deactivatedMembers, guid);
 };
+function getDeactivatedMembersFromFilterJaql(filterJaql) {
+    var _a, _b, _c;
+    return ((_a = filterJaql.filter) === null || _a === void 0 ? void 0 : _a.turnedOff) ? (_c = (_b = filterJaql.filter) === null || _b === void 0 ? void 0 : _b.exclude) === null || _c === void 0 ? void 0 : _c.members : undefined;
+}
+function getActiveMembersFromFilterJaql(filterJaql, deactivatedMembers) {
+    const allMembers = filterJaql.members;
+    return deactivatedMembers
+        ? allMembers.filter((member) => !deactivatedMembers.includes(member))
+        : allMembers;
+}
 /**
  * Creates a filter from a date range filter JAQL object.
  *
@@ -112,6 +124,17 @@ export const createFilterFromConditionFilterJaql = (attribute, conditionFilterJa
         return createAttributeFilterFromConditionFilterJaql(attribute, conditionFilterJaql, guid);
     }
 };
+/**
+ * Creates a filter from a custom filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param customFilterJaql - Custom Filter Jaql
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+export const createFilterFromCustomFilterJaql = (attribute, customFilterJaql, guid) => {
+    return withComposeCode(filterFactory.customFilter)(attribute, customFilterJaql, guid);
+};
 /**
  * Creates a filter from a filter JAQL object.
  *
@@ -144,6 +167,7 @@ export const createFilterFromJaqlInternal = (jaql, guid) => {
             case FILTER_TYPES.NUMERIC_RANGE:
                 return createFilterFromNumericRangeJaql(attribute, filterJaqlWithType, guid);
             case FILTER_TYPES.ADVANCED:
+                return createFilterFromCustomFilterJaql(attribute, filterJaqlWithType, guid);
             case FILTER_TYPES.INVALID:
                 return createGenericFilter(jaql, guid);
         }

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

@@ -29,6 +29,8 @@ const isInvalidFilter = (filter) => filter.filterType === FILTER_TYPES.INVALID;
 export const getFilterType = (filter, dataType = FilterModalType.DATE_TIME, timeData) => {
     if (timeData && isTimeLevelNotSupported(timeData))
         return FILTER_TYPES.ADVANCED;
+    if (isAdvancedFilter(filter))
+        return FILTER_TYPES.ADVANCED;
     if (isIncludeAllFilter(filter))
         return FILTER_TYPES.INCLUDE_ALL;
     if (isPeriodFilter(filter))
@@ -41,11 +43,9 @@ export const getFilterType = (filter, dataType = FilterModalType.DATE_TIME, time
         return FILTER_TYPES.NUMERIC_RANGE;
     if (isConditionFilter(filter))
         return FILTER_TYPES.CONDITION;
-    if (isAdvancedFilter(filter))
-        return FILTER_TYPES.ADVANCED;
     if (isInvalidFilter(filter))
         return FILTER_TYPES.INVALID;
-    return FILTER_TYPES.ADVANCED;
+    return FILTER_TYPES.INVALID;
 };
 /**
  * Extracts Filter Type from Filter Jaql

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

@@ -70,6 +70,12 @@ export declare type FilterMultiSelectJaql = {
     multiSelection: boolean;
     members: string[];
     isCondition?: boolean;
+    filter?: {
+        turnedOff?: boolean;
+        exclude?: {
+            members?: string[];
+        };
+    };
 };
 export declare type FilterMultipleConditionJaql = {
     or: ConditionFilterJaql[];

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

@@ -249,6 +249,14 @@ export interface DateDimension extends Dimension {
      * Minutes (round to 15) level (for Live Models)
      */
     readonly MinutesRoundTo15: LevelAttribute;
+    /**
+     * Minutes level (for Live Models)
+     */
+    readonly Minutes: LevelAttribute;
+    /**
+     * Seconds level (for Live Models)
+     */
+    readonly Seconds: LevelAttribute;
     /**
      * Aggregated Hours level (for Live Models)
      */
@@ -346,6 +354,12 @@ export interface Filter extends Element {
      * @internal
      */
     disabled: boolean;
+    /**
+     * Boolean flag whether the filter is locked
+     *
+     * @internal
+     */
+    locked: boolean;
     /**
      * Gets JAQL representing this Filter instance
      *

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

@@ -144,6 +144,8 @@ export declare const DateLevels: {
     Hours: string;
     MinutesRoundTo30: string;
     MinutesRoundTo15: string;
+    Minutes: string;
+    Seconds: string;
     AggHours: string;
     AggMinutesRoundTo30: string;
     AggMinutesRoundTo15: string;

package/dist/dimensional-model/types.js

@@ -258,6 +258,8 @@ export const DateLevels = {
     Hours: 'Hours',
     MinutesRoundTo30: 'MinutesRoundTo30',
     MinutesRoundTo15: 'MinutesRoundTo15',
+    Minutes: 'Minutes',
+    Seconds: 'Seconds',
     AggHours: 'AggHours',
     AggMinutesRoundTo30: 'AggMinutesRoundTo30',
     AggMinutesRoundTo15: 'AggMinutesRoundTo15',
@@ -273,6 +275,8 @@ export const DateLevels = {
             DateLevels.Hours,
             DateLevels.MinutesRoundTo30,
             DateLevels.MinutesRoundTo15,
+            DateLevels.Minutes,
+            DateLevels.Seconds,
             DateLevels.AggHours,
             DateLevels.AggMinutesRoundTo30,
             DateLevels.AggMinutesRoundTo15,

package/dist/interfaces.d.ts

@@ -288,7 +288,7 @@ export declare const EMPTY_PIVOT_QUERY_RESULT_DATA: PivotQueryResultData;
  * @param arg
  * @internal
  */
-export declare function isDataSource(arg: DataSource | Data | undefined): arg is DataSource;
+export declare function isDataSource(arg: DataSource | Data | undefined): arg is DataSource | undefined;
 /**
  * Trend formula options.
  */

package/dist/translation/resources/en.js

@@ -19,7 +19,7 @@ export const translation = {
         },
         filter: {
             unsupportedType: 'Unsupported filter type: {{filterType}}',
-            unsupportedDatetimeLevel: 'Filters do not support the next "datetime" levels: Hours, MinutesRoundTo30, MinutesRoundTo15',
+            unsupportedDatetimeLevel: 'Filters do not support the next "datetime" levels: Hours, MinutesRoundTo30, MinutesRoundTo15, Minutes, Seconds',
             membersFilterNullMember: 'MembersFilter of {{attributeId}} - member cannot be null',
         },
         unsupportedDimensionalElement: 'Unsupported dimensional element type',

package/dist/translation/resources/uk.js

@@ -19,7 +19,7 @@ export const translation = {
         },
         filter: {
             unsupportedType: 'Непідтримуваний тип фільтра: {{filterType}}',
-            unsupportedDatetimeLevel: 'Фільтри не підтримують наступні рівні "datetime": Hours, MinutesRoundTo30, MinutesRoundTo15',
+            unsupportedDatetimeLevel: 'Фільтри не підтримують наступні рівні "datetime": Hours, MinutesRoundTo30, MinutesRoundTo15, Minutes, Seconds',
             membersFilterNullMember: 'MembersFilter у {{attributeId}} - member не може бути нульовим',
         },
         unsupportedDimensionalElement: 'Непідтримуваний тип елемента',

package/dist/utils.js

@@ -89,6 +89,10 @@ export function isDataSourceInfo(dataSource) {
 export const createFilterFromJaql = (jaql, instanceid) => {
     // translation logic is based on FilterJaqlInternal type (from internal modern-analytics-filters)
     // TODO reconcile FilterJaql and FilterJaqlInternal
-    const jaqlInternal = jaql;
-    return createFilterFromJaqlInternal(jaqlInternal, instanceid);
+    const hasBackgroundFilter = jaql.filter.filter && !('turnedOff' in jaql.filter.filter);
+    const filter = createFilterFromJaqlInternal(jaql, instanceid);
+    if (hasBackgroundFilter) {
+        filter.backgroundFilter = createFilterFromJaqlInternal(Object.assign(Object.assign({}, jaql), { filter: jaql.filter.filter }), `${instanceid}-bg`);
+    }
+    return filter;
 };

package/package.json

@@ -11,7 +11,7 @@
     "Sisense",
     "Compose SDK"
   ],
-  "version": "1.12.0",
+  "version": "1.14.0",
   "type": "module",
   "main": "./dist/cjs/index.js",
   "module": "./dist/index.js",
@@ -32,8 +32,8 @@
   "author": "Sisense",
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@sisense/sdk-common": "^1.12.0",
-    "@sisense/sdk-rest-client": "^1.12.0",
+    "@sisense/sdk-common": "^1.14.0",
+    "@sisense/sdk-rest-client": "^1.14.0",
     "guid-typescript": "^1.0.9",
     "lodash": "^4.17.21",
     "numeral": "^2.0.6",