@thoughtspot/ts-chart-sdk 0.0.2-alpha.2 → 0.0.2-alpha.21

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

@@ -1,6 +1,9 @@
-import { AllowedConfigurations } from '../main/custom-chart-context';
+import type {
+    AllowedConfigurations,
+    ChartConfigParameters,
+} from '../main/custom-chart-context';
 import { ChartColumn } from './answer-column.types';
-import { Point } from './chart-to-ts-event.types';
+import type { Point } from './chart-to-ts-event.types';
 import {
     AppConfig,
     ChartConfig,
@@ -9,8 +12,8 @@ import {
     ValidationResponse,
     VisualProps,
 } from './common.types';
-import { ChartConfigEditorDefinition } from './configurator.types';
-import { VisualPropEditorDefinition } from './visual-prop.types';
+import type { ChartConfigEditorDefinition } from './configurator.types';
+import type { VisualPropEditorDefinition } from './visual-prop.types';
 
 /**
  * All the events sent from the ThoughtSpot application to Custom Chart App
@@ -200,11 +203,19 @@ 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:
      */
     allowedConfigurations?: AllowedConfigurations;
+    /**
+     * Additional chart configuration parameters supported by TS UI. Ex: show/hide Measure Name/
+     * Value columns.
+     *
+     * @version SDK: 0.1 | ThoughtSpot:
+     */
+    chartConfigParameters?: ChartConfigParameters;
 }
 
 /**
@@ -215,12 +226,26 @@ export interface GetDataQueryPayload {
     config: ChartConfig[];
 }
 
+/**
+ *
+ * @group ThoughtSpot to Chart Events
+ */
+export interface QueryColumn extends ChartColumn {
+    /**
+     * Flag to identify if the column is a measure value,
+     * to be used along with MEASURE_NAME/MEASUE_VALUE column in the query
+     *
+     * @version SDK: 0.1 | ThoughtSpot:
+     */
+    isMeasureValue?: boolean;
+}
+
 /**
  *
  * @group ThoughtSpot to Chart Events
  */
 export interface Query {
-    queryColumns: ChartColumn[];
+    queryColumns: QueryColumn[];
     queryParams?: {
         offset?: number;
         size?: number;
@@ -280,6 +305,13 @@ export interface VisualPropsValidateEventPayload {
      * @version SDK: 0.1 | ThoughtSpot:
      */
     visualProps: VisualProps;
+    /**
+     * used to identify active column for column level settings, empty string in case of overall
+     * chart settings
+     *
+     * @version SDK: 0.1 | ThoughtSpot:
+     */
+    activeColumnId?: string;
 }
 
 /**

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

@@ -8,6 +8,9 @@
  * Copyright: ThoughtSpot Inc. 2023
  */
 
+import type { CustomChartContext } from '../main/custom-chart-context';
+import { ColumnType } from './answer-column.types';
+import { ChartModel } from './common.types';
 /**
  * Configuration for input validation rules
  */
@@ -113,6 +116,12 @@ export interface TextInputFormDetail {
      * @version SDK: 0.0.1-alpha.3 | ThoughtSpot:
      */
     inputValidation?: InputValidation;
+    /**
+     * Determines whether it should be disabled or not
+     *
+     * @version SDK: 0.0.2-alpha.13 | ThoughtSpot:
+     */
+    disabled?: boolean;
 }
 
 /**
@@ -146,6 +155,12 @@ export interface NumberInputFormDetail {
      * @version SDK: 0.0.1-alpha.7 | ThoughtSpot:
      */
     inputValidation?: InputValidation;
+    /**
+     * Determines whether it should be disabled or not
+     *
+     * @version SDK: 0.0.2-alpha.13 | ThoughtSpot:
+     */
+    disabled?: boolean;
 }
 
 /**
@@ -207,6 +222,12 @@ export interface ToggleFormDetail {
      * @version SDK: 0.1 | ThoughtSpot:
      */
     defaultValue?: boolean;
+    /**
+     * Determines whether it should be disabled or not
+     *
+     * @version SDK: 0.0.2-alpha.13 | ThoughtSpot:
+     */
+    disabled?: boolean;
 }
 
 /**
@@ -234,6 +255,12 @@ export interface CheckboxFormDetail {
      * @version SDK: 0.1 | ThoughtSpot:
      */
     defaultValue?: boolean;
+    /**
+     * Determines whether it should be disabled or not
+     *
+     * @version SDK: 0.0.2-alpha.13 | ThoughtSpot:
+     */
+    disabled?: boolean;
 }
 
 /**
@@ -267,6 +294,12 @@ export interface RadioButtonFormDetail {
      * @version SDK: 0.1 | ThoughtSpot:
      */
     values: string[];
