@24i/bigscreen-sdk 1.0.4 → 1.0.5-4.alpha-2832

package/packages/analytics/src/clients/GoogleAnalytics/constants.ts

@@ -0,0 +1,126 @@
+import { AnalyticsTriggers } from '@24i/appstage-shared-analytics';
+import { GAEventsNames } from './interface';
+
+const stringParameter = 'ep';
+const numericParameter = 'epn';
+
+export const GOOGLE_ANALYTICS_TRIGGERS = [
+    AnalyticsTriggers.SCENE_VIEW,
+    AnalyticsTriggers.APP_CLOSE,
+    // player triggers
+    AnalyticsTriggers.PLAYBACK_10,
+    AnalyticsTriggers.PLAYBACK_25,
+    AnalyticsTriggers.PLAYBACK_50,
+    AnalyticsTriggers.PLAYBACK_75,
+    AnalyticsTriggers.PLAYBACK_90,
+    AnalyticsTriggers.PLAYBACK_PAUSE,
+    AnalyticsTriggers.PLAYBACK_START,
+    AnalyticsTriggers.PLAYBACK_STOP,
+    AnalyticsTriggers.PLAYER_CLOSE,
+    AnalyticsTriggers.PLAYER_OPEN,
+    AnalyticsTriggers.HEARTBEAT_5,
+    // scroll triggers
+    AnalyticsTriggers.SCROLL_25,
+    AnalyticsTriggers.SCROLL_50,
+    AnalyticsTriggers.SCROLL_75,
+    AnalyticsTriggers.SCROLL_90,
+    // additional triggers
+    AnalyticsTriggers.APP_ERROR,
+    AnalyticsTriggers.FAVORITE_ADD,
+    AnalyticsTriggers.FAVORITE_REMOVE,
+    AnalyticsTriggers.SEARCH,
+    AnalyticsTriggers.RATE_CONTENT,
+    // ads triggers
+    AnalyticsTriggers.AD_BUFFERING,
+    AnalyticsTriggers.AD_COMPLETE,
+    AnalyticsTriggers.AD_ERROR,
+    AnalyticsTriggers.AD_SKIPPED,
+    AnalyticsTriggers.AD_START,
+    AnalyticsTriggers.AD_STOP,
+    // user triggers
+    AnalyticsTriggers.LOGIN,
+    AnalyticsTriggers.LOGOUT,
+    AnalyticsTriggers.SIGN_UP,
+    // purchases
+    AnalyticsTriggers.PURCHASE_CANCEL,
+    AnalyticsTriggers.PURCHASE_COMPLETE,
+    AnalyticsTriggers.PURCHASE_START,
+
+] as const;
+
+export const TRIGGER_NAME_TO_GA_EVENTS: Record<
+    typeof GOOGLE_ANALYTICS_TRIGGERS[number], GAEventsNames[]
+> = {
+    // App
+    [AnalyticsTriggers.APP_CLOSE]: ['close_player_session', 'video_progress'],
+
+    // Playback
+    [AnalyticsTriggers.HEARTBEAT_5]: ['video_progress'],
+    [AnalyticsTriggers.PLAYBACK_10]: ['video_progress'],
+    [AnalyticsTriggers.PLAYBACK_25]: ['video_progress'],
+    [AnalyticsTriggers.PLAYBACK_50]: ['video_progress'],
+    [AnalyticsTriggers.PLAYBACK_75]: ['video_progress'],
+    [AnalyticsTriggers.PLAYBACK_90]: ['video_complete'],
+    [AnalyticsTriggers.PLAYBACK_PAUSE]: ['video_progress'],
+    [AnalyticsTriggers.PLAYBACK_START]: ['video_start'],
+    [AnalyticsTriggers.PLAYBACK_STOP]: ['video_progress'],
+
+    // Player
+    [AnalyticsTriggers.PLAYER_CLOSE]: ['close_player_session', 'video_progress'],
+    [AnalyticsTriggers.PLAYER_OPEN]: ['open_player_session'],
+
+    // Scenes
+    [AnalyticsTriggers.SCENE_VIEW]: ['page_view'],
+
+    // Scrolling in scene
+    [AnalyticsTriggers.SCROLL_25]: ['scroll'],
+    [AnalyticsTriggers.SCROLL_50]: ['scroll'],
+    [AnalyticsTriggers.SCROLL_75]: ['scroll'],
+    [AnalyticsTriggers.SCROLL_90]: ['scroll'],
+
+    // purchases
+    [AnalyticsTriggers.PURCHASE_CANCEL]: [],
+    [AnalyticsTriggers.PURCHASE_COMPLETE]: [],
+    [AnalyticsTriggers.PURCHASE_START]: [],
+
+    // additional triggers
+    [AnalyticsTriggers.APP_ERROR]: ['app_exception'],
+    [AnalyticsTriggers.FAVORITE_ADD]: ['favorite_add'],
+    [AnalyticsTriggers.FAVORITE_REMOVE]: ['favorite_remove'],
+    [AnalyticsTriggers.SEARCH]: ['search'],
+    [AnalyticsTriggers.RATE_CONTENT]: ['rate_content'],
+
+    // ads triggers
+    [AnalyticsTriggers.AD_BUFFERING]: ['ad_buffering'],
+    [AnalyticsTriggers.AD_COMPLETE]: ['ad_complete'],
+    [AnalyticsTriggers.AD_ERROR]: ['ad_error'],
+    [AnalyticsTriggers.AD_SKIPPED]: ['ad_skipped'],
+    [AnalyticsTriggers.AD_START]: ['ad_start'],
+    [AnalyticsTriggers.AD_STOP]: ['ad_stop'],
+
+    // user triggers
+    [AnalyticsTriggers.LOGIN]: ['login'],
+    [AnalyticsTriggers.LOGOUT]: ['logout'],
+    [AnalyticsTriggers.SIGN_UP]: ['sign_up'],
+};
+
+export const gtagPayloadParams: Record<string, string> = {
+    contentType: `${stringParameter}.content_type`,
+    itemId: `${stringParameter}.video_asset_id`,
+    episodeNumber: `${numericParameter}.video_episode_number`,
+    seasonNumber: `${numericParameter}.video_season_number`,
+    currentTime: `${numericParameter}.video_current_time`,
+    duration: `${numericParameter}.video_duration`,
+    percent: `${numericParameter}.video_percent`,
+    provider: `${stringParameter}.video_provider`,
+    title: `${stringParameter}.video_title`,
+    seriesTitle: `${stringParameter}.video_series_title`,
+    url: `${stringParameter}.video_url`,
+    assetId: `${stringParameter}.video_asset_id`,
+    externalId: `${stringParameter}.video_external_id`,
+    channelNumber: `${numericParameter}.channel_number`,
+    channelTitle: `${stringParameter}.channel_title`,
+    method: `${stringParameter}.method`,
+    searchTerm: `${stringParameter}.search_term`,
+    message: `${stringParameter}.message`,
+};

