@sisense/sdk-data 1.10.1 → 1.12.0

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,59 @@ 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) => {
+    return withComposeCode(filterFactory.members)(attribute, specificItemsFilterJaql.members, guid);
 };
 /**
  * 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 +101,25 @@ 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 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 +132,25 @@ 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:
             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-matcher-utils.d.ts

@@ -0,0 +1,5 @@
+import { FilterJaql } from '../../types.js';
+declare type FilterMatcher = (value?: string | number) => boolean;
+/** @internal */
+export declare function createFilterMatcher(filterJaql: FilterJaql): FilterMatcher;
+export {};

package/dist/dimensional-model/filters/utils/filter-matcher-utils.js

@@ -0,0 +1,170 @@
+import { getSelectedConditionOption } from './condition-filter-util.js';
+import { isConditionFilter, isSpecificItemsFilter } from './filter-types-util.js';
+import { ConditionFilterType, } from './types.js';
+const defaultFormatter = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    return `${value}`;
+};
+const defaultDatetimeFormatter = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    return new Date(value).toISOString();
+};
+const defaultMatcher = () => false;
+function createCombinedFilterMatcher(createFilterMatcherFn, filterJaql) {
+    const filter = filterJaql.filter;
+    if ('or' in filter) {
+        return (value) => {
+            return filter.or
+                .map((filterItem) => createFilterMatcherFn(Object.assign(Object.assign({}, filterJaql), { filter: filterItem })))
+                .reduce((acc, filterMatcher) => {
+                return acc || filterMatcher(value);
+            }, false);
+        };
+    }
+    if ('and' in filter) {
+        return (value) => {
+            return filter.and
+                .map((filterItem) => createFilterMatcherFn(Object.assign(Object.assign({}, filterJaql), { filter: filterItem })))
+                .reduce((acc, filterMatcher) => {
+                return acc && filterMatcher(value);
+            }, true);
+        };
+    }
+    return createFilterMatcherFn(filterJaql);
+}
+function createMembersFilterMatcher(filterJaql) {
+    const { datatype } = filterJaql;
+    const filter = filterJaql.filter;
+    const formatter = datatype === 'datetime' ? defaultDatetimeFormatter : defaultFormatter;
+    return (value) => {
+        const formattedMembers = filter.members.map(formatter);
+        const formattedValue = formatter(value);
+        return formattedMembers.includes(formattedValue);
+    };
+}
+function createExcludeMembersFilterMatcher(filterJaql) {
+    const { datatype } = filterJaql;
+    const filter = filterJaql.filter;
+    const formatter = datatype === 'datetime' ? defaultDatetimeFormatter : defaultFormatter;
+    return (value) => {
+        var _a, _b;
+        const formattedMembers = ((_b = (_a = filter.exclude) === null || _a === void 0 ? void 0 : _a.members) === null || _b === void 0 ? void 0 : _b.map(formatter)) || [];
+        const formattedValue = formatter(value);
+        return !formattedMembers.includes(formattedValue);
+    };
+}
+function createTextFilterMatcher(filterJaql) {
+    const filter = filterJaql.filter;
+    const conditionFilterType = getSelectedConditionOption(filter);
+    if (conditionFilterType === ConditionFilterType.STARTS_WITH) {
+        return (value) => {
+            return new RegExp(`^${filter.startsWith}`, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.ENDS_WITH) {
+        return (value) => {
+            return new RegExp(`${filter.endsWith}$`, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.CONTAINS) {
+        return (value) => {
+            return new RegExp(filter.contains, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.EQUALS) {
+        return (value) => {
+            return (value.localeCompare(filter.equals, undefined, {
+                sensitivity: 'base',
+            }) === 0);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.DOESNT_START_WITH) {
+        return (value) => {
+            return !new RegExp(`^${filter.doesntStartWith}`, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.DOESNT_END_WITH) {
+        return (value) => {
+            return !new RegExp(`${filter.doesntEndWith}$`, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.DOESNT_CONTAIN) {
+        return (value) => {
+            return !new RegExp(filter.doesntContain, 'i').test(value);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.DOESNT_EQUAL) {
+        return (value) => {
+            return (value.localeCompare(filter.doesntEqual, undefined, {
+                sensitivity: 'base',
+            }) !== 0);
+        };
+    }
+    return defaultMatcher;
+}
+function createNumericFilterMatcher(filterJaql) {
+    const filter = filterJaql.filter;
+    const conditionFilterType = getSelectedConditionOption(filter);
+    if (conditionFilterType === ConditionFilterType.EQUALS) {
+        return (value) => {
+            return Number(filter.equals) === Number(value);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.DOESNT_EQUAL) {
+        return (value) => {
+            return Number(filter.doesntEqual) !== Number(value);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.LESS_THAN) {
+        return (value) => {
+            return Number(value) < Number(filter.toNotEqual);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.GREATER_THAN) {
+        return (value) => {
+            return Number(value) > Number(filter.fromNotEqual);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.BETWEEN) {
+        return (value) => {
+            return Number(filter.to) >= Number(value) && Number(value) >= Number(filter.from);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.GREATER_THAN_OR_EQUAL) {
+        return (value) => {
+            return Number(value) >= Number(filter.from);
+        };
+    }
+    if (conditionFilterType === ConditionFilterType.LESS_THAN_OR_EQUAL) {
+        return (value) => {
+            return Number(filter.to) >= Number(value);
+        };
+    }
+    return defaultMatcher;
+}
+/** @internal */
+export function createFilterMatcher(filterJaql) {
+    const filterJaqlInternal = filterJaql;
+    const { datatype } = filterJaqlInternal;
+    const filter = filterJaqlInternal.filter;
+    if (isSpecificItemsFilter(filter)) {
+        return createMembersFilterMatcher(filterJaqlInternal);
+    }
+    if (isConditionFilter(filter) &&
+        getSelectedConditionOption(filter) === ConditionFilterType.IS_NOT) {
+        return createExcludeMembersFilterMatcher(filterJaqlInternal);
+    }
+    // text filters
+    if (datatype === 'text') {
+        return createCombinedFilterMatcher(createTextFilterMatcher, filterJaqlInternal);
+    }
+    // // numeric filters
+    if (datatype === 'numeric') {
+        return createCombinedFilterMatcher(createNumericFilterMatcher, filterJaqlInternal);
+    }
+    return defaultMatcher;
+}

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

@@ -1,5 +1,7 @@
-import { FilterModalType, AnyTypeFilterJaql, DatetimeLevel, FilterType, FilterJaqlInternal, FilterJaqlWrapperWithType } from './types.js';
+import { FilterModalType, AnyTypeFilterJaql, DatetimeLevel, FilterType, SpecificItemsFilterJaql, ConditionFilterJaql, FilterJaqlInternal, FilterJaqlWrapperWithType } from './types.js';
+export declare const isSpecificItemsFilter: (filter: AnyTypeFilterJaql) => filter is SpecificItemsFilterJaql;
 export declare const isNumericRangeFilter: (filter: AnyTypeFilterJaql) => boolean;
+export declare const isConditionFilter: (filter: AnyTypeFilterJaql) => filter is ConditionFilterJaql;
 export declare const getFilterType: (filter: AnyTypeFilterJaql, dataType?: FilterModalType, timeData?: {
     level?: DatetimeLevel;
     bucket?: string;

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

@@ -4,7 +4,7 @@ import { getCorrectTimeLevel } from './date-time-filter-util.js';
 const isIncludeAllFilter = (filter) => filter === null || filter === void 0 ? void 0 : filter.all;
 const getInnerPeriodFilter = (filter) => (filter.last ? filter.last : filter.next);
 const isPeriodFilter = (filter) => { var _a; return ((_a = getInnerPeriodFilter(filter)) === null || _a === void 0 ? void 0 : _a.offset) < 2; };
-const isSpecificItemsFilter = (filter) => { var _a; return ((_a = filter === null || filter === void 0 ? void 0 : filter.members) === null || _a === void 0 ? void 0 : _a.length) > 0; };
+export const isSpecificItemsFilter = (filter) => { var _a; return ((_a = filter === null || filter === void 0 ? void 0 : filter.members) === null || _a === void 0 ? void 0 : _a.length) > 0; };
 const isFromOrToDefined = (fromRange, toRange) => (fromRange && typeof fromRange === 'string') || (toRange && typeof toRange === 'string');
 const isFromAndToEmpty = (from, to) => from === '' && to === '';
 const isDateRangeFilter = (filter, dataType) => {
@@ -19,7 +19,7 @@ export const isNumericRangeFilter = (filter) => {
     const { from, to } = filter;
     return !!(from !== undefined && to !== undefined && !filter.isBetween);
 };
-const isConditionFilter = (filter) => getSelectedConditionOption(filter) !== ConditionFilterType.NONE;
+export const isConditionFilter = (filter) => getSelectedConditionOption(filter) !== ConditionFilterType.NONE;
 const isAdvancedFilter = (filter) => Object.keys(filter).includes('isAdvanced');
 const isTimeLevelNotSupported = (timeData) => !!(timeData.level &&
     timeData.bucket &&

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

@@ -121,7 +121,7 @@ export declare type FilterJaqlInternal = {
     fiscal?: string;
     firstday?: string;
     merged?: boolean;
-    table: string;
+    table?: string;
     filter?: AnyTypeFilterJaql;
     level?: DatetimeLevel;
     locale?: string;

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

@@ -340,6 +340,12 @@ export interface Filter extends Element {
      * Boolean flag whether the filter is a scope filter
      */
     isScope: boolean;
+    /**
+     * Boolean flag whether the filter is disabled
+     *
+     * @internal
+     */
+    disabled: boolean;
     /**
      * Gets JAQL representing this Filter instance
      *

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

@@ -1,3 +1,4 @@
+import { type ConditionFilterJaql } from './filters/utils/types.js';
 /**
  * Different aggregation types
  */
@@ -175,13 +176,18 @@ export declare type PivotJaql = (BaseJaql | FormulaJaql) & {
 /** @internal */
 export declare type BaseJaql = {
     agg?: string;
-    datatype: DataType;
+    datatype: `${DataType}`;
     dim: string;
     table: string;
     column: string;
     title: string;
     level?: 'years' | 'quarters' | 'months' | 'weeks' | 'minutes' | 'days';
-    sort?: JaqlSortDirection;
+    sort?: `${JaqlSortDirection}`;
+    in?: {
+        selected?: {
+            jaql: FilterJaql;
+        };
+    };
 };
 /** @internal */
 export declare type FormulaID = string;
@@ -196,7 +202,7 @@ export declare type FormulaJaql = {
     context?: Record<FormulaID, FormulaContext>;
 };
 /** @internal */
-export declare type BaseFilter = IncludeAllFilter | IncludeMembersFilter | ExcludeMembersFilter | JaqlNumericFilter | AndFilter<JaqlNumericFilter> | OrFilter<JaqlNumericFilter>;
+export declare type BaseFilter = IncludeAllFilter | IncludeMembersFilter | ExcludeMembersFilter | JaqlNumericFilter | ConditionFilterJaql | AndFilter<JaqlNumericFilter | ConditionFilterJaql> | OrFilter<JaqlNumericFilter | ConditionFilterJaql>;
 /** @internal */
 export declare type BackgroundFilter = BaseFilter & {
     level?: 'string';

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export * from './dimensional-model/attributes.js';
 export * from './dimensional-model/dimensions.js';
 export * from './dimensional-model/factory.js';
 export * from './dimensional-model/filters/filters.js';
+export { createFilterMatcher } from './dimensional-model/filters/utils/filter-matcher-utils.js';
 /**
  * Functions to create date, text, or numeric filters on specified data.
  *

package/dist/index.js

@@ -15,6 +15,7 @@ export * from './dimensional-model/attributes.js';
 export * from './dimensional-model/dimensions.js';
 export * from './dimensional-model/factory.js';
 export * from './dimensional-model/filters/filters.js';
+export { createFilterMatcher } from './dimensional-model/filters/utils/filter-matcher-utils.js';
 /**
  * Functions to create date, text, or numeric filters on specified data.
  *

package/package.json

@@ -11,20 +11,29 @@
     "Sisense",
     "Compose SDK"
   ],
-  "version": "1.10.1",
+  "version": "1.12.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.10.1",
-    "@sisense/sdk-rest-client": "^1.10.1",
+    "@sisense/sdk-common": "^1.12.0",
+    "@sisense/sdk-rest-client": "^1.12.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",