+    /**
+     * Determines whether it should be disabled or not
+     *
+     * @version SDK: 0.0.2-3 | ThoughtSpot:
+     */
+    disabled?: boolean;
 }
 
 /**
@@ -300,6 +333,12 @@ export interface DropDownFormDetail {
      * @version SDK: 0.1 | ThoughtSpot:
      */
     values: string[];
+    /**
+     * Determines whether it should be disabled or not
+     *
+     * @version SDK: 0.0.2-alpha.13 | ThoughtSpot:
+     */
+    disabled?: boolean;
 }
 
 /**
@@ -329,7 +368,6 @@ export interface Section {
     children?: PropElement[];
     /**
      * Defines form alignment in the view for the section
-     *
      * @version SDK: 0.1 | ThoughtSpot:
      */
     alignment?: 'row' | 'column';
@@ -341,6 +379,18 @@ export interface Section {
      * @version SDK: 0.0.1-alpha.3 | ThoughtSpot:
      */
     layoutType?: 'accordion' | 'tab' | 'none';
+    /**
+     * Determines whether section should be disabled or not
+     *
+     * @version SDK: 0.0.2-alpha.18 | ThoughtSpot:
+     */
+    disabled?: boolean;
+    /* Optional property to make the accordian expanded by default. If
+     * not passed the accordian will remain closed by default. Only works with layout type 'accordian'
+     *
+     * @version SDK: 0.0.2-alpha.19 | ThoughtSpot:
+     */
+    isAccordianExpanded?: boolean;
 }
 
 /**
@@ -358,6 +408,18 @@ export type PropElement =
     | RadioButtonFormDetail
     | DropDownFormDetail;
 
+/**
+ * Define Column settings, based on column type, settings needs to be defined in
+ * visualPropEditorDefinition using the current config columns,
+ * @version SDK: 0.2 | ThoughtSpot:
+ */
+export interface ColumnProp {
+    type: ColumnType;
+    columnSettingsDefinition: {
+        [columnId: string]: { elements: PropElement[] };
+    };
+}
+
 /**
  * Visual property editor definition object
  *
@@ -371,8 +433,20 @@ export interface VisualPropEditorDefinition {
      * @version SDK: 0.1 | ThoughtSpot:
      */
     elements: PropElement[];
+    /**
+     *To Define column level settings.
+     *
+     * @version SDK: 0.2 | ThoughtSpot:
+     */
+    columnsVizPropDefinition?: ColumnProp[];
 }
 
+export type VisualEditorDefinitionSetter = (
+    currentState: ChartModel,
+    ctx: CustomChartContext,
+    activeColumnId?: string,
+) => 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,469 @@
+/**
+ * @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,
+    ChartSpecificColumnType,
+    ColumnTimeBucket,
+    ColumnType,
+    DataType,
+} from '../../types/answer-column.types';
+import { DataPointsArray } from '../../types/common.types';
+import {
+    ConditionalFormatting,
+    ConditionalFormattingComparisonTypes,
+    FalconDataType,
+    Operators,
+    ParameterValueType,
+} 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 invalidOperator = createMetricOperator('invalid-operator' as any);
+
+const parameter = undefined;
+
+const mockConditionalFormatting: ConditionalFormatting = {
+    rows: [lessThanOperator, greaterThanOperator, isBetweenOperator],
+};
+
+const parameters = [
+    {
+        id: 'parameter1',
+        defaultValue: 'abc',
+        dataType: FalconDataType.Char,
+        description: '',
+        owner: null as any,
+        valueType: ParameterValueType.Any,
+        name: 'parameter1',
+    },
+];
+
+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);
+        expect(
+            validateCfCondition(invalidOperator, 4, 'col1', mockDataAttr),
+        ).toBe(false);
+
+        const operatorWithColId = createMetricOperator(
+            Operators.LessThan,
+            'col1',
+            'col2',
+        );
+
+        expect(
+            validateCfCondition(operatorWithColId, 4, '', 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,
+            chartSpecificColumnType: ChartSpecificColumnType.UNKNOWN,
+            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(notEqualToOperator, parameter, null)).toBe(
+            true,
+        );
+        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(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);
+
+        // Parameter Based
+        const parameterBasedOperator = createMetricOperator(
+            Operators.EqualTo,
+            'col1',
+            'col2',
+            'parameter1',
+            ConditionalFormattingComparisonTypes.ParameterBased,
+        );
+        expect(
+            isConditionSatisfied(
+                parameterBasedOperator,
+                parameters,
+                'abc',
+                'abc',
+            ),
+        ).toBe(true);
+    });
+});