#1932

Committed 06 Jun 2025 01:26PM UTC coverage: 93.61% (-0.2%) from 93.827%

Build # #1932

Build Type

Committed by

Commit Message

logger test failure

Pull Request Pull Request #215: SCAL-256749 present-event

Run Details

1103 of 1256 branches covered (87.82%)

Branch coverage included in aggregate %.

40 of 46 new or added lines in 3 files covered. (86.96%)

5 existing lines in 1 file now uncovered.

2662 of 2766 relevant lines covered (96.24%)

67.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.0

/src/utils/processData.ts

import { getEmbedConfig } from '../embed/embedConfig';
import {
    disableAutoLogin,
    notifyAuthFailure,
    notifyAuthSuccess,
    notifyLogout,
} from '../embed/base';
import { AuthFailureType } from '../auth';
import { AuthType, CustomActionPayload, EmbedEvent } from '../types';
import { AnswerService } from './graphql/answerService/answerService';
import { resetCachedAuthToken } from '../authToken';
import { ERROR_MESSAGE } from '../errors';
import { logger } from '../utils/logger';

/**
 * Default handler for exitPresentMode event - exits fullscreen
 */
function handleExitPresentMode(): void {
    const isInFullscreen = !!(
        document.fullscreenElement ||
        (document as any).webkitFullscreenElement ||
        (document as any).mozFullScreenElement ||
        (document as any).msFullscreenElement
    );

    if (!isInFullscreen) {
        // Document is not in fullscreen, nothing to do
        return;
    }

    // Trying to exit fullscreen with vendor prefixes
    const exitFullscreenMethods = [
        'exitFullscreen',
        'webkitExitFullscreen',
        'mozCancelFullScreen', 
        'msExitFullscreen'
    ];

    let fullscreenExited = false;
    
    for (const method of exitFullscreenMethods) {
        if (typeof (document as any)[method] === 'function') {
            try {
                const result = (document as any)[method]();
                // Handle promise-based methods
                if (result && typeof result.catch === 'function') {
                    result.catch((error: any) => {
                        logger.warn(`Failed to exit fullscreen using ${method}:`, error);
                    });
                }
                fullscreenExited = true;
                break;
            } catch (error) {
                logger.warn(`Failed to exit fullscreen using ${method}:`, error);
            }
        }
    }

    if (!fullscreenExited) {
        logger.warn('Exit fullscreen API is not supported by this browser.');
    }
}

/**
 * Process the ExitPresentMode event and handle default fullscreen exit
 * @param e - The event data
 */
function processExitPresentMode(e: any) {
    handleExitPresentMode();
    return e;
}

/**
 *
 * @param e
 * @param thoughtSpotHost
 */
export function processCustomAction(e: any, thoughtSpotHost: string) {
    const { session, embedAnswerData, contextMenuPoints } = e.data as CustomActionPayload;
    const answerService = new AnswerService(
        session,
        embedAnswerData || {},
        thoughtSpotHost,
        contextMenuPoints?.selectedPoints,
    );
    return {
        ...e,
        answerService,
    };
}

/**
 * Responds to AuthInit sent from host signifying successful authentication in host.
 * @param e
 * @returns {any}
 */
function processAuthInit(e: any) {
    notifyAuthSuccess();

    // Expose only allowed details (eg: userGUID) back to SDK users.
    return {
        ...e,
        data: {
            userGUID: e.data?.userGUID || e.payload?.userGUID,
        },
    };
}

/**
 *
 * @param e
 * @param containerEl
 */
function processNoCookieAccess(e: any, containerEl: Element) {
    const {
        loginFailedMessage,
        suppressNoCookieAccessAlert,
        ignoreNoCookieAccess,
        suppressErrorAlerts,
    } = getEmbedConfig();
    if (!ignoreNoCookieAccess) {
        if (!suppressNoCookieAccessAlert && !suppressErrorAlerts) {
            // eslint-disable-next-line no-alert
            alert(ERROR_MESSAGE.THIRD_PARTY_COOKIE_BLOCKED_ALERT);
        }
        // eslint-disable-next-line no-param-reassign
        containerEl.innerHTML = loginFailedMessage;
    }
    notifyAuthFailure(AuthFailureType.NO_COOKIE_ACCESS);
    return e;
}

/**
 *
 * @param e
 * @param containerEl
 */
