@sisense/sdk-data 1.11.0 → 1.13.0

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

@@ -1,67 +1,82 @@
-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';
 /**
  * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
  *
  * @param jaql - The JAQL object.
- * @param instanceid - The instance ID.
+ * @param guid - Optional GUID for the filter
  * @returns A generic Filter object.
  */
-export declare const createGenericFilter: (jaql: FilterJaql | FilterJaqlInternal, instanceid?: string) => Filter;
+export declare const createGenericFilter: (jaql: FilterJaql | FilterJaqlInternal, guid?: string) => Filter;
 /**
  * Creates a filter that includes all members of the attribute.
  *
  * @param attribute - The attribute.
+ * @param guid - Optional GUID for the filter
  * @returns The created Filter object.
  */
-export declare const createFilterIncludeAll: (attribute: Attribute) => Filter;
+export declare const createFilterIncludeAll: (attribute: Attribute, guid?: string) => Filter;
 /**
  * Creates a filter from a specific items filter JAQL object.
  *
  * @param attribute - attribute
  * @param specificItemsFilterJaql - Specific Items Filter Jaql
+ * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql) => Filter;
+export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql, guid?: string) => Filter;
 /**
  * Creates a filter from a date range filter JAQL object.
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
+ * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromDateRangeFilterJaql: (attribute: LevelAttribute, rangeFilterJaql: RangeFilterJaql) => Filter;
+export declare const createFilterFromDateRangeFilterJaql: (attribute: LevelAttribute, rangeFilterJaql: RangeFilterJaql, guid?: string) => Filter;
 /**
  * Creates a filter from a numeric range filter JAQL object.
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
+ * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromNumericRangeJaql: (attribute: Attribute, rangeFilterJaql: RangeFilterJaql) => Filter;
+export declare const createFilterFromNumericRangeJaql: (attribute: Attribute, rangeFilterJaql: RangeFilterJaql, guid?: string) => Filter;
 /**
  * Creates a filter from a period filter JAQL object.
  *
  * @param attribute - attribute
  * @param periodFilterJaql - Period Filter Jaql
+ * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromPeriodFilterJaql: (attribute: LevelAttribute, periodFilterJaql: PeriodFilterJaql) => Filter;
+export declare const createFilterFromPeriodFilterJaql: (attribute: LevelAttribute, periodFilterJaql: PeriodFilterJaql, guid?: string) => Filter;
 /**
  * Creates a filter from a condition filter JAQL object.
  *
  * @param attribute - attribute
  * @param conditionFilterJaql - Condition Filter Jaql
  * @param measure - measure
+ * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql, measure?: BaseMeasure) => Filter;
+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.
  *
  * @param jaql - The filter JAQL object.
- * @param instanceid - The instance ID.
+ * @param guid - Optional GUID for the filter
  * @returns Filter object.
  */
-export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, instanceid?: string) => Filter;
+export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, guid?: string) => Filter;

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