package/packages/analytics/src/clients/GoogleAnalytics/getUrl.ts

@@ -0,0 +1,17 @@
+import { ConstantUrlParams, EventUrlParams } from './interface';
+
+const TRANSPORT_URL = 'https://www.google-analytics.com/g/collect?';
+// You can use the following URL for debugging if the events are not getting collected.
+// const TRANSPORT_URL = 'https://www.google-analytics.com/debug/g/collec?';
+
+export const getUrl = (id: string, params: ConstantUrlParams & EventUrlParams) => {
+    const urlParts = [
+        TRANSPORT_URL,
+        `v=2&tid=${id}`,
+    ];
+    (Object.keys(params) as (keyof (ConstantUrlParams & EventUrlParams))[])
+        .forEach((paramName: keyof (ConstantUrlParams & EventUrlParams)) => {
+            urlParts.push(`&${paramName}=${encodeURIComponent(params[paramName])}`);
+        });
+    return urlParts.join('');
+};

package/packages/analytics/src/clients/GoogleAnalytics/index.ts

@@ -0,0 +1,2 @@
+export { GoogleAnalytics } from './GoogleAnalytics';
+export { GOOGLE_ANALYTICS_TRIGGERS } from './constants';

package/packages/analytics/src/clients/GoogleAnalytics/interface.ts