export function processAuthFailure(e: any, containerEl: Element) {
    const {
        loginFailedMessage, authType, disableLoginFailurePage, autoLogin,
    } = getEmbedConfig();
    
    const isEmbeddedSSO = authType === AuthType.EmbeddedSSO;
    const isTrustedAuth = authType === AuthType.TrustedAuthToken || authType === AuthType.TrustedAuthTokenCookieless;
    const isEmbeddedSSOInfoFailure = isEmbeddedSSO && e?.data?.type === AuthFailureType.UNAUTHENTICATED_FAILURE;
    if (autoLogin && isTrustedAuth) {
        // eslint-disable-next-line no-param-reassign
        containerEl.innerHTML = loginFailedMessage;
        notifyAuthFailure(AuthFailureType.IDLE_SESSION_TIMEOUT);
    } else if (authType !== AuthType.None && !disableLoginFailurePage && !isEmbeddedSSOInfoFailure) {
        // eslint-disable-next-line no-param-reassign
        containerEl.innerHTML = loginFailedMessage;
        notifyAuthFailure(AuthFailureType.OTHER);
    }
    resetCachedAuthToken();
    return e;
}

/**
 *
 * @param e
 * @param containerEl
 */
function processAuthLogout(e: any, containerEl: Element) {
    const { loginFailedMessage } = getEmbedConfig();
    // eslint-disable-next-line no-param-reassign
    containerEl.innerHTML = loginFailedMessage;
    resetCachedAuthToken();
    disableAutoLogin();
    notifyLogout();
    return e;
}

/**
 *
 * @param type
 * @param e
 * @param thoughtSpotHost
 * @param containerEl
 */
export function processEventData(
    type: EmbedEvent,
    e: any,
    thoughtSpotHost: string,
    containerEl: Element,
): any {
    switch (type) {
        case EmbedEvent.CustomAction:
            return processCustomAction(e, thoughtSpotHost);
        case EmbedEvent.AuthInit:
            return processAuthInit(e);
        case EmbedEvent.NoCookieAccess:
            return processNoCookieAccess(e, containerEl);
        case EmbedEvent.AuthFailure:
            return processAuthFailure(e, containerEl);
        case EmbedEvent.AuthLogout:
            return processAuthLogout(e, containerEl);
        case EmbedEvent.ExitPresentMode:
            return processExitPresentMode(e);
        default:
    }
    return e;
}

