@wildix/xbees-connect 1.2.0-alpha.3 → 1.2.0-alpha.7

package/dist-es/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wildix/xbees-connect",
-    "version": "1.2.0-alpha.3",
+    "version": "1.2.0-alpha.7",
     "description": "This library provides easy communication between x-bees and integrated web applications",
     "author": "dimitri.chernykh <dimitri.chernykh@wildix.com>",
     "homepage": "",
@@ -17,7 +17,10 @@
         "build:docs": "typedoc",
         "lint": "eslint . && tsc --noEmit",
         "lint:fix": "eslint . --fix",
-        "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo"
+        "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "test:coverage": "jest --coverage"
     },
     "files": [
         "dist-*/**"
@@ -30,8 +33,12 @@
         "access": "public"
     },
     "devDependencies": {
+        "@types/jest": "^29.5.12",
         "eslint": "^8.55.0",
+        "eslint-plugin-jest": "^28.5.0",
+        "jest": "^29.7.0",
         "rimraf": "^5.0.5",
+        "ts-jest": "^29.1.3",
         "typescript": "^5.3.3"
     },
     "parserOptions": {

package/dist-es/src/Client.js

@@ -4,6 +4,7 @@ import ClientParams from './helpers/ClientParams';
 import LocalStorageManager from './helpers/LocalStorageManager';
 import { MessageListener } from './helpers/MessageListener';
 import PostMessageController from './helpers/PostMessageController';
+import TechnicalSupport from './helpers/TechnicalSupport';
 /**
  * Client provides functionality of communication between xBees and integrated web applications via iFrame or ReactNative WebView
  * integration creates na instance with new Client()
@@ -128,16 +129,17 @@ export class Client {
         return this.sendAsync({ type: ClientEventType.AUTHORIZED });
     }
     addEventListener(eventName, callback) {
-        return this.messageListener.addEventListener(eventName, callback);
+        return MessageListener.getInstance().listen(eventName, callback);
     }
     removeEventListener(eventName, callback) {
-        this.messageListener.removeEventListener(eventName, callback);
+        MessageListener.getInstance().off(eventName, callback);
     }
     off(callback) {
         this.localStorageManager.removeOnStorage(callback);
         this.removeEventListener(null, callback);
     }
     onRedirectQuery(callback) {
+        console.debug('onRedirectQuery', 'listen');
         return this.addEventListener(EventType.REDIRECT_QUERY, callback);
     }
     onCallEnded(callback) {
@@ -238,4 +240,7 @@ export class Client {
     setIntegrationStorageKey(integrationKey) {
         this.localStorageManager.setIntegrationKey(integrationKey);
     }
+    getTechnicalSupport() {
+        return TechnicalSupport.getInstance();
+    }
 }

package/dist-es/src/__tests__/Client.test.js

@@ -0,0 +1,259 @@
+import { Client } from '../Client';
+import { ClientEventType, EventType } from '../enums';
+import ClientParams from '../helpers/ClientParams';
+import LocalStorageManager from '../helpers/LocalStorageManager';
+import { MessageListener } from '../helpers/MessageListener';
+import PostMessageController from '../helpers/PostMessageController';
+import TechnicalSupport from '../helpers/TechnicalSupport';
+jest.mock('../../package.json', () => ({ version: '1.0.0' }));
+jest.mock('../helpers/ClientParams');
+jest.mock('../helpers/LocalStorageManager');
+jest.mock('../helpers/MessageListener');
+jest.mock('../helpers/PostMessageController');
+jest.mock('../helpers/TechnicalSupport');
+describe('Client', () => {
+    let clientInstance;
+    let originalWindow;
+    beforeAll(() => {
+        originalWindow = { ...globalThis.window };
+    });
+    beforeEach(() => {
+        Client.instance = null;
+        clientInstance = Client.getInstance();
+        jest.clearAllMocks();
+        globalThis.window = {
+            ...originalWindow,
+            addEventListener: jest.fn(),
+            removeEventListener: jest.fn(),
+            location: { host: 'http://example.com' },
+        };
+    });
+    afterAll(() => {
+        globalThis.window = originalWindow;
+    });
+    it('should return a singleton instance', () => {
+        const instance1 = Client.getInstance();
+        const instance2 = Client.getInstance();
+        expect(instance1).toBe(instance2);
+    });
+    it('should initialize correctly based on showsUi()', async () => {
+        const renderer = jest.fn().mockResolvedValue(undefined);
+        jest.spyOn(clientInstance, 'showsUi').mockReturnValue(true);
+        Client.initialize(renderer);
+        await Promise.resolve();
+        expect(renderer).toHaveBeenCalled();
+    });
+    it('should initialize and call ready when showsUi() is false', async () => {
+        const renderer = jest.fn().mockResolvedValue(undefined);
+        jest.spyOn(clientInstance, 'showsUi').mockReturnValue(false);
+        const readySpy = jest.spyOn(clientInstance, 'ready').mockResolvedValue({});
+        Client.initialize(renderer);
+        await Promise.resolve();
+        expect(renderer).not.toHaveBeenCalled();
+        expect(readySpy).toHaveBeenCalled();
+    });
+    it('should send a READY message with the correct payload', async () => {
+        const sendAsyncSpy = jest
+            .spyOn(PostMessageController.getInstance(), 'sendAsync')
+            .mockResolvedValue({});
+        await clientInstance.ready('web');
+        expect(sendAsyncSpy).toHaveBeenCalledWith({
+            type: ClientEventType.READY,
+            payload: { version: '1.0.0', platform: 'web' },
+        });
+    });
+    it('should return the correct version', () => {
+        expect(clientInstance.version()).toBe('1.0.0');
+    });
+    it('should return isPlatformNative from PostMessageController', () => {
+        const isPlatformNativeSpy = jest
+            .spyOn(PostMessageController.getInstance(), 'isPlatformNative')
+            .mockReturnValue(true);
+        expect(clientInstance.isPlatformNative()).toBe(true);
+        expect(isPlatformNativeSpy).toHaveBeenCalled();
+    });
+    it('should return isPlatformWeb from PostMessageController', () => {
+        const isPlatformWebSpy = jest.spyOn(PostMessageController.getInstance(), 'isPlatformWeb').mockReturnValue(true);
+        expect(clientInstance.isPlatformWeb()).toBe(true);
+        expect(isPlatformWebSpy).toHaveBeenCalled();
+    });
+    it('should return isOpenedFromXBees from PostMessageController', () => {
+        const isOpenedFromXBeesSpy = jest
+            .spyOn(PostMessageController.getInstance(), 'isOpenedFromXBees')
+            .mockReturnValue(true);
+        expect(clientInstance.isOpenedFromXBees()).toBe(true);
+        expect(isOpenedFromXBeesSpy).toHaveBeenCalled();
+    });
+    it('should get user PBX token from ClientParams', () => {
+        const userToken = 'token';
+        jest.spyOn(ClientParams.getInstance(), 'userToken', 'get').mockReturnValue(userToken);
+        expect(clientInstance.getUserPbxToken()).toBe(userToken);
+    });
+    it('should get user email from ClientParams', () => {
+        const userEmail = 'email@example.com';
+        jest.spyOn(ClientParams.getInstance(), 'userEmail', 'get').mockReturnValue(userEmail);
+        expect(clientInstance.getUserEmail()).toBe(userEmail);
+    });
+    it('should get referrer from ClientParams', () => {
+        const referrer = 'http://example.com';
+        jest.spyOn(ClientParams.getInstance(), 'referrer', 'get').mockReturnValue(referrer);
+        expect(clientInstance.getReferrer()).toBe(referrer);
+    });
+    it('should return correct back to app URL for native platform', () => {
+        jest.spyOn(ClientParams.getInstance(), 'iframeId', 'get').mockReturnValue('1234');
+        jest.spyOn(clientInstance, 'isPlatformNative').mockReturnValue(true);
+        expect(clientInstance.getBackToAppUrl()).toBe('com.wildix.rnc://integrations/1234');
+    });
+    it('should return correct back to app URL for web platform', () => {
+        jest.spyOn(ClientParams.getInstance(), 'iframeId', 'get').mockReturnValue('1234');
+        jest.spyOn(ClientParams.getInstance(), 'referrer', 'get').mockReturnValue('http://example.com');
+        jest.spyOn(clientInstance, 'isPlatformNative').mockReturnValue(false);
+        expect(clientInstance.getBackToAppUrl()).toBe('http://example.com/integrations/1234');
+    });
+    it('should return isDataOnly correctly', () => {
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('no-ui');
+        expect(clientInstance.isDataOnly()).toBe(true);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('daemon');
+        expect(clientInstance.isDataOnly()).toBe(true);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('d');
+        expect(clientInstance.isDataOnly()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('dialog');
+        expect(clientInstance.isDataOnly()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('ui');
+        expect(clientInstance.isDataOnly()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('info-frame');
+        expect(clientInstance.isDataOnly()).toBe(false);
+    });
+    it('should return isSetupDialog correctly', () => {
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('d');
+        expect(clientInstance.isSetupDialog()).toBe(true);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('dialog');
+        expect(clientInstance.isSetupDialog()).toBe(true);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('no-ui');
+        expect(clientInstance.isSetupDialog()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('daemon');
+        expect(clientInstance.isSetupDialog()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('ui');
+        expect(clientInstance.isDataOnly()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('info-frame');
+        expect(clientInstance.isDataOnly()).toBe(false);
+    });
+    it('should return showsUi correctly', () => {
+        jest.spyOn(clientInstance, 'isDataOnly').mockReturnValue(false);
+        expect(clientInstance.showsUi()).toBe(true);
+        jest.spyOn(clientInstance, 'isDataOnly').mockReturnValue(true);
+        expect(clientInstance.showsUi()).toBe(false);
+    });
+    it('should return isActivationOnly correctly', () => {
+        jest.spyOn(ClientParams.getInstance(), 'needAuthorize', 'get').mockReturnValue(true);
+        expect(clientInstance.isActivationOnly()).toBe(true);
+        jest.spyOn(ClientParams.getInstance(), 'needAuthorize', 'get').mockReturnValue(false);
+        expect(clientInstance.isActivationOnly()).toBe(false);
+    });
+    it('should add event listener through MessageListener', () => {
+        const eventName = EventType.PBX_TOKEN;
+        const callback = jest.fn();
+        clientInstance.addEventListener(eventName, callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(eventName, callback);
+    });
+    it('should remove event listener through MessageListener', () => {
+        const eventName = EventType.PBX_TOKEN;
+        const callback = jest.fn();
+        clientInstance.removeEventListener(eventName, callback);
+        expect(MessageListener.getInstance().off).toHaveBeenCalledWith(eventName, callback);
+    });
+    it('should handle onRedirectQuery correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onRedirectQuery(callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.REDIRECT_QUERY, callback);
+    });
+    it('should handle onCallEnded correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onCallEnded(callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.TERMINATE_CALL, callback);
+    });
+    it('should handle onCallStarted correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onCallStarted(callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.ADD_CALL, callback);
+    });
+    it('should handle onPbxTokenChange correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onPbxTokenChange(callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.PBX_TOKEN, callback);
+    });
+    it('should handle getXBeesToken correctly', async () => {
+        const sendAsyncSpy = jest
+            .spyOn(PostMessageController.getInstance(), 'sendAsync')
+            .mockResolvedValue({});
+        await clientInstance.getXBeesToken();
+        expect(sendAsyncSpy).toHaveBeenCalledWith({ type: ClientEventType.TOKEN });
+    });
+    it('should handle onSuggestContacts correctly', () => {
+        const callback = jest.fn();
+        const addEventListenerSpy = jest.spyOn(clientInstance, 'addEventListener');
+        clientInstance.onSuggestContacts(callback);
+        expect(PostMessageController.getInstance().sendAsyncErrorSafe).toHaveBeenCalledWith({
+            type: ClientEventType.CONTACTS_AUTO_SUGGEST_IS_SUPPORTED,
+        });
+        expect(addEventListenerSpy).toHaveBeenCalledWith(EventType.GET_CONTACTS_AUTO_SUGGEST, expect.any(Function));
+    });
+    it('should handle onLookupAndMatchContact correctly', () => {
+        const callback = jest.fn();
+        const addEventListenerSpy = jest.spyOn(clientInstance, 'addEventListener');
+        clientInstance.onLookupAndMatchContact(callback);
+        expect(PostMessageController.getInstance().sendAsyncErrorSafe).toHaveBeenCalledWith({
+            type: ClientEventType.CONTACT_LOOK_UP_AND_MATCH_IS_SUPPORTED,
+        });
+        expect(addEventListenerSpy).toHaveBeenCalledWith(EventType.GET_LOOK_UP_AND_MATCH, expect.any(Function));
+    });
+    it('should handle onThemeChange correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onThemeChange(callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.USE_THEME, callback);
+    });
+    it('should handle storage correctly', () => {
+        const key = 'testKey';
+        const value = 'testValue';
+        const localStorageManager = LocalStorageManager.getInstance();
+        clientInstance.saveToStorage(key, value);
+        expect(localStorageManager.save).toHaveBeenCalledWith(key, value);
+        clientInstance.deleteFromStorage(key);
+        expect(localStorageManager.delete).toHaveBeenCalledWith(key);
+        jest.spyOn(localStorageManager, 'retrieve').mockReturnValue(value);
+        expect(clientInstance.getFromStorage(key)).toBe(value);
+    });
+    it('should handle onStorage correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onStorage(callback);
+        expect(LocalStorageManager.getInstance().onStorage).toHaveBeenCalledWith(callback);
+    });
+    it('should handle onLogout correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onLogout(callback);
+        expect(PostMessageController.getInstance().sendAsync).toHaveBeenCalledWith({
+            type: ClientEventType.LOGOUT_IS_SUPPORTED,
+        });
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.LOGOUT, callback);
+    });
+    it('should handle sendAnalytics correctly', () => {
+        const eventName = 'testEvent';
+        const params = { key: 'value' };
+        clientInstance.sendAnalytics(eventName, params);
+        expect(PostMessageController.getInstance().sendAsync).toHaveBeenCalledWith({
+            type: ClientEventType.SEND_ANALYTICS,
+            payload: {
+                eventName,
+                params,
+            },
+        });
+    });
+    it('should set integration storage key correctly', () => {
+        const integrationKey = 'integrationKey';
+        clientInstance.setIntegrationStorageKey(integrationKey);
+        expect(LocalStorageManager.getInstance().setIntegrationKey).toHaveBeenCalledWith(integrationKey);
+    });
+    it('should get TechnicalSupport instance', () => {
+        expect(clientInstance.getTechnicalSupport()).toBe(TechnicalSupport.getInstance());
+    });
+});

package/dist-es/src/__tests__/MessageListener.test.js

@@ -0,0 +1,100 @@
+import { EventType } from '../enums';
+import { MessageListener } from '../helpers/MessageListener';
+describe('MessageListener', () => {
+    let listenerInstance;
+    let originalWindow;
+    beforeAll(() => {
+        originalWindow = { ...globalThis.window };
+    });
+    beforeEach(() => {
+        MessageListener.instance = null;
+        listenerInstance = MessageListener.getInstance();
+        jest.clearAllMocks();
+        // (listenerInstance as any).listeners = [];
+        // (listenerInstance as any).useSubscription = false;
+        globalThis.window = {
+            ...originalWindow,
+            addEventListener: jest.fn(),
+            removeEventListener: jest.fn(),
+            location: { host: 'http://example.com' },
+        };
+    });
+    afterAll(() => {
+        globalThis.window = originalWindow;
+    });
+    it('should return a singleton instance', () => {
+        const instance1 = MessageListener.getInstance();
+        const instance2 = MessageListener.getInstance();
+        expect(instance1).toBe(instance2);
+    });
+    it('should add an event listener and call the callback on message event', () => {
+        const mockCallback = jest.fn();
+        listenerInstance.listen(EventType.REDIRECT_QUERY, mockCallback);
+        // console.log((listenerInstance as any).listeners);
+        const messageEvent = {
+            data: JSON.stringify({ type: EventType.REDIRECT_QUERY, payload: { some: 'data' } }),
+            origin: 'http://parent.example.com',
+            source: {},
+        };
+        listenerInstance.onMessage(messageEvent);
+        expect(mockCallback).toHaveBeenCalledWith({ some: 'data' });
+    });
+    it('should not call the callback if the message origin is the same as the current window location', () => {
+        const mockCallback = jest.fn();
+        listenerInstance.listen(EventType.ADD_CALL, mockCallback);
+        const messageEvent = {
+            data: JSON.stringify({ type: EventType.ADD_CALL, payload: { some: 'data' } }),
+            origin: window.location.host,
+            source: window,
+        };
+        listenerInstance.onMessage(messageEvent);
+        expect(mockCallback).not.toHaveBeenCalled();
+    });
+    it('should remove an event listener and stop calling the callback on message event', () => {
+        const mockCallback = jest.fn();
+        const removeEventListener = listenerInstance.listen(EventType.ADD_CALL, mockCallback);
+        removeEventListener();
+        const messageEvent = {
+            data: JSON.stringify({ type: EventType.ADD_CALL, payload: { some: 'data' } }),
+            origin: 'http://example.com',
+            source: window,
+        };
+        listenerInstance.onMessage(messageEvent);
+        expect(mockCallback).not.toHaveBeenCalled();
+    });
+    it('should not add duplicate event listeners', () => {
+        const mockCallback = jest.fn();
+        listenerInstance.listen(EventType.ADD_CALL, mockCallback);
+        listenerInstance.listen(EventType.ADD_CALL, mockCallback);
+        expect(listenerInstance.listeners.length).toBe(1);
+    });
+    it('should parse valid JSON message data correctly', () => {
+        const validJsonMessage = '{"type": "xBeesAddCall", "payload": {"some": "data"}}';
+        const parsedMessage = listenerInstance.parseJSON(validJsonMessage);
+        expect(parsedMessage).toEqual({ type: EventType.ADD_CALL, payload: { some: 'data' } });
+    });
+    it('should return null for invalid JSON message data', () => {
+        const invalidJsonMessage = 'invalid json';
+        const parsedMessage = listenerInstance.parseJSON(invalidJsonMessage);
+        expect(parsedMessage).toBeNull();
+    });
+    it('should handle non-JSON message data gracefully', () => {
+        const messageEvent = {
+            data: 'invalid json',
+            origin: 'http://example.com',
+            source: window,
+        };
+        expect(listenerInstance.parseMessage(messageEvent)).toBeNull();
+    });
+    it('should correctly manage the useSubscription flag and event listeners on window', () => {
+        const mockCallback = jest.fn();
+        const addEventListenerSpy = jest.spyOn(window, 'addEventListener');
+        const removeEventListenerSpy = jest.spyOn(window, 'removeEventListener');
+        const removeEventListener = listenerInstance.listen(EventType.ADD_CALL, mockCallback);
+        expect(listenerInstance.useSubscription).toBe(true);
+        expect(addEventListenerSpy).toHaveBeenCalledWith('message', expect.any(Function));
+        removeEventListener();
+        expect(listenerInstance.useSubscription).toBe(false);
+        expect(removeEventListenerSpy).toHaveBeenCalledWith('message', expect.any(Function));
+    });
+});

package/dist-es/src/helpers/ClientParams.js

@@ -23,4 +23,7 @@ export default class ClientParams {
         this.referrer = (params.get(UrlParams.REFERRER) ?? params.get(DeprecatedUrlParams.REFERRER));
         this.needAuthorize = params.has(UrlParams.AUTHORIZE) ?? params.has(DeprecatedUrlParams.AUTHORIZE);
     }
+    toString() {
+        return JSON.stringify(this);
+    }
 }

package/dist-es/src/helpers/MessageListener.js

@@ -33,14 +33,17 @@ export class MessageListener {
     }
     onMessage = (message) => {
         if (window.location.host === message.origin || window === message.source) {
+            console.debug('onMessage skipped', 'skipped', 'window.location.host', window.location.host, message.origin, 'window', window === message.source, message);
             // skip events started from integration itself if any
             return;
         }
         const data = this.parseMessage(message);
         if (!data) {
+            console.debug('onMessage skipped', message);
             return;
         }
         const { type, payload } = data;
+        console.debug('onMessage call', type, payload);
         this.listeners.forEach(({ eventName, callback }) => {
             if (eventName === type) {
                 if (type === EventType.ADD_CALL) {
@@ -55,7 +58,7 @@ export class MessageListener {
             }
         });
     };
-    addEventListener(eventName, callback) {
+    listen(eventName, callback) {
         if (!this.useSubscription) {
             this.useSubscription = true;
             window.addEventListener('message', this.onMessage);
@@ -65,10 +68,10 @@ export class MessageListener {
             this.listeners.push({ eventName, callback });
         }
         return () => {
-            this.removeEventListener(eventName, callback);
+            this.off(eventName, callback);
         };
     }
-    removeEventListener(eventName, callback) {
+    off(eventName, callback) {
         this.listeners = this.listeners.filter(({ eventName: _eventName, callback: _callback }) => !(Object.is(callback, _callback) && (!eventName ? true : eventName === _eventName)));
         if (this.useSubscription && !this.listeners.length) {
             this.useSubscription = false;

package/dist-es/src/helpers/TechnicalSupport.js

@@ -0,0 +1,25 @@
+import { ClientEventType } from '../enums';
+import ClientParams from './ClientParams';
+import PostMessageController from './PostMessageController';
+class TechnicalSupport {
+    static instance = null;
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new TechnicalSupport();
+        }
+        return this.instance;
+    }
+    // eslint-disable-next-line
+    constructor() { }
+    sendTechnicalInformation(message, data) {
+        return PostMessageController.getInstance().sendAsyncErrorSafe({
+            type: ClientEventType.SEND_TECHNICAL_SUPPORT_INFORMATION,
+            payload: {
+                'x-iframe-params': ClientParams.getInstance(),
+                message,
+                data,
+            },
+        });
+    }
+}
+export default TechnicalSupport;

package/dist-es/types/Json.js

@@ -0,0 +1 @@
+export {};

package/dist-types/src/Client.d.ts

@@ -8,6 +8,7 @@ import { LookupAndMatchContactsResolver, Reject, SuggestContactsResolver } from
 import { StorageEventCallback } from '../types/Storage';
 import { ToastSeverity } from '../types/Toast';
 import { ClientEventType, EventType } from './enums';
+import TechnicalSupport from './helpers/TechnicalSupport';
 /**
  * Client provides functionality of communication between xBees and integrated web applications via iFrame or ReactNative WebView
  * integration creates na instance with new Client()
@@ -65,4 +66,5 @@ export declare class Client implements ConnectClient {
     onLogout(callback: Callback<EventType.LOGOUT>): RemoveEventListener;
     sendAnalytics(eventName: string, params?: Record<string, string>): void;
     setIntegrationStorageKey(integrationKey: string): void;
+    getTechnicalSupport(): TechnicalSupport;
 }

package/dist-types/src/__tests__/Client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-types/src/__tests__/MessageListener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-types/src/helpers/ClientParams.d.ts

@@ -9,4 +9,5 @@ export default class ClientParams {
     readonly iframeId: string;
     readonly variant: WorkVariants | null;
     constructor();
+    toString(): string;
 }

package/dist-types/src/helpers/MessageListener.d.ts

@@ -10,6 +10,6 @@ export declare class MessageListener {
     private parseMessage;
     private parseJSON;
     private onMessage;
-    addEventListener<T extends EventType = EventType>(eventName: T, callback: Callback<T>): RemoveEventListener;
-    removeEventListener<T extends EventType = EventType>(eventName: T | null, callback: Callback<T>): void;
+    listen<T extends EventType = EventType>(eventName: T, callback: Callback<T>): RemoveEventListener;
+    off<T extends EventType = EventType>(eventName: T | null, callback: Callback<T>): void;
 }

package/dist-types/src/helpers/TechnicalSupport.d.ts

@@ -0,0 +1,9 @@
+import { JSONArray, JSONObject } from '../../types';
+import { ClientEventType } from '../enums';
+declare class TechnicalSupport {
+    private static instance;
+    static getInstance(): TechnicalSupport;
+    private constructor();
+    sendTechnicalInformation(message: string, data?: JSONObject | JSONArray): Promise<import("../../types/Message").ResponseMessage<ClientEventType.SEND_TECHNICAL_SUPPORT_INFORMATION> | undefined>;
+}
+export default TechnicalSupport;

package/dist-types/types/Client.d.ts

@@ -1,4 +1,5 @@
 import { ClientEventType, EventType } from '../src/enums';
+import TechnicalSupport from '../src/helpers/TechnicalSupport';
 import { Callback } from './Callback';
 import { Contact, ContactQuery } from './Contact';
 import { RemoveEventListener } from './Listener';
@@ -147,4 +148,7 @@ export interface ConnectClient {
     /**
      * send analytics data to x-bees for track into analytics data */
     sendAnalytics: (eventName: string, params?: Record<string, string>) => void;
+    /**
+     * special object to provide x-bees technical support */
+    getTechnicalSupport: () => TechnicalSupport;
 }