@@ -0,0 +1,82 @@
+export type GAEventsNames = (
+    | 'app_close' // When the playback is active at the time the app or website is closing.
+    | 'page_view' // Each time the page loads or the browser history state is changed
+    | 'scroll' // The first time a user reaches the bottom of each page
+    | 'video_progress' // When the video progresses past 10%, 25%, 50%, and 75% duration time
+    | 'video_start' // When the video starts playing
+    | 'video_complete' // When the video ends
+    | 'open_player_session' // When the user opens a player scene and the player is initiated
+    | 'close_player_session' // When the user exits the player scene with initiated player
+    | 'select_content' // When a user has selected content
+    | 'login' // When a user logs in
+    | 'logout' // When a user logs in
+    | 'sign_up' // When a user has signed up Allows you to see which methods of signup are popular
+    | 'search' // When a user searches your content
+    | 'purchase' // When a user completes a purchase
+    | 'share' // When a user has shared content
+    | 'favorite_add' // When a user add asset to favorites
+    | 'favorite_remove' // When a user remove asset froms favorites
+    | 'user_engagement' // Periodically, while the app is in the foreground
+    | 'ad_buffering' // When advertisement is buffering
+    | 'ad_complete' // When advertisement has been completed
+    | 'ad_error' // When advertisement has an error
+    | 'ad_skipped' // When user skipped current advertisement
+    | 'ad_start' // When advertisement has been started
+    | 'ad_stop' // When advertisement has been stopped
+    | 'app_exception' // When application throws an error
+    | 'rate_content' // When user rates an asset
+);
+
+export type QueuedEvent = {
+    name: string,
+    params: Record<string, any>,
+    urlParams: EventUrlParams,
+};
+
+export type SessionInfo = {
+    appVersion: string,
+    manufacturer: string,
+    platform: string,
+    language: string,
+    resolution: string,
+    referrer: string,
+    engagementTime: number | undefined,
+    sessionStarted: boolean,
+    isAuthenticated: '0' | '1',
+    firstEvent: boolean,
+    firstVisit: boolean,
+};
+
+export type ConstantUrlParams = {
+    /** Client ID (UUIv4 string) */
+    cid: string,
+    /** Session ID (random number) */
+    sid: number,
+    /** Session engagement 0 for first event of session, 1 otherwise */
+    seg: number,
+    /** Session count */
+    sct: number,
+    /** Random page hash */
+    _p: string,
+    /** Device manufacturer e.g. 'Samsung' */
+    'up.device_manufacturer': string,
+    /** Platform e.g. 'Tizen' */
+    'up.device_platform': string,
+    /** Platform version e.g. '5.0' */
+    'up.device_platform_version': string,
+    /** Version of application 'v1.0.0' */
+    'up.app_version': string,
+};
+
+export type EventUrlParams = {
+    /** Language iso639-1 */
+    ul: string,
+    /** Device resolution as WIDTHxHEIGHT */
+    sr: string,
+    /** Page hash route */
+    dl: string,
+    /** Page title */
+    dt: string,
+    /** Page referrer hash route */
+    dr: string,
+};

package/packages/analytics/src/clients/GoogleAnalytics/mapPayload.ts

@@ -0,0 +1,51 @@
+import type { AnalyticsEventsNames, AnyPayload } from '../../interface';
+import type { EventUrlParams, GAEventsNames } from './interface';
+import { gtagPayloadParams } from './constants';
+
+const map: Record<string, string> = {
+    language: 'ul',
+    resolution: 'sr',
+    referrer: 'dr',
+    sceneId: 'dl',
+    sceneName: 'dt',
+    isAuthenticated: 'up.is_authenticated',
+};
+
+export const mapEventParamsToUrlParams = (eventParams: Record<string, any>)
+: EventUrlParams => {
+    const urlParams = {};
+    Object.entries(eventParams).forEach(([key]) => {
+        if (map[key]) {
+            Object.assign(urlParams, {
+                [map[key]]: eventParams[key] || '',
+            });
+        }
+    });
+    return urlParams as EventUrlParams;
+};
+
+export const mapPayload = (
+    eventName: GAEventsNames,
+    triggerName: AnalyticsEventsNames,
+    payload: AnyPayload,
+) => {
+    const pageParams = triggerName === 'scene_view' ? {
+        ...(payload.firstEvent && { _ee: 1 }),
+        ...(payload.firstVisit && { _fv: 1 }),
+        ...(payload.sessionStarted && { _ss: 1 }),
+    } : {};
+    const gtagPayload: Record<string, any> = {
+        'ep.event_trigger': triggerName,
+        _et: payload.engagementTime ?? 0,
+        ...pageParams,
+    };
+    if (eventName === 'scroll') {
+        gtagPayload['epn.percent_scrolled'] = parseInt(triggerName.split('_')[1], 10);
+    }
+    Object.keys(payload).forEach((key: keyof typeof payload) => {
+        if (gtagPayloadParams[key] !== undefined) {
+            gtagPayload[gtagPayloadParams[key]] = payload[key];
+        }
+    });
+    return gtagPayload;
+};