@@ -4,16 +4,17 @@ import { createAttributeFilterFromConditionFilterJaql, createMeasureFilterFromCo
 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';
 /**
  * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
  *
  * @param jaql - The JAQL object.
- * @param instanceid - The instance ID.
+ * @param guid - Optional GUID for the filter
  * @returns A generic Filter object.
  */
-export const createGenericFilter = (jaql, instanceid) => {
+export const createGenericFilter = (jaql, guid) => {
     return {
-        guid: instanceid,
+        guid: guid || guidFast(13),
         jaql: (nested) => {
             if (nested) {
                 return jaql;
@@ -39,54 +40,71 @@ export const createGenericFilter = (jaql, instanceid) => {
  * Creates a filter that includes all members of the attribute.
  *
  * @param attribute - The attribute.
+ * @param guid - Optional GUID for the filter
  * @returns The created Filter object.
  */
-export const createFilterIncludeAll = (attribute) => {
-    return withComposeCode(filterFactory.members)(attribute, []);
+export const createFilterIncludeAll = (attribute, guid) => {
+    return withComposeCode(filterFactory.members)(attribute, [], [], guid);
 };
 /**
  * Creates a filter from a specific items filter JAQL object.
  *
  * @param attribute - attribute
  * @param specificItemsFilterJaql - Specific Items Filter Jaql
+ * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJaql) => {
-    return withComposeCode(filterFactory.members)(attribute, specificItemsFilterJaql.members);
+export const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJaql, 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.
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
+ * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export const createFilterFromDateRangeFilterJaql = (attribute, rangeFilterJaql) => {
-    return withComposeCode(filterFactory.dateRange)(attribute, rangeFilterJaql.from, rangeFilterJaql.to);
+export const createFilterFromDateRangeFilterJaql = (attribute, rangeFilterJaql, guid) => {
+    return withComposeCode(filterFactory.dateRange)(attribute, rangeFilterJaql.from, rangeFilterJaql.to, guid);
 };
 /**
  * Creates a filter from a numeric range filter JAQL object.
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
+ * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export const createFilterFromNumericRangeJaql = (attribute, rangeFilterJaql) => {
-    return withComposeCode(filterFactory.between)(attribute, rangeFilterJaql.from, rangeFilterJaql.to);
+export const createFilterFromNumericRangeJaql = (attribute, rangeFilterJaql, guid) => {
+    return withComposeCode(filterFactory.between)(attribute, rangeFilterJaql.from, rangeFilterJaql.to, guid);
 };
 /**
  * Creates a filter from a period filter JAQL object.
  *
  * @param attribute - attribute
  * @param periodFilterJaql - Period Filter Jaql
+ * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export const createFilterFromPeriodFilterJaql = (attribute, periodFilterJaql) => {
+export const createFilterFromPeriodFilterJaql = (attribute, periodFilterJaql, guid) => {
     if (periodFilterJaql.last) {
-        return withComposeCode(filterFactory.dateRelativeTo)(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor);
+        return withComposeCode(filterFactory.dateRelativeTo)(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor, guid);
     }
     else {
-        return withComposeCode(filterFactory.dateRelativeFrom)(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor);
+        return withComposeCode(filterFactory.dateRelativeFrom)(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor, guid);
     }
 };
 /**
@@ -95,24 +113,36 @@ export const createFilterFromPeriodFilterJaql = (attribute, periodFilterJaql) =>
  * @param attribute - attribute
  * @param conditionFilterJaql - Condition Filter Jaql
  * @param measure - measure
+ * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export const createFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, measure) => {
+export const createFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, measure, guid) => {
     if (measure) {
-        return createMeasureFilterFromConditionFilterJaql(measure, conditionFilterJaql);
+        return createMeasureFilterFromConditionFilterJaql(measure, conditionFilterJaql, guid);
     }
     else {
-        return createAttributeFilterFromConditionFilterJaql(attribute, conditionFilterJaql);
+        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.
  *
  * @param jaql - The filter JAQL object.
- * @param instanceid - The instance ID.
+ * @param guid - Optional GUID for the filter
  * @returns Filter object.
  */
-export const createFilterFromJaqlInternal = (jaql, instanceid) => {
+export const createFilterFromJaqlInternal = (jaql, guid) => {
     try {
         if ('formula' in jaql) {
             // generic pass-through JAQL filter will be used instead
@@ -125,25 +155,26 @@ export const createFilterFromJaqlInternal = (jaql, instanceid) => {
         const measure = createMeasureFromFilterJaql(jaql);
         switch (filterType) {
             case FILTER_TYPES.INCLUDE_ALL:
-                return createFilterIncludeAll(attribute);
+                return createFilterIncludeAll(attribute, guid);
             case FILTER_TYPES.SPECIFIC_ITEMS:
-                return createFilterFromSpecificItemsFilterJaql(attribute, filterJaqlWithType);
+                return createFilterFromSpecificItemsFilterJaql(attribute, filterJaqlWithType, guid);
             case FILTER_TYPES.CONDITION:
-                return createFilterFromConditionFilterJaql(attribute, filterJaqlWithType, measure);
+                return createFilterFromConditionFilterJaql(attribute, filterJaqlWithType, measure, guid);
             case FILTER_TYPES.DATE_RANGE:
-                return createFilterFromDateRangeFilterJaql(attribute, filterJaqlWithType);
+                return createFilterFromDateRangeFilterJaql(attribute, filterJaqlWithType, guid);
             case FILTER_TYPES.PERIOD:
-                return createFilterFromPeriodFilterJaql(attribute, filterJaqlWithType);
+                return createFilterFromPeriodFilterJaql(attribute, filterJaqlWithType, guid);
             case FILTER_TYPES.NUMERIC_RANGE:
-                return createFilterFromNumericRangeJaql(attribute, filterJaqlWithType);
+                return createFilterFromNumericRangeJaql(attribute, filterJaqlWithType, guid);
             case FILTER_TYPES.ADVANCED:
+                return createFilterFromCustomFilterJaql(attribute, filterJaqlWithType, guid);
             case FILTER_TYPES.INVALID:
-                return createGenericFilter(jaql, instanceid);
+                return createGenericFilter(jaql, guid);
         }
     }
     catch (e) {
         // if a filter type is untranslatable, fall back to the generic pass-through JAQL filter
         // console.error(e);
     }
-    return createGenericFilter(jaql, instanceid);
+    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/package.json

@@ -11,20 +11,29 @@
     "Sisense",
     "Compose SDK"
   ],
-  "version": "1.11.0",
+  "version": "1.13.0",
   "type": "module",
-  "exports": {
-    ".": "./dist/index.js",
-    "./dist/dimensional-model/filters/filters": "./dist/dimensional-model/filters/filters.js"
-  },
-  "main": "./dist/index.js",
+  "main": "./dist/cjs/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./dist/dimensional-model/filters/filters": {
+      "default": "./dist/dimensional-model/filters/filters.js",
+      "import": "./dist/dimensional-model/filters/filters.js",
+      "require": "./dist/cjs/dimensional-model/filters/filters.js"
+    }
+  },
   "author": "Sisense",
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@sisense/sdk-common": "^1.11.0",
-    "@sisense/sdk-rest-client": "^1.11.0",
+    "@sisense/sdk-common": "^1.13.0",
+    "@sisense/sdk-rest-client": "^1.13.0",
     "guid-typescript": "^1.0.9",
     "lodash": "^4.17.21",
     "numeral": "^2.0.6",
@@ -33,7 +42,7 @@
   "scripts": {
     "type-check": "tsc --noEmit",
     "build": "tsc --build tsconfig.build.json",
-    "build:prod": "tsc --project tsconfig.prod.json",
+    "build:prod": "tsc --project tsconfig.prod.json && tsc --project tsconfig.cjs.json",
     "build.watch": "tsc --build --watch",
     "clean": "rm -rf dist coverage tsconfig.build.tsbuildinfo tsconfig.prod.tsbuildinfo",
     "lint": "eslint . --fix",