1	import { getEmbedConfig } from '../embed/embedConfig';	15✔
2	import {	15✔
3	disableAutoLogin,
4	notifyAuthFailure,
5	notifyAuthSuccess,
6	notifyLogout,
7	} from '../embed/base';
8	import { AuthFailureType } from '../auth';	15✔
9	import { AuthType, CustomActionPayload, EmbedEvent } from '../types';	15✔
10	import { AnswerService } from './graphql/answerService/answerService';	15✔
11	import { resetCachedAuthToken } from '../authToken';	15✔
12	import { ERROR_MESSAGE } from '../errors';	15✔
13	import { logger } from '../utils/logger';	15✔
14
15	/**
16	* Default handler for exitPresentMode event - exits fullscreen
17	*/
18	function handleExitPresentMode(): void {
19	const isInFullscreen = !!(	3✔
20	document.fullscreenElement \|\|	6✔
21	(document as any).webkitFullscreenElement \|\|
22	(document as any).mozFullScreenElement \|\|
23	(document as any).msFullscreenElement
24	);
25
26	if (!isInFullscreen) {	3✔
27	// Document is not in fullscreen, nothing to do
28	return;	1✔
29	}
30
31	// Trying to exit fullscreen with vendor prefixes
32	const exitFullscreenMethods = [	2✔
33	'exitFullscreen',
34	'webkitExitFullscreen',
35	'mozCancelFullScreen',
36	'msExitFullscreen'
37	];
38
39	let fullscreenExited = false;	2✔
40
41	for (const method of exitFullscreenMethods) {	2✔
42	if (typeof (document as any)[method] === 'function') {	5✔
43	try {	1✔
44	const result = (document as any)[method]();	1✔
45	// Handle promise-based methods
46	if (result && typeof result.catch === 'function') {	1✔
47	result.catch((error: any) => {	1✔
NEW 48	logger.warn(`Failed to exit fullscreen using ${method}:`, error);	×
49	});
50	}
51	fullscreenExited = true;	1✔
52	break;	1✔
53	} catch (error) {
NEW 54	logger.warn(`Failed to exit fullscreen using ${method}:`, error);	×
55	}
56	}
57	}
58
59	if (!fullscreenExited) {	2✔
60	logger.warn('Exit fullscreen API is not supported by this browser.');	1✔
61	}
62	}
63
64	/**
65	* Process the ExitPresentMode event and handle default fullscreen exit
66	* @param e - The event data
67	*/
68	function processExitPresentMode(e: any) {
69	handleExitPresentMode();	3✔
70	return e;	3✔
71	}
72
73	/**
74	*
75	* @param e
76	* @param thoughtSpotHost
77	*/
78	export function processCustomAction(e: any, thoughtSpotHost: string) {	15✔
79	const { session, embedAnswerData, contextMenuPoints } = e.data as CustomActionPayload;	6✔
80	const answerService = new AnswerService(	6✔
81	session,
82	embedAnswerData \|\| {},	12✔
83	thoughtSpotHost,
84	contextMenuPoints?.selectedPoints,	18✔
85	);
86	return {	6✔
87	...e,
88	answerService,
89	};
90	}
91
92	/**
93	* Responds to AuthInit sent from host signifying successful authentication in host.
94	* @param e
95	* @returns {any}
96	*/
97	function processAuthInit(e: any) {
98	notifyAuthSuccess();	2✔
99
100	// Expose only allowed details (eg: userGUID) back to SDK users.
101	return {	2✔
102	...e,
103	data: {
104	userGUID: e.data?.userGUID \|\| e.payload?.userGUID,	8!
105	},
106	};
107	}
108
109	/**
110	*
111	* @param e
112	* @param containerEl
113	*/
114	function processNoCookieAccess(e: any, containerEl: Element) {
115	const {
116	loginFailedMessage,
117	suppressNoCookieAccessAlert,
118	ignoreNoCookieAccess,
119	suppressErrorAlerts,
120	} = getEmbedConfig();	6✔
121	if (!ignoreNoCookieAccess) {	6✔
122	if (!suppressNoCookieAccessAlert && !suppressErrorAlerts) {	3✔
123	// eslint-disable-next-line no-alert
124	alert(ERROR_MESSAGE.THIRD_PARTY_COOKIE_BLOCKED_ALERT);	2✔
125	}
126	// eslint-disable-next-line no-param-reassign
127	containerEl.innerHTML = loginFailedMessage;	3✔
128	}
129	notifyAuthFailure(AuthFailureType.NO_COOKIE_ACCESS);	6✔
130	return e;	6✔
131	}
132
133	/**
134	*
135	* @param e
136	* @param containerEl
137	*/
138	export function processAuthFailure(e: any, containerEl: Element) {	15✔
139	const {
140	loginFailedMessage, authType, disableLoginFailurePage, autoLogin,
141	} = getEmbedConfig();	10✔
142
143	const isEmbeddedSSO = authType === AuthType.EmbeddedSSO;	10✔
144	const isTrustedAuth = authType === AuthType.TrustedAuthToken \|\| authType === AuthType.TrustedAuthTokenCookieless;	10✔
145	const isEmbeddedSSOInfoFailure = isEmbeddedSSO && e?.data?.type === AuthFailureType.UNAUTHENTICATED_FAILURE;	10!
146	if (autoLogin && isTrustedAuth) {	10✔
147	// eslint-disable-next-line no-param-reassign
148	containerEl.innerHTML = loginFailedMessage;	3✔
149	notifyAuthFailure(AuthFailureType.IDLE_SESSION_TIMEOUT);	3✔
150	} else if (authType !== AuthType.None && !disableLoginFailurePage && !isEmbeddedSSOInfoFailure) {	7✔
151	// eslint-disable-next-line no-param-reassign
152	containerEl.innerHTML = loginFailedMessage;	5✔
153	notifyAuthFailure(AuthFailureType.OTHER);	5✔
154	}
155	resetCachedAuthToken();	10✔
156	return e;	10✔
157	}
158
159	/**
160	*
161	* @param e
162	* @param containerEl
163	*/
164	function processAuthLogout(e: any, containerEl: Element) {
165	const { loginFailedMessage } = getEmbedConfig();	1✔
166	// eslint-disable-next-line no-param-reassign
167	containerEl.innerHTML = loginFailedMessage;	1✔
168	resetCachedAuthToken();	1✔
169	disableAutoLogin();	1✔
170	notifyLogout();	1✔
171	return e;	1✔
172	}
173
174	/**
175	*
176	* @param type
177	* @param e
178	* @param thoughtSpotHost
179	* @param containerEl
180	*/
181	export function processEventData(	15✔
182	type: EmbedEvent,
183	e: any,
184	thoughtSpotHost: string,
185	containerEl: Element,
186	): any {
187	switch (type) {	71✔
188	case EmbedEvent.CustomAction:
189	return processCustomAction(e, thoughtSpotHost);	6✔
190	case EmbedEvent.AuthInit:
191	return processAuthInit(e);	2✔
192	case EmbedEvent.NoCookieAccess:
193	return processNoCookieAccess(e, containerEl);	6✔
194	case EmbedEvent.AuthFailure:
195	return processAuthFailure(e, containerEl);	5✔
196	case EmbedEvent.AuthLogout:
197	return processAuthLogout(e, containerEl);	1✔
198	case EmbedEvent.ExitPresentMode:
199	return processExitPresentMode(e);	3✔
200	default:
201	}
202	return e;	48✔
203	}

thoughtspot / visual-embed-sdk / #1932

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous