@thoughtspot/ts-chart-sdk 0.0.2-alpha.3 → 0.0.2-alpha.4

package/src/types/conditional-formatting.types.ts

@@ -0,0 +1,172 @@
+/**
+ * @file: Conditional Formatting Types
+ * @fileoverview All CF types for the Custom Chart implementations
+ * @author Yashvardhan Nehra <yashvardhan.nehra@thoughtspot.com>
+ *
+ * Copyright: ThoughtSpot Inc. 2023
+ */
+
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+
+export type ConditionalFormatting = {
+    __typename?: 'ConditionalFormatting';
+    rows?: Maybe<Array<Maybe<ConditionalMetric>>>;
+};
+export type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    FileUpload: any;
+    GUID: string;
+    JSON: {
+        [key: string]: any;
+    };
+    JSONObject: any;
+    Long: any;
+};
+export declare enum BackgroundFormatTypes {
+    Gradient = 'GRADIENT',
+    Solid = 'SOLID',
+}
+export enum ConditionalFormattingComparisonTypes {
+    ColumnBased = 'COLUMN_BASED',
+    ParameterBased = 'PARAMETER_BASED',
+    ValueBased = 'VALUE_BASED',
+}
+export type FontAttrs = {
+    __typename?: 'FontAttrs';
+    bold?: Maybe<Scalars['Boolean']>;
+    color?: Maybe<Scalars['String']>;
+    italic?: Maybe<Scalars['Boolean']>;
+    strikeThrough?: Maybe<Scalars['Boolean']>;
+    underline?: Maybe<Scalars['Boolean']>;
+};
+export type GradientBackgroundAttrs = {
+    __typename?: 'GradientBackgroundAttrs';
+    backgroundFormatMidpoint?: Maybe<Scalars['Float']>;
+    backgroundFormatRange?: Maybe<Array<Maybe<Scalars['Float']>>>;
+    colors?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+export enum Operators {
+    Contains = 'CONTAINS',
+    DoesNotContain = 'DOES_NOT_CONTAIN',
+    EndsWith = 'ENDS_WITH',
+    EqualTo = 'EQUAL_TO',
+    GreaterThan = 'GREATER_THAN',
+    GreaterThanEqualTo = 'GREATER_THAN_EQUAL_TO',
+    Is = 'IS',
+    IsBetween = 'IS_BETWEEN',
+    IsEmpty = 'IS_EMPTY',
+    IsNot = 'IS_NOT',
+    IsNotEmpty = 'IS_NOT_EMPTY',
+    IsNotNull = 'IS_NOT_NULL',
+    IsNull = 'IS_NULL',
+    LessThan = 'LESS_THAN',
+    LessThanEqualTo = 'LESS_THAN_EQUAL_TO',
+    NotEqualTo = 'NOT_EQUAL_TO',
+    StartsWith = 'STARTS_WITH',
+}
+export type SolidBackgroundAttrs = {
+    __typename?: 'SolidBackgroundAttrs';
+    color?: Maybe<Scalars['String']>;
+};
+export type Range = {
+    __typename?: 'Range';
+    max?: Maybe<Scalars['Float']>;
+    min?: Maybe<Scalars['Float']>;
+};
+export type ConditionalMetric = {
+    __typename?: 'ConditionalMetric';
+    backgroundFormatType?: Maybe<BackgroundFormatTypes>;
+    comparisonParameterId?: Maybe<Scalars['String']>;
+    comparisonType?: Maybe<ConditionalFormattingComparisonTypes>;
+    fontProperties?: Maybe<FontAttrs>;
+    gradientBackgroundAttrs?: Maybe<GradientBackgroundAttrs>;
+    isHighlightRow?: Maybe<Scalars['Boolean']>;
+    lhsColumnId?: Maybe<Scalars['String']>;
+    operator?: Maybe<Operators>;
+    plotAsBand?: Maybe<Scalars['Boolean']>;
+    rangeValues?: Maybe<Range>;
+    rhsColumnId?: Maybe<Scalars['String']>;
+    solidBackgroundAttrs?: Maybe<SolidBackgroundAttrs>;
+    value?: Maybe<Scalars['String']>;
+};
+
+export type Parameter = {
+    __typename?: 'Parameter';
+    dataType: FalconDataType;
+    defaultValue: Scalars['String'];
+    description: Scalars['String'];
+    id: Scalars['GUID'];
+    name: Scalars['String'];
+    /** If not present, the parameter has not been overridden */
+    overrideValue?: Maybe<Scalars['String']>;
+    owner: ParameterOwnerInfo;
+    valueList?: Maybe<Array<ParameterValueListItem>>;
+    valueRange?: Maybe<ParameterValueRange>;
+    valueType: ParameterValueType;
+};
+
+export enum FalconDataType {
+    Bool = 'BOOL',
+    Char = 'CHAR',
+    Date = 'DATE',
+    DateTime = 'DATE_TIME',
+    Double = 'DOUBLE',
+    Float = 'FLOAT',
+    Int32 = 'INT32',
+    Int64 = 'INT64',
+    List = 'LIST',
+    ListBool = 'LIST_BOOL',
+    ListDate = 'LIST_DATE',
+    ListDateTime = 'LIST_DATE_TIME',
+    ListDouble = 'LIST_DOUBLE',
+    ListInt = 'LIST_INT',
+    ListString = 'LIST_STRING',
+    ListTime = 'LIST_TIME',
+    MaxType = 'MAX_TYPE',
+    Time = 'TIME',
+    Unknown = 'UNKNOWN',
+}
+export type ParameterOwnerInfo = {
+    __typename?: 'ParameterOwnerInfo';
+    id: Scalars['GUID'];
+    name: Scalars['String'];
+    type: ParameterOwnerType;
+};
+
+export enum ParameterOwnerType {
+    Answer = 'ANSWER',
+    Worksheet = 'WORKSHEET',
+}
+
+export type ParameterValueListItem = {
+    __typename?: 'ParameterValueListItem';
+    displayAs?: Maybe<Scalars['String']>;
+    value: Scalars['String'];
+};
+
+export type ParameterValueListItemInput = {
+    displayAs?: InputMaybe<Scalars['String']>;
+    value: Scalars['String'];
+};
+
+export type ParameterValueRange = {
+    __typename?: 'ParameterValueRange';
+    max?: Maybe<Scalars['Float']>;
+    min?: Maybe<Scalars['Float']>;
+};
+
+export type ParameterValueRangeInput = {
+    max?: InputMaybe<Scalars['Float']>;
+    min?: InputMaybe<Scalars['Float']>;
+};
+
+export enum ParameterValueType {
+    Any = 'ANY',
+    List = 'LIST',
+    Range = 'RANGE',
+}

package/src/types/configurator.types.ts

@@ -14,6 +14,8 @@
  * Copyright: ThoughtSpot Inc. 2023
  */
 
+import { CustomChartContext } from '../main/custom-chart-context';
+import { ChartModel } from './common.types';
 /**
  *
  * @group Chart Configuration Editor
@@ -100,3 +102,8 @@ export interface ChartConfigEditorDefinition {
      */
     columnSections: ChartConfigSection[];
 }
