@sisense/sdk-data 1.10.1 → 1.11.0

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

@@ -104,6 +104,7 @@ export declare class DimensionalLevelAttribute extends DimensionalAttribute impl
         dateTimeLevel?: undefined;
     };
     static translateJaqlToGranularity(json: any): string;
+    static getDefaultFormatForGranularity(granularity: string): string;
 }
 /**
  * Creates an Attribute instance from the given JSON object.

package/dist/dimensional-model/attributes.js

@@ -253,6 +253,37 @@ export class DimensionalLevelAttribute extends DimensionalAttribute {
                 return returnUnsupported(json.level);
         }
     }
+    static getDefaultFormatForGranularity(granularity) {
+        switch (granularity) {
+            case DateLevels.Years:
+                return 'yyyy';
+            case DateLevels.Quarters:
+                return 'Q yyyy';
+            case DateLevels.Months:
+                return 'yyyy-MM';
+            case DateLevels.Weeks:
+                return 'ww yyyy';
+            case DateLevels.Days:
+                return 'yyyy-MM-dd';
+            case DateLevels.Hours:
+                // eslint-disable-next-line sonarjs/no-duplicate-string
+                return 'yyyy-MM-dd HH:mm';
+            case DateLevels.MinutesRoundTo30:
+                return 'yyyy-MM-dd HH:mm';
+            case DateLevels.MinutesRoundTo15:
+                return 'yyyy-MM-dd HH:mm';
+            case DateLevels.AggHours:
+                return 'HH:mm';
+            case DateLevels.AggMinutesRoundTo30:
+                return 'HH:mm';
+            case DateLevels.AggMinutesRoundTo15:
+                return 'HH:mm';
+            case DateLevels.AggMinutesRoundTo1:
+                return 'HH:mm';
+            default:
+                return '';
+        }
+    }
 }
 /**
  * Creates an Attribute instance from the given JSON object.

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

@@ -92,6 +92,12 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
      * Global filter identifier
      */
     readonly guid: string;
