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

package/dist-es/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wildix/xbees-connect",
-    "version": "1.2.0-alpha.0",
+    "version": "1.2.0-alpha.3",
     "description": "This library provides easy communication between x-bees and integrated web applications",
     "author": "dimitri.chernykh <dimitri.chernykh@wildix.com>",
     "homepage": "",

package/dist-es/src/Client.js

@@ -2,6 +2,7 @@ import packageJson from '../package.json';
 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';
 /**
  * Client provides functionality of communication between xBees and integrated web applications via iFrame or ReactNative WebView
@@ -28,52 +29,14 @@ export class Client {
             void this.getInstance().ready();
         }
     }
-    listeners = [];
-    useSubscription = false;
     localStorageManager = LocalStorageManager.getInstance();
+    messageListener = MessageListener.getInstance();
     constructor() {
         this.addEventListener(EventType.PBX_TOKEN, (token) => (ClientParams.getInstance().userToken = token));
     }
     sendAsync(data) {
         return PostMessageController.getInstance().sendAsync(data);
     }
-    parseMessage(message) {
-        try {
-            const data = typeof message.data === 'string' ? JSON.parse(message.data) : message.data;
-            if (!data?.type) {
-                return null;
-            }
-            return data;
-        }
-        catch (error) {
-            console.error('parse message error', error);
-            return null;
-        }
-    }
-    onMessage(message) {
-        if (window.location.host === message.origin || window === message.source) {
-            // skip events started from integration itself if any
-            return;
-        }
-        const data = this.parseMessage(message);
-        if (!data) {
-            return;
-        }
-        const { type, payload } = data;
-        this.listeners.forEach(({ eventName, callback }) => {
-            if (eventName === type) {
-                if (type === EventType.ADD_CALL) {
-                    const callbackFn = callback;
-                    callbackFn(payload);
-                }
-                else {
-                    // @ts-expect-error TODO: check the type for Callback<?>
-                    const callbackFn = callback;
-                    callbackFn(payload);
-                }
-            }
-        });
-    }
     ready(platform = 'all') {
         return this.sendAsync({
             type: ClientEventType.READY,
@@ -165,24 +128,10 @@ export class Client {
         return this.sendAsync({ type: ClientEventType.AUTHORIZED });
     }
     addEventListener(eventName, callback) {
-        if (!this.useSubscription) {
-            this.useSubscription = true;
-            window.addEventListener('message', this.onMessage.bind(this));
-        }
-        const foundThisEvent = this.listeners.find(({ eventName: _eventName, callback: _callback }) => eventName === _eventName && Object.is(callback, _callback));
-        if (!foundThisEvent) {
-            this.listeners.push({ eventName, callback });
-        }
-        return () => {
-            this.removeEventListener(eventName, callback);
-        };
+        return this.messageListener.addEventListener(eventName, callback);
     }
     removeEventListener(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;
-            window.removeEventListener('message', this.onMessage.bind(this));
-        }
+        this.messageListener.removeEventListener(eventName, callback);
     }
     off(callback) {
         this.localStorageManager.removeOnStorage(callback);

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

@@ -0,0 +1,78 @@
+import { EventType } from '../enums';
+export class MessageListener {
+    static instance = null;
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new MessageListener();
+        }
+        return this.instance;
+    }
+    listeners = [];
+    useSubscription = false;
+    // eslint-disable-next-line
+    constructor() { }
+    parseMessage(message) {
+        try {
+            const data = typeof message.data === 'string' ? this.parseJSON(message.data) : message.data;
+            if (!data?.type) {
+                return null;
+            }
+            return data;
+        }
+        catch (error) {
+            console.error('parse message error', error);
+            return null;
+        }
+    }
+    parseJSON(messageData) {
+        const trimmedData = messageData.trim();
+        if (!trimmedData || !trimmedData.startsWith('{') || !trimmedData.endsWith('}')) {
+            return null;
+        }
+        return JSON.parse(trimmedData);
+    }
+    onMessage = (message) => {
+        if (window.location.host === message.origin || window === message.source) {
+            // skip events started from integration itself if any
+            return;
+        }
+        const data = this.parseMessage(message);
+        if (!data) {
+            return;
+        }
+        const { type, payload } = data;
+        this.listeners.forEach(({ eventName, callback }) => {
+            if (eventName === type) {
+                if (type === EventType.ADD_CALL) {
+                    const callbackFn = callback;
+                    callbackFn(payload);
+                }
+                else {
+                    // @ts-expect-error TODO: check the type for Callback<?>
+                    const callbackFn = callback;
+                    callbackFn(payload);
+                }
+            }
+        });
+    };
+    addEventListener(eventName, callback) {
+        if (!this.useSubscription) {
+            this.useSubscription = true;
+            window.addEventListener('message', this.onMessage);
+        }
+        const foundThisEvent = this.listeners.find(({ eventName: _eventName, callback: _callback }) => eventName === _eventName && Object.is(callback, _callback));
+        if (!foundThisEvent) {
+            this.listeners.push({ eventName, callback });
+        }
+        return () => {
+            this.removeEventListener(eventName, callback);
+        };
+    }
+    removeEventListener(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;
+            window.removeEventListener('message', this.onMessage);
+        }
+    }
+}

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

@@ -16,13 +16,10 @@ export declare class Client implements ConnectClient {
     private static instance;
     static getInstance(): ConnectClient;
     static initialize(renderer: () => Promise<void>): void;
-    private listeners;
-    private useSubscription;
     private readonly localStorageManager;
-    constructor();
+    private readonly messageListener;
+    private constructor();
     private sendAsync;
-    private parseMessage;
-    private onMessage;
     ready(platform?: SupportedPlatformVariant | undefined): Promise<ResponseMessage>;
     version(): string;
     isPlatformNative(): boolean;

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

@@ -0,0 +1,15 @@
+import { Callback } from '../../types/Callback';
+import { RemoveEventListener } from '../../types/Listener';
+import { EventType } from '../enums';
+export declare class MessageListener {
+    private static instance;
+    static getInstance(): MessageListener;
+    private listeners;
+    private useSubscription;
+    private constructor();
+    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;
+}

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

@@ -1,4 +1,4 @@
-import { EventType } from '../src/enums';
+import { ClientEventType, EventType } from '../src/enums';
 import { Callback } from './Callback';
 import { Contact, ContactQuery } from './Contact';
 import { RemoveEventListener } from './Listener';
@@ -53,25 +53,25 @@ export interface ConnectClient {
     isActivationOnly: () => boolean;
     /**
      * Retrieves current x-bees context data */
