@thoughtspot/visual-embed-sdk 1.26.6 → 1.26.7

package/src/embed/ts-embed.spec.ts

@@ -1,37 +1,38 @@
 /* eslint-disable dot-notation */
+import * as authInstance from '../auth';
 import { resetCachedAuthToken } from '../authToken';
+import * as config from '../config';
 import {
+    AppEmbed,
     AuthType,
-    init,
     EmbedEvent,
-    SearchEmbed,
-    PinboardEmbed,
-    LiveboardViewConfig,
-    AppEmbed,
     LiveboardEmbed,
+    LiveboardViewConfig,
+    PinboardEmbed,
+    SearchEmbed,
+    init,
 } from '../index';
+import * as mixpanelInstance from '../mixpanel-service';
+import { MIXPANEL_EVENT } from '../mixpanel-service';
 import {
-    Action, HomeLeftNavItem, RuntimeFilter, RuntimeFilterOp, HomepageModule,
-} from '../types';
-import {
+    defaultParamsForPinboardEmbed,
     executeAfterWait,
+    expectUrlMatchesWithParams,
     getDocumentBody,
     getIFrameEl,
     getIFrameSrc,
     getRootEl,
+    mockMessageChannel,
     postMessageToParent,
-    defaultParamsForPinboardEmbed,
     waitFor,
-    expectUrlMatchesWithParams,
-    mockMessageChannel,
 } from '../test/test-utils';
-import * as config from '../config';
-import * as tsEmbedInstance from './ts-embed';
-import * as mixpanelInstance from '../mixpanel-service';
-import * as authInstance from '../auth';
-import * as baseInstance from './base';
-import { MIXPANEL_EVENT } from '../mixpanel-service';
+import {
+    Action, HomeLeftNavItem, HomepageModule, RuntimeFilter, RuntimeFilterOp,
+} from '../types';
 import * as authService from '../utils/authService/authService';