+    /**
+     * Boolean flag whether the filter is disabled
+     *
+     * @internal
+     */
+    disabled: boolean;
     constructor(att: Attribute, filterType: string);
     get name(): string;
     /**

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

@@ -25,7 +25,7 @@ export const TextOperators = {
     DoesntEqual: 'doesntEqual',
     DoesntStartWith: 'doesntStartWith',
     DoesntContain: 'doesntContain',
-    DoesntEndWith: 'doesntEndWidth',
+    DoesntEndWith: 'doesntEndWith',
     Like: 'like',
 };
 /**
@@ -99,6 +99,7 @@ class AbstractFilter extends DimensionalElement {
         AbstractFilter.checkAttributeSupport(att);
         this.attribute = att;
         this.guid = guidFast(13);
+        this.disabled = false;
     }
     get name() {
         return hash(this.jaql());
@@ -118,6 +119,10 @@ class AbstractFilter extends DimensionalElement {
      * @param nested - defines whether the JAQL is nested within parent JAQL statement or a root JAQL element
      */
     jaql(nested) {
+        // if the filter is disabled, return empty filter JAQL
+        if (this.disabled) {
+            return nested ? { filter: {} } : { jaql: { filter: {} } };
+        }
         const result = this.attribute.jaql(false);
         const level = this.attribute;
         if (level.getFormat && level.getFormat() !== undefined) {
@@ -349,6 +354,10 @@ export class MeasureFilter extends DoubleOperatorFilter {
         return result;
     }
     jaql(nested) {
+        // if the filter is disabled, return empty filter JAQL
+        if (this.disabled) {
+            return nested ? { filter: {} } : { jaql: { filter: {} } };
+        }
         const result = super.jaql(nested);
         if (this.measure instanceof DimensionalBaseMeasure) {
             Object.entries(this.measure.jaql().jaql).forEach(([key, value]) => {

package/dist/dimensional-model/filters/utils/attribute-measure-util.d.ts

@@ -11,7 +11,7 @@ import { FilterJaqlInternal, RankingFilterJaql } from './types.js';
  * @param dataType - Data type
  * @returns attribute or level attribute
  */
-export declare const createAttributeHelper: (dim: string, table: string, column: string, level: string | undefined, dataType: string) => Attribute | LevelAttribute;
+export declare const createAttributeHelper: (dim: string, table: string | undefined, column: string, level: string | undefined, dataType: string) => Attribute | LevelAttribute;
 /**
  * Creates an attribute or level attribute from the provided filter JAQL object
  *
@@ -30,7 +30,7 @@ export declare const createAttributeFromFilterJaql: (jaql: FilterJaql | FilterJa
  * @param agg - Aggregation function
  * @returns measure
  */
-export declare const createMeasureHelper: (dim: string, table: string, column: string, level: string | undefined, dataType: string, agg: string) => BaseMeasure;
+export declare const createMeasureHelper: (dim: string, table: string | undefined, column: string, level: string | undefined, dataType: string, agg: string) => BaseMeasure;
 /**
  * Creates a measure from the provided filter JAQL object
  *

package/dist/dimensional-model/filters/utils/attribute-measure-util.js

@@ -14,17 +14,20 @@ const DATA_MODEL_MODULE_NAME = 'DM';
  * @returns attribute or level attribute
  */
 export const createAttributeHelper = (dim, table, column, level, dataType) => {
+    // if table is undefined, extract it from dim
+    const dimTable = table !== null && table !== void 0 ? table : dim.slice(1, -1).split('.')[0];
     if (level) {
         const dateLevel = DimensionalLevelAttribute.translateJaqlToGranularity({ level });
-        const levelAttribute = new DimensionalLevelAttribute(column, dim, dateLevel);
-        levelAttribute.composeCode = normalizeAttributeName(table, column, level, DATA_MODEL_MODULE_NAME);
+        const format = DimensionalLevelAttribute.getDefaultFormatForGranularity(dateLevel);
+        const levelAttribute = new DimensionalLevelAttribute(column, dim, dateLevel, format);
+        levelAttribute.composeCode = normalizeAttributeName(dimTable, column, level, DATA_MODEL_MODULE_NAME);
         return levelAttribute;
     }
     const attributeType = isNumber(dataType)
         ? MetadataTypes.NumericAttribute
         : MetadataTypes.TextAttribute;
     const attribute = new DimensionalAttribute(column, dim, attributeType);
-    attribute.composeCode = normalizeAttributeName(table, column, undefined, DATA_MODEL_MODULE_NAME);
+    attribute.composeCode = normalizeAttributeName(dimTable, column, undefined, DATA_MODEL_MODULE_NAME);
     return attribute;
 };
 /**

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

@@ -35,12 +35,8 @@ export const getSelectedConditionOption = (filter) => {
         return ConditionFilterType.IS_WITHIN;
     if (isGreaterThanCondition(filter))
         return ConditionFilterType.GREATER_THAN;
-    if (isGreaterThanOrEqualCondition(filter))
-        return ConditionFilterType.GREATER_THAN_OR_EQUAL;
     if (isLessThanCondition(filter))
         return ConditionFilterType.LESS_THAN;
-    if (isLessThanOrEqualCondition(filter))
-        return ConditionFilterType.LESS_THAN_OR_EQUAL;
     if (isEqualsCondition(filter))
         return ConditionFilterType.EQUALS;
     if (isNotEqualCondition(filter))
@@ -61,14 +57,19 @@ export const getSelectedConditionOption = (filter) => {
         return ConditionFilterType.ENDS_WITH;
     if (isStartsWithCondition(filter))
         return ConditionFilterType.STARTS_WITH;
-    if (isBetweenCondition(filter))
-        return ConditionFilterType.BETWEEN;
     if (isNotBetweenCondition(filter))
         return ConditionFilterType.IS_NOT_BETWEEN;
     if (isMembersCondition(filter))
         return ConditionFilterType.IS;
     if (isMultipleCondition(filter))
         return ConditionFilterType.MULTIPLE_CONDITION;
+    // Need to verify BETWEEN case before the GREATER_THAN_OR_EQUAL and LESS_THAN_OR_EQUAL due to missing `filter.isBetween` property in some cases
+    if (isBetweenCondition(filter))
+        return ConditionFilterType.BETWEEN;
+    if (isGreaterThanOrEqualCondition(filter))
+        return ConditionFilterType.GREATER_THAN_OR_EQUAL;
+    if (isLessThanOrEqualCondition(filter))
+        return ConditionFilterType.LESS_THAN_OR_EQUAL;
     return ConditionFilterType.NONE;
 };
 /**

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,7 +11,7 @@
     "Sisense",
     "Compose SDK"
   ],
-  "version": "1.10.1",
+  "version": "1.11.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -23,8 +23,8 @@
   "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.11.0",
+    "@sisense/sdk-rest-client": "^1.11.0",
     "guid-typescript": "^1.0.9",
     "lodash": "^4.17.21",
     "numeral": "^2.0.6",