package/dist-types/types/Event.d.ts

@@ -19,4 +19,4 @@ export type EventCallbackMap = {
     [EventType.PBX_TOKEN]: (token: EventPayloadMap[EventType.PBX_TOKEN]) => void;
     [EventType.REDIRECT_QUERY]: (query: EventPayloadMap[EventType.REDIRECT_QUERY]) => void;
 };
-export type RawMessageEvent = MessageEvent<'string' | Message>;
+export type RawMessageEvent = MessageEvent<string | Message>;

package/dist-types/types/Json.d.ts

@@ -0,0 +1,7 @@
+type JSONValue = string | number | boolean | null | JSONObject | JSONArray;
+export interface JSONObject {
+    [key: string]: JSONValue;
+}
+export interface JSONArray extends Array<JSONValue> {
+}
+export {};

package/dist-types/types/Payload.d.ts

@@ -1,5 +1,7 @@
+import ClientParams from '../src/helpers/ClientParams';
 import { Contact, ContactQuery } from './Contact';
 import { Conversation } from './conversation';
+import { JSONArray, JSONObject } from './Json';
 import { SupportedPlatformVariant } from './Platform';
 import { ToastSeverity } from './Toast';
 export interface IPayloadViewPort {
@@ -52,5 +54,7 @@ export interface IPayloadSendAnalytics {
     params?: Record<string, string>;
 }
 export interface IPayloadTechSupport {
+    'x-iframe-params': ClientParams;
     message: string;
+    data?: JSONObject | JSONArray;
 }

package/dist-types/types/index.d.ts

@@ -1,3 +1,4 @@
 import { Contact, ContactQuery } from './Contact';
+import { JSONArray, JSONObject } from './Json';
 import { IPayloadAutoSuggestResult, IPayloadCallStart, IPayloadCallStartedInfo, IPayloadContactMatchResult, IPayloadContactMatchResultNotFound, IPayloadContactResult, IPayloadContextResult, IPayloadConversationResult, IPayloadSendAnalytics, IPayloadTechSupport, IPayloadThemeChange, IPayloadToast, IPayloadVersion, IPayloadViewPort } from './Payload';
-export type { Contact, ContactQuery, IPayloadAutoSuggestResult, IPayloadCallStart, IPayloadCallStartedInfo, IPayloadContactMatchResult, IPayloadContactMatchResultNotFound, IPayloadContactResult, IPayloadContextResult, IPayloadConversationResult, IPayloadSendAnalytics, IPayloadTechSupport, IPayloadThemeChange, IPayloadToast, IPayloadVersion, IPayloadViewPort, };
+export type { Contact, ContactQuery, IPayloadAutoSuggestResult, IPayloadCallStart, IPayloadCallStartedInfo, IPayloadContactMatchResult, IPayloadContactMatchResultNotFound, IPayloadContactResult, IPayloadContextResult, IPayloadConversationResult, IPayloadSendAnalytics, IPayloadTechSupport, IPayloadThemeChange, IPayloadToast, IPayloadVersion, IPayloadViewPort, JSONArray, JSONObject, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wildix/xbees-connect",
-  "version": "1.2.0-alpha.3",
+  "version": "1.2.0-alpha.7",
   "description": "This library provides easy communication between x-bees and integrated web applications",
   "author": "dimitri.chernykh <dimitri.chernykh@wildix.com>",
   "homepage": "",
@@ -17,7 +17,10 @@
     "build:docs": "typedoc",
     "lint": "eslint . && tsc --noEmit",
     "lint:fix": "eslint . --fix",
-    "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo"
+    "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   },
   "files": [
     "dist-*/**"
@@ -30,8 +33,12 @@
     "access": "public"
   },
   "devDependencies": {
+    "@types/jest": "^29.5.12",
     "eslint": "^8.55.0",
+    "eslint-plugin-jest": "^28.5.0",
+    "jest": "^29.7.0",
     "rimraf": "^5.0.5",
+    "ts-jest": "^29.1.3",
     "typescript": "^5.3.3"
   },
   "parserOptions": {
@@ -42,5 +49,5 @@
   "engines": {
     "node": ">=16"
   },
-  "gitHead": "53d26ea455e12585a72b9e4c831927afa241f7a5"
+  "gitHead": "8c0d507e1063a5c4de57b59fc58dcba65a14d6d6"
 }