+import { logger } from '../utils/logger';
+import * as baseInstance from './base';
+import * as tsEmbedInstance from './ts-embed';
 
 const defaultViewConfig = {
     frameParams: {
@@ -425,7 +426,7 @@ describe('Unit test case for ts embed', () => {
             const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
             searchEmbed
                 .on(EmbedEvent.Save, () => {
-                    console.log('non callable');
+                    logger.log('non callable');
                 })
                 .render();
 
@@ -468,7 +469,7 @@ describe('Unit test case for ts embed', () => {
                 .on(
                     EmbedEvent.Save,
                     () => {
-                        console.log('non callable');
+                        logger.log('non callable');
                     },
                     { start: true },
                 )
@@ -562,6 +563,144 @@ describe('Unit test case for ts embed', () => {
         });
     });
 
+    describe('Token fetch fails in cookieless authentication authType', () => {
+        beforeEach(() => {
+            jest.spyOn(authInstance, 'doCookielessTokenAuth').mockResolvedValueOnce(true);
+            init({
+                thoughtSpotHost: 'tshost',
+                customizations: customisations,
+                customCssUrl: 'http://localhost:5000',
+                authType: AuthType.TrustedAuthTokenCookieless,
+                getAuthToken: () => Promise.reject(),
+            });
+        });
+
+        afterEach(() => {
+            jest.clearAllMocks();
+            baseInstance.reset();
+        });
+
+        test('should show login failure message if token failed during app_init', async () => {
+            const a = jest.spyOn(authService, 'verifyTokenService');
+            a.mockResolvedValue(true);
+
+            // authVerifyMock.mockResolvedValue(true);
+            const mockEmbedEventPayload = {
+                type: EmbedEvent.APP_INIT,
+                data: {},
+            };
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            searchEmbed.render();
+            const mockPort: any = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
+            });
+            await executeAfterWait(() => {
+                expect(mockPort.postMessage).not.toHaveBeenCalled();
+                expect(getRootEl().innerHTML).toContain('Not logged in');
+            });
+
+            jest.spyOn(authService, 'verifyTokenService').mockClear();
+        });
+
+        test('should show login failure message if token failed during app_init prerender', async () => {
+            const a = jest.spyOn(authService, 'verifyTokenService');
+            a.mockResolvedValue(true);
+
+            // authVerifyMock.mockResolvedValue(true);
+            const mockEmbedEventPayload = {
+                type: EmbedEvent.APP_INIT,
+                data: {},
+            };
+            const searchEmbed = new SearchEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                preRenderId: 'test',
+            });
+            searchEmbed.preRender();
+            const mockPort: any = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
+            });
+            const preRenderWrapper = document.getElementById('tsEmbed-pre-render-wrapper-test');
+            await executeAfterWait(() => {
+                expect(mockPort.postMessage).not.toHaveBeenCalled();
+                expect(preRenderWrapper.innerHTML).toContain('Not logged in');
+            });
+
+            jest.spyOn(authService, 'verifyTokenService').mockClear();
+        });
+
+        test('should show login failure message if update token failed', async () => {
+            const a = jest.spyOn(authService, 'verifyTokenService');
+            a.mockResolvedValue(true);
+
+            // authVerifyMock.mockResolvedValue(true);
+            const mockEmbedEventPayload = {
+                type: EmbedEvent.AuthExpire,
+                data: {},
+            };
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            jest.spyOn(baseInstance, 'notifyAuthFailure');
+            searchEmbed.render();
+            const mockPort: any = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
+            });
+            await executeAfterWait(() => {
+                expect(getRootEl().innerHTML).toContain('Not logged in');
+                expect(baseInstance.notifyAuthFailure).toBeCalledWith(
+                    authInstance.AuthFailureType.EXPIRY,
+                );
+            });
+
+            jest.spyOn(authService, 'verifyTokenService').mockClear();
+            jest.spyOn(baseInstance, 'notifyAuthFailure').mockClear();
+        });
+
+        test('should show login failure message if update token failed prerender', async () => {
+            const a = jest.spyOn(authService, 'verifyTokenService');
+            a.mockResolvedValue(true);
+
+            // authVerifyMock.mockResolvedValue(true);
+            const mockEmbedEventPayload = {
+                type: EmbedEvent.AuthExpire,
+                data: {},
+            };
+            const searchEmbed = new SearchEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                preRenderId: 'test',
+            });
+            jest.spyOn(baseInstance, 'notifyAuthFailure');
+            searchEmbed.preRender();
+            const mockPort: any = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
+            });
+            const preRenderWrapper = document.getElementById('tsEmbed-pre-render-wrapper-test');
+            await executeAfterWait(() => {
+                expect(preRenderWrapper.innerHTML).toContain('Not logged in');
+                expect(baseInstance.notifyAuthFailure).toBeCalledWith(
+                    authInstance.AuthFailureType.EXPIRY,
+                );
+            });
+
+            jest.spyOn(authService, 'verifyTokenService').mockClear();
+            jest.spyOn(baseInstance, 'notifyAuthFailure').mockClear();
+        });
+    });
+
     xdescribe('AuthExpire embedEvent in TrustedAuthToken authType', () => {
         test('AutoLogin true scenario', async () => {
             init({
@@ -698,7 +837,7 @@ describe('Unit test case for ts embed', () => {
             const iFrame: any = document.createElement('div');
             iFrame.contentWindow = null;
             jest.spyOn(document, 'createElement').mockReturnValueOnce(iFrame);
-            spyOn(console, 'error');
+            spyOn(logger, 'error');
             tsEmbed.render();
         });
 
@@ -712,7 +851,7 @@ describe('Unit test case for ts embed', () => {
 
     describe('when visible actions are set', () => {
         test('should throw error when there are both visible and hidden actions - pinboard', async () => {
-            spyOn(console, 'error');
+            spyOn(logger, 'error');
             const pinboardEmbed = new PinboardEmbed(getRootEl(), {
                 hiddenActions: [Action.DownloadAsCsv],
                 visibleActions: [Action.DownloadAsCsv],
@@ -721,7 +860,7 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             await pinboardEmbed.render();
             expect(pinboardEmbed['isError']).toBe(true);
-            expect(console.error).toHaveBeenCalledWith(
+            expect(logger.error).toHaveBeenCalledWith(
                 'You cannot have both hidden actions and visible actions',
             );
         });
@@ -744,7 +883,7 @@ describe('Unit test case for ts embed', () => {
             hiddenActions: Array<Action>,
             visibleActions: Array<Action>,
         ) {
-            spyOn(console, 'error');
+            spyOn(logger, 'error');
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 hiddenActions,
                 visibleActions,
@@ -753,7 +892,7 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             await liveboardEmbed.render();
             expect(liveboardEmbed['isError']).toBe(true);
-            expect(console.error).toHaveBeenCalledWith(
+            expect(logger.error).toHaveBeenCalledWith(
                 'You cannot have both hidden actions and visible actions',
             );
         }
@@ -789,7 +928,7 @@ describe('Unit test case for ts embed', () => {
 
     describe('when visible Tabs are set', () => {
         test('should throw error when there are both visible and hidden Tabs - pinboard', async () => {
-            spyOn(console, 'error');
+            spyOn(logger, 'error');
             const pinboardEmbed = new PinboardEmbed(getRootEl(), {
                 visibleTabs: [tabId1],
                 hiddenTabs: [tabId2],
@@ -798,7 +937,7 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             await pinboardEmbed.render();
             expect(pinboardEmbed['isError']).toBe(true);
-            expect(console.error).toHaveBeenCalledWith(
+            expect(logger.error).toHaveBeenCalledWith(
                 'You cannot have both hidden Tabs and visible Tabs',
             );
         });
@@ -821,7 +960,7 @@ describe('Unit test case for ts embed', () => {
             hiddenTabs: Array<string>,
             visibleTabs: Array<string>,
         ) {
-            spyOn(console, 'error');
+            spyOn(logger, 'error');
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 hiddenTabs,
                 visibleTabs,
@@ -830,7 +969,7 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             await liveboardEmbed.render();
             expect(liveboardEmbed['isError']).toBe(true);
-            expect(console.error).toHaveBeenCalledWith(
+            expect(logger.error).toHaveBeenCalledWith(
                 'You cannot have both hidden Tabs and visible Tabs',
             );
         }
@@ -874,11 +1013,11 @@ describe('Unit test case for ts embed', () => {
         });
 
         test('Error should be true', async () => {
-            spyOn(console, 'error');
+            spyOn(logger, 'error');
             const tsEmbed = new SearchEmbed(getRootEl(), {});
             tsEmbed.render();
             expect(tsEmbed['isError']).toBe(true);
-            expect(console.error).toHaveBeenCalledWith(
+            expect(logger.error).toHaveBeenCalledWith(
                 'You need to init the ThoughtSpot SDK module first',
             );
         });
@@ -886,13 +1025,13 @@ describe('Unit test case for ts embed', () => {
 
     describe('V1Embed ', () => {
         test('when isRendered is true than isError will be true', () => {
-            spyOn(console, 'error');
+            spyOn(logger, 'error');
             const viEmbedIns = new tsEmbedInstance.V1Embed(getRootEl(), defaultViewConfig);
             expect(viEmbedIns['isError']).toBe(false);
             viEmbedIns.render();
             viEmbedIns.on(EmbedEvent.CustomAction, jest.fn()).render();
             expect(viEmbedIns['isError']).toBe(true);
-            expect(console.error).toHaveBeenCalledWith(
+            expect(logger.error).toHaveBeenCalledWith(
                 'Please register event handlers before calling render',
             );
         });
@@ -933,7 +1072,7 @@ describe('Unit test case for ts embed', () => {
         });
 
         test('navigateToPage function use before render', async () => {
-            spyOn(console, 'log');
+            spyOn(logger, 'log');
             const appEmbed = new AppEmbed(getRootEl(), {
                 frameParams: {
                     width: '100%',
@@ -942,7 +1081,7 @@ describe('Unit test case for ts embed', () => {
             });
             appEmbed.navigateToPage(path, false);
             await appEmbed.render();
-            expect(console.log).toHaveBeenCalledWith(
+            expect(logger.log).toHaveBeenCalledWith(
                 'Please call render before invoking this method',
             );
         });
@@ -1330,7 +1469,7 @@ describe('Unit test case for ts embed', () => {
                 });
 
             // show preRender
-            const warnSpy = spyOn(console, 'warn');
+            const warnSpy = spyOn(logger, 'warn');
             libEmbed.showPreRender();
             expect(warnSpy).toHaveBeenCalledTimes(0);
 
@@ -1360,13 +1499,13 @@ describe('Unit test case for ts embed', () => {
         it('preRender called without preRenderId should log error ', () => {
             createRootEleForEmbed();
 
-            spyOn(console, 'error');
+            spyOn(logger, 'error');
             const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
                 liveboardId: 'myLiveboardId',
             });
             libEmbed.preRender();
 
-            expect(console.error).toHaveBeenCalledWith('PreRender id is required for preRender');
+            expect(logger.error).toHaveBeenCalledWith('PreRender id is required for preRender');
         });
 
         it('showPreRender should preRender if not available', async () => {
@@ -1414,7 +1553,7 @@ describe('Unit test case for ts embed', () => {
 
             libEmbed.preRender();
             await waitFor(() => !!getIFrameEl());
-            const warnSpy = jest.spyOn(console, 'warn');
+            const warnSpy = jest.spyOn(logger, 'warn');
             const newEmbed = new LiveboardEmbed('#tsEmbedDiv', {
                 preRenderId: 'i-am-preRendered',
                 liveboardId: 'awdawda',
@@ -1433,10 +1572,10 @@ describe('Unit test case for ts embed', () => {
                 liveboardId: 'myLiveboardId',
             });
             spyOn(libEmbed, 'preRender');
-            spyOn(console, 'error');
+            spyOn(logger, 'error');
             libEmbed.showPreRender();
             expect(libEmbed.preRender).toHaveBeenCalledTimes(0);
-            expect(console.error).toHaveBeenCalledTimes(1);
+            expect(logger.error).toHaveBeenCalledTimes(1);
         });
 
         it('should get underlying iframe', async () => {
@@ -1464,16 +1603,16 @@ describe('Unit test case for ts embed', () => {
             );
         });
         it('should log error if sync is called before preRender', async () => {
-            jest.spyOn(console, 'error').mockImplementation(jest.fn());
+            jest.spyOn(logger, 'error').mockImplementation(jest.fn());
             const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
                 liveboardId: 'myLiveboardId',
                 preRenderId: 'test',
             });
             await libEmbed.syncPreRenderStyle();
-            expect(console.error).toBeCalledWith(
+            expect(logger.error).toBeCalledWith(
                 'PreRender should be called before using syncPreRenderStyle',
             );
-            (console.error as any).mockClear();
+            (logger.error as any).mockClear();
         });
     });
 });

package/src/embed/ts-embed.ts

@@ -8,57 +8,54 @@
  */
 
 import isEqual from 'lodash/isEqual';
-
+import pkgInfo from '../../package.json';
+import { AuthFailureType } from '../auth';
 import { getAuthenticationToken } from '../authToken';
-import { AnswerService } from '../utils/graphql/answerService/answerService';
 import {
-    getEncodedQueryParamsString,
-    getCssDimension,
-    getOffsetTop,
-    embedEventStatus,
-    setAttributes,
-    getCustomisations,
-    getRuntimeFilters,
-    getDOMNode,
-    getFilterQuery,
-    getQueryParamString,
-    getRuntimeParameters,
-    setStyleProperties,
-    removeStyleProperties,
-    isUndefined,
-} from '../utils';
-import {
-    getThoughtSpotHost,
-    URL_MAX_LENGTH,
-    DEFAULT_EMBED_WIDTH,
     DEFAULT_EMBED_HEIGHT,
+    DEFAULT_EMBED_WIDTH,
+    URL_MAX_LENGTH,
+    getThoughtSpotHost,
     getV2BasePath,
 } from '../config';
+import { MIXPANEL_EVENT, uploadMixpanelEvent } from '../mixpanel-service';
 import {
+    Action,
     AuthType,
+    ContextMenuTriggerOptions,
     DOMSelector,
-    HostEvent,
+    EmbedConfig,
     EmbedEvent,
+    HostEvent,
     MessageCallback,
-    Action,
-    Param,
-    EmbedConfig,
-    MessageOptions,
-    MessagePayload,
     MessageCallbackObj,
+    MessageOptions,
+    Param,
     ViewConfig,
-    FrameParams,
-    ContextMenuTriggerOptions,
-    RuntimeFilter,
 } from '../types';
-import { uploadMixpanelEvent, MIXPANEL_EVENT } from '../mixpanel-service';
-import { processEventData } from '../utils/processData';
+import {
+    embedEventStatus,
+    getCssDimension,
+    getCustomisations,
+    getDOMNode,
+    getEncodedQueryParamsString,
+    getFilterQuery,
+    getOffsetTop,
+    getQueryParamString,
+    getRuntimeFilters,
+    getRuntimeParameters,
+    isUndefined,
+    removeStyleProperties,
+    setAttributes,
+    setStyleProperties,
+} from '../utils';
+import { AnswerService } from '../utils/graphql/answerService/answerService';
+import { logger } from '../utils/logger';
+import { processAuthFailure, processEventData } from '../utils/processData';
 import { processTrigger } from '../utils/processTrigger';
-import pkgInfo from '../../package.json';
 import {
-    getAuthPromise, renderInQueue, handleAuth, notifyAuthFailure,
+    getAuthPromise, handleAuth, notifyAuthFailure, renderInQueue,
 } from './base';
-import { AuthFailureType } from '../auth';
 import { getEmbedConfig } from './embedConfig';
 
 const { version } = pkgInfo;
@@ -196,7 +193,7 @@ export class TsEmbed {
             error,
         });
         // Log error
-        console.error(error);
+        logger.error(error);
     }
 
     /**
@@ -280,7 +277,7 @@ export class TsEmbed {
             this.executeCallbacks(EmbedEvent.Error, {
                 offlineWarning,
             });
-            console.warn(offlineWarning);
+            logger.warn(offlineWarning);
         };
         window.addEventListener('offline', offlineEventListener);
 
@@ -306,7 +303,12 @@ export class TsEmbed {
     private appInitCb = async (_: any, responder: any) => {
         let authToken = '';
         if (this.embedConfig.authType === AuthType.TrustedAuthTokenCookieless) {
-            authToken = await getAuthenticationToken(this.embedConfig);
+            try {
+                authToken = await getAuthenticationToken(this.embedConfig);
+            } catch (e) {
+                processAuthFailure(e, this.isPreRendered ? this.preRenderWrapper : this.el);
+                return;
+            }
         }
         this.isAppInitialized = true;
         responder({
@@ -336,11 +338,16 @@ export class TsEmbed {
     private updateAuthToken = async (_: any, responder: any) => {
         const { autoLogin = false, authType } = this.embedConfig; // Set autoLogin default to false
         if (authType === AuthType.TrustedAuthTokenCookieless) {
-            const authToken = await getAuthenticationToken(this.embedConfig);
-            responder({
-                type: EmbedEvent.AuthExpire,
-                data: { authToken },
-            });
+            let authToken = '';
+            try {
+                authToken = await getAuthenticationToken(this.embedConfig);
+                responder({
+                    type: EmbedEvent.AuthExpire,
+                    data: { authToken },
+                });
+            } catch (e) {
+                processAuthFailure(e, this.isPreRendered ? this.preRenderWrapper : this.el);
+            }
         } else if (autoLogin) {
             handleAuth();
         }
@@ -490,6 +497,9 @@ export class TsEmbed {
             queryParams[Param.ShowInsertToSlide] = insertInToSlide;
         }
 
+        queryParams[Param.OverrideNativeConsole] = true;
+        queryParams[Param.ClientLogLevel] = this.embedConfig.logLevel;
+
         return queryParams;
     }
 
@@ -505,7 +515,11 @@ export class TsEmbed {
         const queryParams = this.shouldEncodeUrlQueryParams
             ? `?base64UrlEncodedFlags=${getEncodedQueryParamsString(queryString)}`
             : `?${queryString}`;
-        const path = `${this.thoughtSpotHost}/${queryParams}#`;
+        let host = this.thoughtSpotHost;
+        if (!isUndefined(this.embedConfig.enableReactShell)) {
+            host = (this.embedConfig.enableReactShell as boolean) ? '/v2' : '/v1';
+        }
+        const path = `${host}/${queryParams}#`;
         return path;
     }
 
@@ -524,6 +538,7 @@ export class TsEmbed {
 
         iFrame.src = frameSrc;
         iFrame.id = TS_EMBED_ID;
+        iFrame.setAttribute('data-ts-iframe', 'true');
 
         // according to screenfull.js documentation
         // allowFullscreen, webkitallowfullscreen and mozallowfullscreen must be
@@ -664,7 +679,7 @@ export class TsEmbed {
     protected connectPreRendered(): boolean {
         const preRenderIds = this.getPreRenderIds();
         this.preRenderWrapper = this.preRenderWrapper
-            || document.getElementById(preRenderIds.wrapper);
+          || document.getElementById(preRenderIds.wrapper);
 
         this.preRenderChild = this.preRenderChild || document.getElementById(preRenderIds.child);
 
@@ -935,10 +950,10 @@ export class TsEmbed {
                 });
             } catch (e) {
                 eventPort.postMessage({ error: e });
-                console.log(e);
+                logger.log(e);
             }
         } else {
-            console.log('Event Port is not defined');
+            logger.log('Event Port is not defined');
         }
     }
 
@@ -966,6 +981,10 @@ export class TsEmbed {
         return this;
     }
 
+    public getIframeSrc(): string {
+        return '';
+    }
+
     protected handleRenderForPrerender() {
         this.render();
     }
@@ -977,7 +996,7 @@ export class TsEmbed {
      */
     public preRender(showPreRenderByDefault = false): TsEmbed {
         if (!this.viewConfig.preRenderId) {
-            console.error('PreRender id is required for preRender');
+            logger.error('PreRender id is required for preRender');
             return this;
         }
         this.isPreRendered = true;
@@ -1026,7 +1045,7 @@ export class TsEmbed {
             this.insertedDomEl?.parentNode.removeChild(this.insertedDomEl);
             this.unsubscribeToEvents();
         } catch (e) {
-            console.log('Error destroying TS Embed', e);
+            logger.log('Error destroying TS Embed', e);
         }
     }
 
@@ -1066,13 +1085,13 @@ export class TsEmbed {
                     !isUndefined(viewConfig[key])
                     && !isEqual(viewConfig[key], preRenderedObject.viewConfig[key])
                 ) {
-                    console.warn(
-                        'TS Embed component was pre-rendered with '
-                        + `"${key}" as "${JSON.stringify(preRenderedObject.viewConfig[key])}" `
-                        + `but a different value "${JSON.stringify(viewConfig[key])}" `
-                        + 'was passed to the Embed component. '
-                        + 'The new value provided is ignored, the value provided during '
-                        + 'preRender is used.',
+                    logger.warn(
+                        `${viewConfig.embedComponentType || 'Component'} was pre-rendered with `
+                            + `"${key}" as "${JSON.stringify(preRenderedObject.viewConfig[key])}" `
+                            + `but a different value "${JSON.stringify(viewConfig[key])}" `
+                            + 'was passed to the Embed component. '
+                            + 'The new value provided is ignored, the value provided during '
+                            + 'preRender is used.',
                     );
                 }
             });
@@ -1087,7 +1106,7 @@ export class TsEmbed {
      */
     public showPreRender(): void {
         if (!this.viewConfig.preRenderId) {
-            console.error('PreRender id is required for preRender');
+            logger.error('PreRender id is required for preRender');
             return;
         }
         if (!this.isPreRenderAvailable()) {
@@ -1136,7 +1155,7 @@ export class TsEmbed {
      */
     public syncPreRenderStyle(): void {
         if (!this.isPreRenderAvailable() || !this.el) {
-            console.error('PreRender should be called before using syncPreRenderStyle');
+            logger.error('PreRender should be called before using syncPreRenderStyle');
             return;
         }
         const elBoundingClient = this.el.getBoundingClientRect();
@@ -1156,7 +1175,7 @@ export class TsEmbed {
     public hidePreRender(): void {
         if (!this.isPreRenderAvailable()) {
             // if the embed component is not preRendered , nothing to hide
-            console.warn('PreRender should be called before hiding it using hidePreRender.');
+            logger.warn('PreRender should be called before hiding it using hidePreRender.');
             return;
         }
         const preRenderHideStyles = {

package/src/index.ts

@@ -45,6 +45,7 @@ import {
     customCssInterface,
     ContextMenuTriggerOptions,
     RuntimeParameter,
+    LogLevel,
 } from './types';
 import { CustomCssVariables } from './css-variables';
 import { SageEmbed, SageViewConfig } from './embed/sage';
@@ -101,4 +102,5 @@ export {
     customCssInterface,
     CustomCssVariables,
     RuntimeParameter,
+    LogLevel,
 };