package/packages/analytics/src/clients/GoogleAnalytics/prepareBody.ts

@@ -0,0 +1,14 @@
+import { QueuedEvent } from './interface';
+
+export const prepareBody = (events: QueuedEvent[]) => {
+    const eventLines = events.map((event: QueuedEvent) => {
+        const eventParams = [
+            `en=${event.name}`,
+        ];
+        Object.keys(event.params).forEach((paramName) => {
+            eventParams.push(`${paramName}=${encodeURIComponent(event.params[paramName])}`);
+        });
+        return eventParams.join('&');
+    });
+    return eventLines.join('\r\n');
+};

package/packages/analytics/src/clients/TealiumAnalytics/TealiumAnalytics.ts

@@ -0,0 +1,181 @@
+import { Storage } from '@24i/bigscreen-sdk/storage';
+import { MINUTE_IN_MS } from '@24i/bigscreen-sdk/utils/timeConstants';
+import { createTimeout } from '@24i/bigscreen-sdk/utils/timers';
+import { AnalyticsTriggers } from '@24i/appstage-shared-analytics';
+import { findForLanguage } from './findForLanguage';
+import {
+    BIGSCREEN_APP_TYPE,
+    BIGSCREEN_OTT_TYPE,
+    BIGSCREEN_PLATFORM_SHORT,
+    BIGSCREEN_PLATFORM_TYPE,
+    TRIGGER_NAME_TO_TEALIUM_EVENTS,
+} from './constants';
+import { EVENTS_MAPPING } from './interface';
+import type { AnalyticsClient, AnyPayload } from '../../interface';
+import type {
+    TeaStaticCoreResult,
+    Payload,
+    TealiumAnalyticsConfiguration,
+    TeaResult,
+    TealiumDataMapper,
+    CustomMappers,
+    TeaDynamicCoreResult,
+} from './types';
+
+// eslint-disable-next-line no-magic-numbers
+const SESSION_TIMEOUT = 30 * MINUTE_IN_MS;
+const TEALIUM_SESSION_COUNTER = 'tealium_session_counter';
+const TEALIUM_BASE_URL = 'https://collect.tealiumiq.com/event';
+
+const DEFAULT_PAYLOAD: TeaStaticCoreResult = {
+    tealium_account: '',
+    tealium_profile: '',
+    entity: '',
+    platform_short: BIGSCREEN_PLATFORM_SHORT,
+    platform_type: BIGSCREEN_PLATFORM_TYPE,
+    app_type: BIGSCREEN_APP_TYPE,
+    ott_type: BIGSCREEN_OTT_TYPE,
+    app_id: '',
+} as const;
+
+export class TealiumAnalytics implements AnalyticsClient {
+    name = 'TealiumAnalytics';
+
+    constantPayload: TeaStaticCoreResult = DEFAULT_PAYLOAD;
+
+    sessionTimeout = createTimeout();
+
+    isSessionActive = false;
+
+    sessionStartSent = false;
+
+    baseUrl: string = '';
+
+    customMappers: CustomMappers | undefined = undefined;
+
+    constructor(private config: TealiumAnalyticsConfiguration, private appVersion: string = '') {
+        this.init();
+    }
+
+    async init() {
+        this.baseUrl = this.config.baseURL || TEALIUM_BASE_URL;
+        this.prepareDatasetPayload();
+    }
+
+    prepareDatasetPayload() {
+        if (!this.config) {
+            console.warn(`[${this.name}] prepareDatasetPayload missing configuration`);
+            return;
+        }
+        const {
+            account,
+            profile,
+            environment,
+            datasource,
+            customMappers,
+            dataMapper = {} as TealiumDataMapper,
+        } = this.config;
+        const { entity, platformShort, platformType, appType } = dataMapper;
+        this.customMappers = customMappers;
+        this.constantPayload = {
+            tealium_account: account,
+            tealium_profile: profile,
+            tealium_environment: environment,
+            entity,
+            ...(datasource && { tealium_datasource: datasource }),
+            platform_short: platformShort ?? BIGSCREEN_PLATFORM_SHORT,
+            platform_type: platformType ?? BIGSCREEN_PLATFORM_TYPE,
+            app_type: appType ?? BIGSCREEN_APP_TYPE,
+            ott_type: BIGSCREEN_OTT_TYPE,
+            app_id: `${entity} ${appType ?? BIGSCREEN_APP_TYPE} : ${this.appVersion}`,
+        };
+    }
+
+    getDynamicPayload({ language: payloadLanguage }: AnyPayload): TeaDynamicCoreResult {
+        if (!this.config || !this.config.dataMapper) {
+            console.warn(`[${this.name}] getDynamicPayload missing configuration`);
+            return {
+                language: '', language_service: '', property_id: '', short_language_service: '',
+            };
+        }
+        const { dataMapper } = this.config;
+        const { entity, languageMap, propertyIdsMap, shortLanguageServiceMap } = dataMapper;
+        const tealiumLanguage = findForLanguage(languageMap, payloadLanguage) || '';
+        return {
+            language: tealiumLanguage || '',
+            language_service: `${entity} ${tealiumLanguage}`,
+            property_id: findForLanguage(propertyIdsMap, payloadLanguage) || '',
+            short_language_service: findForLanguage(shortLanguageServiceMap, payloadLanguage) || '',
+        };
+    }
+
+    async startSession() {
+        const sessionNumber = parseInt(
+            await Storage.getItem(TEALIUM_SESSION_COUNTER) ?? '0', 10,
+        ) + 1;
+        await Storage.setItem(TEALIUM_SESSION_COUNTER, sessionNumber.toString());
+        this.isSessionActive = true;
+        this.setSessionTimeout();
+    }
+
+    setSessionTimeout() {
+        this.sessionTimeout.set(() => {
+            this.isSessionActive = false;
+            this.sessionStartSent = false;
+        }, SESSION_TIMEOUT);
+    }
+
+    async sendEvent(eventBody: TeaResult) {
+        try {
+            await fetch(this.baseUrl, {
+                method: 'POST',
+                body: JSON.stringify(eventBody),
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json;charset=UTF-8',
+                },
+            });
+        } catch (error) {
+            console.warn(`[${this.name}] Error sendEvent: `, error);
+        }
+    }
+
+    async onEvent(triggerName: AnalyticsTriggers, payload: AnyPayload): Promise<void> {
+        const events = TRIGGER_NAME_TO_TEALIUM_EVENTS[triggerName];
+        if (this.isSessionActive) {
+            this.setSessionTimeout();
+        } else {
+            await this.startSession();
+        }
+        if (!events) return;
+        await Promise.all(
+            events.map(async (event) => {
+                const mappingFunction = this.customMappers && this.customMappers[event]
+                    ? this.customMappers[event]
+                    : EVENTS_MAPPING[event];
+                try {
+                    if (!mappingFunction) {
+                        throw Error(`Missing mapping function for "${event}"`);
+                    }
+                    const eventBody = {
+                        ...this.constantPayload,
+                        ...this.getDynamicPayload(payload),
+                        ...mappingFunction(triggerName, payload as Payload, this.config),
+                    };
+                    const filteredEventBody: TeaResult = Object.entries(eventBody).reduce(
+                        (acc: any, [key, value]) => {
+                            if (value != null && value !== '') {
+                                acc[key] = value;
+                            }
+                            return acc;
+                        },
+                        {} as TeaResult,
+                    );
+                    if (eventBody) await this.sendEvent(filteredEventBody);
+                } catch (e) {
+                    console.warn(`[${this.name}] Error onEvent: `, e);
+                }
+            }),
+        );
+    }
+}

