@thoughtspot/ts-chart-sdk 0.0.1-alpha.9 → 0.0.2-alpha.1

package/cjs/main/custom-chart-context.spec.js

@@ -1,699 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = __importDefault(require("lodash"));
-const test_utils_1 = require("../test/test-utils");
-const chart_to_ts_event_types_1 = require("../types/chart-to-ts-event.types");
-const ts_to_chart_event_types_1 = require("../types/ts-to-chart-event.types");
-const custom_chart_context_1 = require("./custom-chart-context");
-const PostMessageEventBridge = __importStar(require("./post-message-event-bridge"));
-jest.mock('./post-message-event-bridge');
-jest.spyOn(console, 'log').mockImplementation(() => {
-});
-describe('CustomChartContext', () => {
-    let eventProcessor;
-    let getDefaultChartConfig = jest.fn();
-    let getQueriesFromChartConfig = jest.fn();
-    let renderChart = jest.fn();
-    const mockInitMessage = jest.spyOn(PostMessageEventBridge, 'initMessageListener');
-    const mockPostMessageToHost = jest.spyOn(PostMessageEventBridge, 'postMessageToHostApp');
-    beforeEach(() => {
-        getDefaultChartConfig = jest.fn();
-        getQueriesFromChartConfig = jest.fn();
-        renderChart = jest.fn();
-        mockInitMessage.mockImplementation((fn) => {
-            eventProcessor = fn;
-        });
-        mockPostMessageToHost.mockImplementation(() => {
-            return global.Promise.resolve();
-        });
-    });
-    describe('initialize', () => {
-        let customChartContext;
-        beforeEach(() => {
-            customChartContext = new custom_chart_context_1.CustomChartContext({
-                getDefaultChartConfig,
-                getQueriesFromChartConfig,
-                renderChart,
-            });
-        });
-        afterEach(() => {
-            jest.resetAllMocks();
-            customChartContext.destroy();
-            eventProcessor = null;
-        });
-        test('should wait till the parent calls initialize', async () => {
-            expect(mockInitMessage).toHaveBeenCalled();
-            const promise = customChartContext.initialize();
-            const rej = jest.fn();
-            const res = jest.fn();
-            promise.then(() => rej()).catch(() => res());
-            await new global.Promise((resolve) => {
-                setTimeout(() => resolve(null), 3000);
-            });
-            expect(rej).not.toHaveBeenCalled();
-            expect(res).not.toHaveBeenCalled();
-        });
-        test('should return a promise that resolves when the chart context is initialized', async () => {
-            expect(mockInitMessage).toHaveBeenCalled();
-            const promise = customChartContext.initialize();
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            await expect(promise).resolves.toBeUndefined();
-            expect(mockPostMessage).toHaveBeenCalledTimes(2);
-            expect(mockPostMessage.mock.calls[0][0]).toEqual({
-                isConfigValid: false,
-                defaultChartConfig: undefined,
-                chartConfigEditorDefinition: undefined,
-                visualPropEditorDefinition: undefined,
-            });
-            expect(mockPostMessage).toHaveBeenCalled();
-            expect(mockPostMessageToHost).not.toHaveBeenCalled();
-        });
-        test('multiple intializations should throw an error', async () => {
-            const promise = customChartContext.initialize();
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            await expect(promise).resolves.toBeUndefined();
-            let error;
-            try {
-                customChartContext = new custom_chart_context_1.CustomChartContext({
-                    getDefaultChartConfig,
-                    getQueriesFromChartConfig,
-                    renderChart,
-                });
-            }
-            catch (err) {
-                error = err.message;
-            }
-            expect(error).toBe(chart_to_ts_event_types_1.ErrorType.MultipleContextsNotSupported);
-            try {
-                await (0, custom_chart_context_1.getChartContext)({
-                    getDefaultChartConfig,
-                    getQueriesFromChartConfig,
-                    renderChart,
-                });
-            }
-            catch (err) {
-                error = err.message;
-            }
-            expect(error).toBe(chart_to_ts_event_types_1.ErrorType.MultipleContextsNotSupported);
-        });
-    });
-    describe('on', () => {
-        let customChartContext;
-        beforeEach(() => {
-            customChartContext = new custom_chart_context_1.CustomChartContext({
-                getDefaultChartConfig,
-                getQueriesFromChartConfig,
-                renderChart,
-            });
-        });
-        afterEach(() => {
-            jest.resetAllMocks();
-            customChartContext.destroy();
-            eventProcessor = null;
-        });
-        test('should not trigger post message if host is not accurate', () => {
-            expect(mockInitMessage).toHaveBeenCalled();
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.ChartConfigValidate,
-                    source: 'incorrect-source',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockPostMessage).not.toHaveBeenCalled();
-        });
-        test('default internal function testing', () => {
-            expect(mockInitMessage).toHaveBeenCalled();
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.ChartConfigValidate,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockPostMessage).toHaveBeenCalledWith({
-                isValid: true,
-            });
-            mockPostMessage.mockReset();
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.VisualPropsValidate,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockPostMessage).toHaveBeenCalledWith({
-                isValid: true,
-            });
-            mockPostMessage.mockReset();
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.TriggerRenderChart,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockPostMessage).toHaveBeenCalledWith({});
-            expect(renderChart).toHaveBeenCalled();
-            mockPostMessage.mockReset();
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.GetDataQuery,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockPostMessage).toHaveBeenCalledWith({});
-            expect(getQueriesFromChartConfig).toHaveBeenCalled();
-        });
-        test('default external function testing', () => {
-            expect(mockInitMessage).toHaveBeenCalled();
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: {
-                        data: 'random data',
-                    },
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.DataUpdate,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockPostMessage).toHaveBeenCalledWith({
-                triggerRenderChart: true,
-            });
-            expect(customChartContext.getChartModel().data).toBe('random data');
-            mockPostMessage.mockReset();
-            eventProcessor({
-                data: {
-                    payload: {
-                        chartModel: {
-                            data: 'random data2',
-                            visualProps: null,
-                        },
-                    },
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.ChartModelUpdate,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockPostMessage).toHaveBeenCalledWith({
-                triggerRenderChart: true,
-            });
-            expect(customChartContext.getChartModel().data).toBe('random data2');
-            expect(customChartContext.getChartModel().visualProps).toBe(null);
-            mockPostMessage.mockReset();
-            eventProcessor({
-                data: {
-                    payload: {
-                        visualProps: 'random data',
-                    },
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.VisualPropsUpdate,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockPostMessage).toHaveBeenCalledWith({
-                triggerRenderChart: true,
-            });
-            expect(customChartContext.getChartModel().visualProps).toBe('random data');
-            mockPostMessage.mockReset();
-            customChartContext.axisMenuCustomActionPreProcessor([
-                {
-                    customActions: [
-                        {
-                            icon: '',
-                            id: 'custom-action-1',
-                            label: 'Custom user action 1',
-                            onClick: () => lodash_1.default.noop(),
-                        },
-                    ],
-                },
-            ]);
-            eventProcessor({
-                data: {
-                    payload: {
-                        customAction: {
-                            id: 'custom-action-1',
-                            columnIds: ['9f96b5b0-f7e4-4a5e-aa11-4c77fdf42125'],
-                        },
-                    },
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.AxisMenuActionClick,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockPostMessage).toHaveBeenCalledWith({
-                isValid: true,
-            });
-            customChartContext.contextMenuCustomActionPreProcessor([
-                {
-                    customActions: [
-                        {
-                            icon: '',
-                            id: 'custom-action-1',
-                            label: 'Custom user action 1',
-                            onClick: () => lodash_1.default.noop(),
-                        },
-                    ],
-                },
-            ]);
-            eventProcessor({
-                data: {
-                    payload: {
-                        customAction: {
-                            id: 'custom-action-1',
-                            columnIds: ['9f96b5b0-f7e4-4a5e-aa11-4c77fdf42125'],
-                        },
-                    },
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.ContextMenuActionClick,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockPostMessage).toHaveBeenCalledWith({
-                isValid: true,
-            });
-        });
-        test('should add an event listener to the specified event type', () => {
-            expect(mockInitMessage).toHaveBeenCalled();
-            const TEST_EVENT_TYPE = 'testEventType';
-            const testCallbackFn = jest.fn();
-            customChartContext.on(TEST_EVENT_TYPE, testCallbackFn);
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: TEST_EVENT_TYPE,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(testCallbackFn).toHaveBeenCalled();
-        });
-        test('should respond with an error to an unspecified event type', () => {
-            expect(mockInitMessage).toHaveBeenCalled();
-            const TEST_EVENT_TYPE = 'testEventType';
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: TEST_EVENT_TYPE,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockPostMessage).toHaveBeenCalledWith({
-                hasError: true,
-                error: `Event type not recognised or processed: ${TEST_EVENT_TYPE}`,
-            });
-        });
-    });
-    describe('off', () => {
-        let customChartContext;
-        beforeEach(() => {
-            customChartContext = new custom_chart_context_1.CustomChartContext({
-                getDefaultChartConfig,
-                getQueriesFromChartConfig,
-                renderChart,
-            });
-        });
-        afterEach(() => {
-            customChartContext.destroy();
-            eventProcessor = null;
-            jest.resetAllMocks();
-        });
-        test('should remove the event listener for the specified event type', () => {
-            const TEST_EVENT_TYPE = 'testEventType';
-            const testCallbackFn = jest.fn();
-            customChartContext.on(TEST_EVENT_TYPE, testCallbackFn);
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: TEST_EVENT_TYPE,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            customChartContext.off(TEST_EVENT_TYPE);
-            expect(testCallbackFn).toHaveBeenCalled();
-            expect(customChartContext.eventListeners[TEST_EVENT_TYPE]).toHaveLength(0);
-        });
-        test('should remove a specific event listener without affecting others', () => {
-            const TEST_EVENT_TYPE_1 = 'testEventType1';
-            const TEST_EVENT_TYPE_2 = 'testEventType2';
-            const testCallbackFn1 = jest.fn();
-            const testCallbackFn2 = jest.fn();
-            customChartContext.on(TEST_EVENT_TYPE_1, testCallbackFn1);
-            customChartContext.on(TEST_EVENT_TYPE_2, testCallbackFn2);
-            expect(customChartContext.eventListeners[TEST_EVENT_TYPE_1]).toHaveLength(1);
-            expect(customChartContext.eventListeners[TEST_EVENT_TYPE_2]).toHaveLength(1);
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: TEST_EVENT_TYPE_1,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: TEST_EVENT_TYPE_2,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(testCallbackFn1).toHaveBeenCalled();
-            expect(testCallbackFn2).toHaveBeenCalled();
-            customChartContext.off(TEST_EVENT_TYPE_1);
-            expect(customChartContext.eventListeners[TEST_EVENT_TYPE_1]).toHaveLength(0);
-            expect(customChartContext.eventListeners[TEST_EVENT_TYPE_2]).toHaveLength(1);
-        });
-        test('should make sure not to throw error when off is called before', () => {
-            const TEST_EVENT_TYPE_1 = 'testEventType1';
-            customChartContext.off(TEST_EVENT_TYPE_1);
-            expect(customChartContext.eventListeners[TEST_EVENT_TYPE_1]).toHaveLength(0);
-        });
-    });
-    describe('emitEvent', () => {
-        let customChartContext;
-        beforeEach(() => {
-            customChartContext = new custom_chart_context_1.CustomChartContext({
-                getDefaultChartConfig,
-                getQueriesFromChartConfig,
-                renderChart,
-            });
-        });
-        afterEach(() => {
-            customChartContext.destroy();
-            eventProcessor = null;
-            jest.resetAllMocks();
-        });
-        test('should reject the promise if the chart context is not initialized', async () => {
-            const TEST_EVENT_TYPE = 'testEventType';
-            const testPayload = { value: 'testPayload' };
-            const result = customChartContext.emitEvent(TEST_EVENT_TYPE, testPayload);
-            expect(mockPostMessageToHost).not.toHaveBeenCalled();
-            await expect(result).rejects.toBeDefined();
-        });
-        test('should resolve the promise if the chart context is initialized', async () => {
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            const promise = customChartContext.initialize();
-            await expect(promise).resolves.toBeUndefined();
-            expect(mockPostMessage).toHaveBeenCalledTimes(2);
-            let resolve;
-            mockPostMessageToHost.mockImplementation(() => new global.Promise((res) => {
-                resolve = res;
-            }));
-            const TEST_EVENT_TYPE = 'testEventType';
-            const testPayload = { value: 'testPayload' };
-            const result = customChartContext.emitEvent(TEST_EVENT_TYPE, testPayload);
-            global.setTimeout(() => resolve('helloworld'), 1000);
-            await expect(result).resolves.toEqual('helloworld');
-            expect(mockPostMessageToHost).toHaveBeenCalledWith(test_utils_1.mockInitializeContextPayload.componentId, test_utils_1.mockInitializeContextPayload.hostUrl, testPayload, TEST_EVENT_TYPE);
-            mockPostMessageToHost.mockReset();
-            mockPostMessageToHost.mockImplementation(() => new global.Promise((res) => {
-                resolve = res;
-            }));
-            const result2 = customChartContext.emitEvent(chart_to_ts_event_types_1.ChartToTSEvent.RenderStart);
-            global.setTimeout(() => resolve('helloworld'), 1000);
-            await expect(result2).resolves.toEqual('helloworld');
-            expect(mockPostMessageToHost).toHaveBeenCalledWith(test_utils_1.mockInitializeContextPayload.componentId, test_utils_1.mockInitializeContextPayload.hostUrl, null, chart_to_ts_event_types_1.ChartToTSEvent.RenderStart);
-        });
-        test('should process the event payload for context menu custom actions', async () => {
-            const mockPostMessage = jest.fn();
-            const mockCustomAction = jest.fn();
-            let resolve;
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            customChartContext.initialize();
-            mockPostMessageToHost.mockImplementation(() => new global.Promise((res) => {
-                resolve = res;
-            }));
-            const TEST_EVENT_TYPE = chart_to_ts_event_types_1.ChartToTSEvent.OpenContextMenu;
-            const testPayload = {
-                customActions: [
-                    {
-                        id: 'custom-action-1',
-                        label: 'Custom user action 1',
-                        icon: '',
-                        onClick: mockCustomAction,
-                    },
-                ],
-            };
-            customChartContext.emitEvent(TEST_EVENT_TYPE, testPayload);
-            expect(mockPostMessageToHost).toHaveBeenCalledWith(test_utils_1.mockInitializeContextPayload.componentId, test_utils_1.mockInitializeContextPayload.hostUrl, {
-                customActions: [
-                    {
-                        icon: '',
-                        id: 'custom-action-1',
-                        label: 'Custom user action 1',
-                    },
-                ],
-            }, TEST_EVENT_TYPE);
-            eventProcessor({
-                data: {
-                    payload: {
-                        customAction: {
-                            id: 'custom-action-1',
-                            clickedPoint: {},
-                            event: {},
-                            selectedPoints: [{}],
-                        },
-                    },
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.ContextMenuActionClick,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockCustomAction).toHaveBeenCalled();
-            expect(mockCustomAction).toHaveBeenCalledWith({
-                clickedPoint: {},
-                event: {},
-                id: 'custom-action-1',
-                selectedPoints: [{}],
-            });
-        });
-        test('should process the event payload for axis menu custom actions', async () => {
-            const mockPostMessage = jest.fn();
-            const mockCustomAction = jest.fn();
-            let resolve;
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            customChartContext.initialize();
-            mockPostMessageToHost.mockImplementation(() => new global.Promise((res) => {
-                resolve = res;
-            }));
-            const TEST_EVENT_TYPE = chart_to_ts_event_types_1.ChartToTSEvent.OpenAxisMenu;
-            const testPayload = {
-                customActions: [
-                    {
-                        id: 'custom-action-1',
-                        label: 'Custom user action 1',
-                        icon: '',
-                        onClick: mockCustomAction,
-                    },
-                ],
-            };
-            customChartContext.emitEvent(TEST_EVENT_TYPE, testPayload);
-            expect(mockPostMessageToHost).toHaveBeenCalledWith(test_utils_1.mockInitializeContextPayload.componentId, test_utils_1.mockInitializeContextPayload.hostUrl, {
-                customActions: [
-                    {
-                        icon: '',
-                        id: 'custom-action-1',
-                        label: 'Custom user action 1',
-                    },
-                ],
-            }, TEST_EVENT_TYPE);
-            eventProcessor({
-                data: {
-                    payload: {
-                        customAction: {
-                            id: 'custom-action-1',
-                            columnIds: ['123'],
-                            event: {},
-                        },
-                    },
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.AxisMenuActionClick,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            expect(mockCustomAction).toHaveBeenCalled();
-            expect(mockCustomAction).toHaveBeenCalledWith({
-                id: 'custom-action-1',
-                columnIds: ['123'],
-                event: {},
-            });
-        });
-        test('should process the event payload for axis menu when custom actions are not defined', async () => {
-            const mockPostMessage = jest.fn();
-            let resolve;
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            customChartContext.initialize();
-            mockPostMessageToHost.mockImplementation(() => new global.Promise((res) => {
-                resolve = res;
-            }));
-            const TEST_EVENT_TYPE = chart_to_ts_event_types_1.ChartToTSEvent.OpenAxisMenu;
-            const testPayload = {};
-            customChartContext.emitEvent(TEST_EVENT_TYPE, testPayload);
-            expect(mockPostMessageToHost).toHaveBeenCalledWith(test_utils_1.mockInitializeContextPayload.componentId, test_utils_1.mockInitializeContextPayload.hostUrl, {}, TEST_EVENT_TYPE);
-        });
-        test('should process the event payload for context menu when custom actions are not defined', async () => {
-            const mockPostMessage = jest.fn();
-            let resolve;
-            eventProcessor({
-                data: {
-                    payload: test_utils_1.mockInitializeContextPayload,
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: ts_to_chart_event_types_1.TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
-            });
-            customChartContext.initialize();
-            mockPostMessageToHost.mockImplementation(() => new global.Promise((res) => {
-                resolve = res;
-            }));
-            const TEST_EVENT_TYPE = chart_to_ts_event_types_1.ChartToTSEvent.OpenContextMenu;
-            const testPayload = {};
-            customChartContext.emitEvent(TEST_EVENT_TYPE, testPayload);
-            expect(mockPostMessageToHost).toHaveBeenCalledWith(test_utils_1.mockInitializeContextPayload.componentId, test_utils_1.mockInitializeContextPayload.hostUrl, {}, TEST_EVENT_TYPE);
-        });
-    });
-});
-//# sourceMappingURL=custom-chart-context.spec.js.map