-    getContext: () => Promise<ResponseMessage>;
+    getContext: () => Promise<ResponseMessage<ClientEventType.CONTEXT>>;
     /**
      * Retrieves current opened in x-bees contact data */
-    getCurrentContact: () => Promise<ResponseMessage>;
+    getCurrentContact: () => Promise<ResponseMessage<ClientEventType.CURRENT_CONTACT>>;
     /**
      * Retrieves current opened in x-bees conversation data or undefined if the conversation is temporary */
-    getCurrentConversation: () => Promise<ResponseMessage>;
+    getCurrentConversation: () => Promise<ResponseMessage<ClientEventType.CURRENT_CONVERSATION>>;
     /**
      * Sends notification to x-bees about contact data updated */
-    contactUpdated(query: ContactQuery, contact: Contact): Promise<ResponseMessage>;
+    contactUpdated(query: ContactQuery, contact: Contact): Promise<ResponseMessage<ClientEventType.CONTACT_CREATE_OR_UPDATE>>;
     /**
      * Sends notification to x-bees about contact match was updated */
-    contactMatchUpdated(query: ContactQuery, contact: Contact): Promise<ResponseMessage>;
+    contactMatchUpdated(query: ContactQuery, contact: Contact): Promise<ResponseMessage<ClientEventType.CONTACT_MATCH_UPDATE>>;
     /**
      * Retrieves current theme mode (light or dark) */
-    getThemeMode: () => Promise<ResponseMessage>;
+    getThemeMode: () => Promise<ResponseMessage<ClientEventType.THEME_MODE>>;
     /**
      * Retrieves current theme with mode (light or dark) and theme options like typography settings and palette */
-    getTheme: () => Promise<ResponseMessage>;
+    getTheme: () => Promise<ResponseMessage<ClientEventType.THEME>>;
     /**
      * Sends request to x-bees to start a call with the number */
     startCall: (phoneNumber: string) => Promise<ResponseMessage>;
@@ -107,7 +107,7 @@ export interface ConnectClient {
     onPbxTokenChange: (callback: Callback<EventType.PBX_TOKEN>) => RemoveEventListener;
     /**
      * Retrieves current x-bees token */
-    getXBeesToken: () => Promise<ResponseMessage>;
+    getXBeesToken: () => Promise<ResponseMessage<ClientEventType.TOKEN>>;
     /**
      * Starts listen for the events of searching contacts and handle autosuggestion with the provided callback */
     onSuggestContacts: (callback: (query: string, resolve: SuggestContactsResolver, reject: Reject) => void) => RemoveEventListener;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wildix/xbees-connect",
-  "version": "1.2.0-alpha.1",
+  "version": "1.2.0-alpha.3",
   "description": "This library provides easy communication between x-bees and integrated web applications",
   "author": "dimitri.chernykh <dimitri.chernykh@wildix.com>",
   "homepage": "",
@@ -42,5 +42,5 @@
   "engines": {
     "node": ">=16"
   },
-  "gitHead": "6f953fb9e8d3a38116761747d7421241400966ff"
+  "gitHead": "53d26ea455e12585a72b9e4c831927afa241f7a5"
 }