package/packages/analytics/src/clients/TealiumAnalytics/constants.ts

@@ -0,0 +1,106 @@
+import { AnalyticsTriggers } from '@24i/appstage-shared-analytics';
+
+export const BIGSCREEN_OTT_TYPE = 'SmartTV';
+
+export const BIGSCREEN_APP_TYPE = 'html5';
+
+export const BIGSCREEN_PLATFORM_SHORT = 'o';
+
+export const BIGSCREEN_PLATFORM_TYPE = 'ott';
+
+export const TEALIUM_TRIGGERS = [
+    // App
+    AnalyticsTriggers.APP_OPEN,
+    AnalyticsTriggers.APP_CLOSE,
+    AnalyticsTriggers.APP_ERROR,
+
+    // Scenes
+    AnalyticsTriggers.SCENE_VIEW,
+
+    // Search
+    AnalyticsTriggers.SEARCH,
+
+    // Playback
+    AnalyticsTriggers.PLAYBACK_10,
+    AnalyticsTriggers.PLAYBACK_50,
+    AnalyticsTriggers.PLAYBACK_90,
+    AnalyticsTriggers.PLAYBACK_PAUSE,
+    AnalyticsTriggers.PLAYBACK_UNPAUSE,
+    AnalyticsTriggers.PLAYBACK_START,
+    AnalyticsTriggers.PLAYBACK_STOP,
+
+    // Player
+    AnalyticsTriggers.PLAYER_CLOSE,
+    AnalyticsTriggers.PLAYER_OPEN,
+
+    // Favorites
+    AnalyticsTriggers.FAVORITE_ADD,
+    AnalyticsTriggers.FAVORITE_REMOVE,
+
+    AnalyticsTriggers.SELECT_CONTENT,
+    AnalyticsTriggers.SEARCH_SUCCESS,
+    AnalyticsTriggers.SEARCH_FAILED,
+];
+
+export const AppEvents = {
+    [AnalyticsTriggers.APP_OPEN]: '',
+    [AnalyticsTriggers.SCENE_VIEW]: '',
+    [AnalyticsTriggers.PLAYBACK_10]: 'media_milestone_10_video',
+    [AnalyticsTriggers.PLAYBACK_50]: 'media_milestone_50_video',
+    [AnalyticsTriggers.PLAYBACK_90]: 'media_milestone_90_video',
+    [AnalyticsTriggers.PLAYBACK_STOP]: 'video_stop',
+    [AnalyticsTriggers.PLAYBACK_PAUSE]: 'video_pause',
+    [AnalyticsTriggers.PLAYBACK_UNPAUSE]: 'video_resume',
+    [AnalyticsTriggers.PLAYBACK_START]: 'video_play',
+    [AnalyticsTriggers.PLAYER_OPEN]: 'player_open',
+    [AnalyticsTriggers.PLAYER_CLOSE]: 'player_x',
+    [AnalyticsTriggers.FAVORITE_ADD]: 'subscribe_to_fav',
+    [AnalyticsTriggers.FAVORITE_REMOVE]: 'subscribe_to_fav',
+    [AnalyticsTriggers.APP_ERROR]: 'app_events',
+    [AnalyticsTriggers.SELECT_CONTENT]: 'app_events',
+    [AnalyticsTriggers.SEARCH_SUCCESS]: 'search_success',
+    [AnalyticsTriggers.SEARCH_FAILED]: 'search_fail',
+} as const;
+
+export enum EVENTS {
+    APP_OPEN = 'app_open',
+    SCENE_VIEW = 'scene_view',
+    VIDEO_PROGRESS = 'video_progress',
+    VIDEO_START = 'video_start',
+    VIDEO_STOP = 'video_stop',
+    VIDEO_PAUSE = 'video_pause',
+    VIDEO_UNPAUSE = 'video_unpause',
+    PLAYER_CLOSE = 'player_close',
+    PLAYER_OPEN = 'player_open',
+    SEARCH_SUCCESS = 'search_success',
+    SEARCH_FAILED = 'search_failed',
+    FAVORITE_ADD = 'favorite_add',
+    FAVORITE_REMOVE = 'favorite_remove',
+    APP_ERROR = 'app_error',
+}
+
+export enum TrackEventType {
+    VIEW = 'view',
+    ACTIVITY = 'activity',
+}
+
+export const TRIGGER_NAME_TO_TEALIUM_EVENTS: { [K in AnalyticsTriggers]?: EVENTS[]; } = {
+    [AnalyticsTriggers.APP_OPEN]: [EVENTS.APP_OPEN],
+    [AnalyticsTriggers.SCENE_VIEW]: [EVENTS.SCENE_VIEW],
+    [AnalyticsTriggers.PLAYBACK_10]: [EVENTS.VIDEO_PROGRESS],
+    [AnalyticsTriggers.PLAYBACK_50]: [EVENTS.VIDEO_PROGRESS],
+    [AnalyticsTriggers.PLAYBACK_90]: [EVENTS.VIDEO_PROGRESS],
+    [AnalyticsTriggers.PLAYBACK_PAUSE]: [EVENTS.VIDEO_PAUSE],
+    [AnalyticsTriggers.PLAYBACK_UNPAUSE]: [EVENTS.VIDEO_UNPAUSE],
+    [AnalyticsTriggers.PLAYBACK_START]: [EVENTS.VIDEO_START],
+    [AnalyticsTriggers.PLAYBACK_STOP]: [EVENTS.VIDEO_STOP],
+    [AnalyticsTriggers.PLAYER_CLOSE]: [EVENTS.PLAYER_CLOSE],
+    [AnalyticsTriggers.PLAYER_OPEN]: [EVENTS.PLAYER_OPEN],
+    [AnalyticsTriggers.APP_CLOSE]: [EVENTS.VIDEO_STOP, EVENTS.PLAYER_CLOSE],
+    [AnalyticsTriggers.APP_ERROR]: [EVENTS.APP_ERROR],
+    [AnalyticsTriggers.FAVORITE_ADD]: [EVENTS.FAVORITE_ADD],
+    [AnalyticsTriggers.FAVORITE_REMOVE]: [EVENTS.FAVORITE_REMOVE],
+    [AnalyticsTriggers.SEARCH]: [EVENTS.SEARCH_SUCCESS, EVENTS.SEARCH_FAILED],
+};
+
+export const HUNDRED_PERCENT = 100;