+
+export type ConfigEditorDefinitionSetter = (
+    currentState: ChartModel,
+    ctx: CustomChartContext,
+) => ChartConfigEditorDefinition[];

package/src/types/ts-to-chart-event.types.ts

@@ -200,7 +200,8 @@ export interface InitializeEventResponsePayload {
      */
     visualPropEditorDefinition?: VisualPropEditorDefinition;
     /**
-     * Toggle native configurations supported by TS UI. Ex: column level number and conditional formatting.
+     * Toggle native configurations supported by TS UI. Ex: column level number and conditional
+     * formatting.
      *
      * @version SDK: 0.1 | ThoughtSpot:
      */

package/src/types/visual-prop.types.ts

@@ -8,6 +8,8 @@
  * Copyright: ThoughtSpot Inc. 2023
  */
 
+import { CustomChartContext } from '../main/custom-chart-context';
+import { ChartModel } from './common.types';
 /**
  * Configuration for input validation rules
  */
@@ -373,6 +375,11 @@ export interface VisualPropEditorDefinition {
     elements: PropElement[];
 }
 
+export type VisualEditorDefinitionSetter = (
+    currentState: ChartModel,
+    ctx: CustomChartContext,
+) => VisualPropEditorDefinition;
+
 /**
  * Example config to be able to store config in the following keys
  * 1. range.xaxis.min

package/src/utils/conditional-formatting/conditional-formatting.spec.ts

@@ -0,0 +1,415 @@
+/**
+ * @file: Conditional Formatting Spec
+ *
+ * @author Yashvardhan Nehra <yashvardhan.nehra@thoughtspot.com>
+ *
+ * Copyright: ThoughtSpot Inc. 2023
+ */
+import _ from 'lodash';
+import {
+    createAttributeOperator,
+    createBetweenMetricOperator,
+    createMetricOperator,
+} from '../../test/test-conditional-formatting-utils';
+import {
+    ChartColumn,
+    ColumnTimeBucket,
+    ColumnType,
+    DataType,
+} from '../../types/answer-column.types';
+import { DataPointsArray } from '../../types/common.types';
+import {
+    ConditionalFormatting,
+    ConditionalFormattingComparisonTypes,
+    Operators,
+} from '../../types/conditional-formatting.types';
+import {
+    applicableConditionalFormatting,
+    getCfForColumn,
+    isConditionSatisfied,
+    validateCfCondition,
+} from './conditional-formatting';
+
+const mockDataAttr: DataPointsArray = {
+    columns: ['col1', 'col2'],
+    dataValue: [
+        [1, 'abc'],
+        [100, 'def'],
+        [150, 'ghi'],
+        [200, 'jkl'],
+        [300, 'mno'],
+    ],
+};
+
+// Measure operators
+const lessThanOperator = createMetricOperator(Operators.LessThan);
+const greaterThanOperator = createMetricOperator(Operators.GreaterThan);
+const lessThanEqualToOperator = createMetricOperator(Operators.LessThanEqualTo);
+const greaterThanEqualToOperator = createMetricOperator(
+    Operators.GreaterThanEqualTo,
+);
+const equalToOperator = createMetricOperator(Operators.EqualTo);
+const notEqualToOperator = createMetricOperator(Operators.NotEqualTo);
+const isBetweenOperator = createBetweenMetricOperator(Operators.IsBetween);
+const isNullOperator = createMetricOperator(Operators.IsNull);
+const isNotNullOperator = createMetricOperator(Operators.IsNotNull);
+
+// Attribute operators
+const isOperator = createAttributeOperator(Operators.Is);
+const isNotOperator = createAttributeOperator(Operators.IsNot);
+const containsOperator = createAttributeOperator(Operators.Contains);
+const doesNotContainOperator = createAttributeOperator(
+    Operators.DoesNotContain,
+);
+const startsWithOperator = createAttributeOperator(Operators.StartsWith);
+const endsWithOperator = createAttributeOperator(Operators.EndsWith);
+
+const parameter = undefined;
+
+const mockConditionalFormatting: ConditionalFormatting = {
+    rows: [lessThanOperator, greaterThanOperator, isBetweenOperator],
+};
+
+describe('validateCfCondition', () => {
+    test('verify validateCfCondition util', () => {
+        expect(
+            validateCfCondition(lessThanOperator, 0, 'col1', mockDataAttr),
+        ).toBe(true);
+        expect(
+            validateCfCondition(lessThanOperator, 3, 'col1', mockDataAttr),
+        ).toBe(false);
+        expect(
+            validateCfCondition(
+                lessThanEqualToOperator,
+                3,
+                'col1',
+                mockDataAttr,
+            ),
+        ).toBe(true);
+        expect(
+            validateCfCondition(greaterThanOperator, 4, 'col1', mockDataAttr),
+        ).toBe(true);
+        expect(
+            validateCfCondition(greaterThanOperator, 3, 'col1', mockDataAttr),
+        ).toBe(false);
+        expect(
+            validateCfCondition(
+                greaterThanEqualToOperator,
+                3,
+                'col1',
+                mockDataAttr,
+            ),
+        ).toBe(true);
+        expect(
+            validateCfCondition(isBetweenOperator, 0, 'col1', mockDataAttr),
+        ).toBe(false);
+        expect(
+            validateCfCondition(isBetweenOperator, 1, 'col1', mockDataAttr),
+        ).toBe(true);
+        expect(
+            validateCfCondition(isBetweenOperator, 2, 'col1', mockDataAttr),
+        ).toBe(true);
+        expect(
+            validateCfCondition(isBetweenOperator, 3, 'col1', mockDataAttr),
+        ).toBe(true);
+        expect(
+            validateCfCondition(isBetweenOperator, 4, 'col1', mockDataAttr),
+        ).toBe(false);
+    });
+});
+
+describe('applicableConditionalFormatting', () => {
+    test('returns the first applicable ConditionalMetric or null', () => {
+        expect(
+            applicableConditionalFormatting(
+                0,
+                'col1',
+                mockDataAttr,
+                mockConditionalFormatting,
+            ),
+        ).toEqual(lessThanOperator);
+        expect(
+            applicableConditionalFormatting(
+                3,
+                'col1',
+                mockDataAttr,
+                mockConditionalFormatting,
+            ),
+        ).toEqual(isBetweenOperator);
+        expect(
+            applicableConditionalFormatting(
+                4,
+                'col1',
+                mockDataAttr,
+                mockConditionalFormatting,
+            ),
+        ).toEqual(greaterThanOperator);
+        expect(
+            applicableConditionalFormatting(
+                0,
+                'col2',
+                mockDataAttr,
+                mockConditionalFormatting,
+            ),
+        ).toBeNull();
+    });
+});
+
+describe('getCfForColumn', () => {
+    it('returns conditional formatting or null for the specified column', () => {
+        const column: ChartColumn = {
+            id: 'col3',
+            name: '',
+            type: ColumnType.MEASURE,
+            timeBucket: ColumnTimeBucket.AUTO,
+            dataType: DataType.UNKNOWN,
+            columnProperties: {
+                conditionalFormatting: mockConditionalFormatting,
+            },
+        };
+
+        expect(getCfForColumn(column)).toEqual(mockConditionalFormatting);
+    });
+});
+
+describe('isConditionSatisfied', () => {
+    test('verify isConditionSatisfied util', () => {
+        expect(isConditionSatisfied(lessThanOperator, parameter, 100)).toBe(
+            true,
+        );
+        expect(isConditionSatisfied(lessThanOperator, parameter, 200)).toBe(
+            false,
+        );
+        expect(
+            isConditionSatisfied(lessThanOperator, parameter, undefined),
+        ).toBe(false);
+        expect(isConditionSatisfied(greaterThanOperator, parameter, 300)).toBe(
+            true,
+        );
+        expect(isConditionSatisfied(greaterThanOperator, parameter, 100)).toBe(
+            false,
+        );
+        expect(
+            isConditionSatisfied(lessThanEqualToOperator, parameter, 200),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(lessThanEqualToOperator, parameter, 300),
+        ).toBe(false);
+        expect(
+            isConditionSatisfied(greaterThanEqualToOperator, parameter, 200),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(
+                greaterThanEqualToOperator,
+                parameter,
+                undefined,
+            ),
+        ).toBe(false);
+        expect(
+            isConditionSatisfied(greaterThanEqualToOperator, parameter, 100),
+        ).toBe(false);
+        expect(isConditionSatisfied(equalToOperator, parameter, 200)).toBe(
+            true,
+        );
+        expect(isConditionSatisfied(equalToOperator, parameter, 100)).toBe(
+            false,
+        );
+        expect(isConditionSatisfied(notEqualToOperator, parameter, 300)).toBe(
+            true,
+        );
+        expect(isConditionSatisfied(notEqualToOperator, parameter, 200)).toBe(
+            false,
+        );
+        expect(isConditionSatisfied(isBetweenOperator, parameter, 200)).toBe(
+            true,
+        );
+        expect(isConditionSatisfied(isBetweenOperator, parameter, 150)).toBe(
+            true,
+        );
+        expect(isConditionSatisfied(isBetweenOperator, parameter, 201)).toBe(
+            false,
+        );
+        expect(isConditionSatisfied(isBetweenOperator, parameter, 50)).toBe(
+            false,
+        );
+
+        expect(
+            isConditionSatisfied(
+                createBetweenMetricOperator(
+                    Operators.IsBetween,
+                    -2.5412312,
+                    2.112312,
+                ),
+                parameter,
+                -2.54,
+            ),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(
+                createBetweenMetricOperator(
+                    Operators.IsBetween,
+                    -2.5412312,
+                    2.112312,
+                ),
+                parameter,
+                -2.5412312,
+            ),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(
+                createBetweenMetricOperator(
+                    Operators.IsBetween,
+                    -2.5412312,
+                    2.112312,
+                ),
+                parameter,
+                -2.5412313,
+            ),
+        ).toBe(false);
+        expect(
+            isConditionSatisfied(
+                createBetweenMetricOperator(
+                    Operators.IsBetween,
+                    -2.5412312,
+                    2.112312,
+                ),
+                parameter,
+                2.1,
+            ),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(
+                createBetweenMetricOperator(
+                    Operators.IsBetween,
+                    -2.5412312,
+                    2.112312,
+                ),
+                parameter,
+                2.112312,
+            ),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(
+                createBetweenMetricOperator(
+                    Operators.IsBetween,
+                    -2.5412312,
+                    2.112312,
+                ),
+                parameter,
+                2.112313,
+            ),
+        ).toBe(false);
+
+        expect(isConditionSatisfied(isNullOperator, parameter, undefined)).toBe(
+            true,
+        );
+        expect(isConditionSatisfied(isNullOperator, parameter, 50)).toBe(false);
+        expect(isConditionSatisfied(isNullOperator, parameter, null)).toBe(
+            true,
+        );
+        expect(isConditionSatisfied(isNotNullOperator, parameter, 50)).toBe(
+            true,
+        );
+        expect(
+            isConditionSatisfied(isNotNullOperator, parameter, undefined),
+        ).toBe(false);
+
+        expect(
+            isConditionSatisfied(isOperator, parameter, 'check attribute'),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(isOperator, parameter, 'check not attribute'),
+        ).toBe(false);
+        expect(
+            isConditionSatisfied(
+                isNotOperator,
+                parameter,
+                'check not attribute',
+            ),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(isNotOperator, parameter, 'check attribute'),
+        ).toBe(false);
+        expect(
+            isConditionSatisfied(
+                containsOperator,
+                parameter,
+                'check attribute check',
+            ),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(
+                { operator: Operators.Contains, value: '4' },
+                parameter,
+                4099,
+            ),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(
+                { operator: Operators.Contains, value: '4' },
+                parameter,
+                5099,
+            ),
+        ).toBe(false);
+        expect(
+            isConditionSatisfied(containsOperator, parameter, 'check attribut'),
+        ).toBe(false);
+        expect(
+            isConditionSatisfied(
+                doesNotContainOperator,
+                parameter,
+                'check attribut',
+            ),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(
+                doesNotContainOperator,
+                parameter,
+                'check attribute check',
+            ),
+        ).toBe(false);
+        expect(
+            isConditionSatisfied(
+                startsWithOperator,
+                parameter,
+                'check attribute check',
+            ),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(
+                startsWithOperator,
+                parameter,
+                'check check attribute',
+            ),
+        ).toBe(false);
+        expect(
+            isConditionSatisfied(
+                endsWithOperator,
+                parameter,
+                'check check attribute',
+            ),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(
+                endsWithOperator,
+                parameter,
+                'check attribute check',
+            ),
+        ).toBe(false);
+
+        // Column Based
+        const columnBasedOperator = createMetricOperator(
+            Operators.EqualTo,
+            'col1',
+            'col2',
+            '',
+            ConditionalFormattingComparisonTypes.ColumnBased,
+        );
+        expect(
+            isConditionSatisfied(columnBasedOperator, undefined, 'abc', 'abc'),
+        ).toBe(true);
+        expect(
+            isConditionSatisfied(columnBasedOperator, undefined, 'abc', 'def'),
+        ).toBe(false);
+    });
+});