package/packages/analytics/src/clients/TealiumAnalytics/findForLanguage.ts

@@ -0,0 +1,9 @@
+import { LanguageMapper } from '@24i/bigscreen-sdk/analytics/TealiumAnalytics';
+
+export const findForLanguage = (
+    languageMapper: LanguageMapper = {},
+    language: string = '',
+) => {
+    const languageKey = Object.keys(languageMapper).find((key) => key === language);
+    return languageKey ? languageMapper[languageKey] : null;
+};

package/packages/analytics/src/clients/TealiumAnalytics/index.ts

@@ -0,0 +1,4 @@
+export { TealiumAnalytics } from './TealiumAnalytics';
+export { findForLanguage } from './findForLanguage';
+export * from './constants';
+export * from './types';

package/packages/analytics/src/clients/TealiumAnalytics/interface.ts

@@ -0,0 +1,35 @@
+import {
+    EVENTS,
+} from './constants';
+import { mapSceneView } from './mappers/mapSceneView';
+import { mapVideoProgress } from './mappers/mapVideoProgress';
+import { mapVideoStop } from './mappers/mapVideoStop';
+import { mapPlayerOpen } from './mappers/mapPlayerOpen';
+import { mapPlayerClose } from './mappers/mapPlayerClose';
+import { mapVideoStart } from './mappers/mapVideoStart';
+import { mapVideoPause } from './mappers/mapVideoPause';
+import { mapFavoriteAdd } from './mappers/mapFavoriteAdd';
+import { mapFavoriteRemove } from './mappers/mapFavoriteRemove';
+import { mapVideoResume } from './mappers/mapVideoResume';
+import { mapSearchSuccess } from './mappers/mapSearchSuccess';
+import { mapSearchFailed } from './mappers/mapSearchFailed';
+import { mapAppError } from './mappers/mapAppError';
+import { mapAppOpen } from './mappers/mapAppOpen';
+import { EventMappingFunction } from './types';
+
+export const EVENTS_MAPPING: Record<EVENTS, EventMappingFunction> = {
+    [EVENTS.APP_OPEN]: mapAppOpen,
+    [EVENTS.SCENE_VIEW]: mapSceneView,
+    [EVENTS.PLAYER_OPEN]: mapPlayerOpen,
+    [EVENTS.PLAYER_CLOSE]: mapPlayerClose,
+    [EVENTS.VIDEO_START]: mapVideoStart,
+    [EVENTS.VIDEO_STOP]: mapVideoStop,
+    [EVENTS.VIDEO_PROGRESS]: mapVideoProgress,
+    [EVENTS.VIDEO_PAUSE]: mapVideoPause,
+    [EVENTS.VIDEO_UNPAUSE]: mapVideoResume,
+    [EVENTS.FAVORITE_ADD]: mapFavoriteAdd,
+    [EVENTS.FAVORITE_REMOVE]: mapFavoriteRemove,
+    [EVENTS.SEARCH_SUCCESS]: mapSearchSuccess,
+    [EVENTS.SEARCH_FAILED]: mapSearchFailed,
+    [EVENTS.APP_ERROR]: mapAppError,
+};