@wildix/xbees-connect 1.3.4 → 1.3.5

package/dist-cjs/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlParams = exports.StartPage = exports.ClientEventType = exports.EventType = void 0;
+const Client_1 = require("./src/Client");
+var enums_1 = require("./src/enums");
+Object.defineProperty(exports, "EventType", { enumerable: true, get: function () { return enums_1.EventType; } });
+var enums_2 = require("./src/enums");
+Object.defineProperty(exports, "ClientEventType", { enumerable: true, get: function () { return enums_2.ClientEventType; } });
+var enums_3 = require("./src/enums");
+Object.defineProperty(exports, "StartPage", { enumerable: true, get: function () { return enums_3.StartPage; } });
+Object.defineProperty(exports, "UrlParams", { enumerable: true, get: function () { return enums_3.UrlParams; } });
+__exportStar(require("./types"), exports);
+exports.default = Client_1.Client;

package/dist-cjs/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@wildix/xbees-connect",
+    "version": "1.3.5",
+    "description": "This library provides easy communication between x-bees and integrated web applications",
+    "author": "dimitri.chernykh <dimitri.chernykh@wildix.com>",
+    "homepage": "",
+    "sideEffects": false,
+    "license": "MIT",
+    "main": "./dist-cjs/index.js",
+    "types": "./dist-types/index.d.ts",
+    "module": "./dist-es/index.js",
+    "scripts": {
+        "build": "bun run clean && bun run build:es && bun run build:cjs && bun run build:types",
+        "build:es": "tsc -p tsconfig.es.json",
+        "build:cjs": "tsc -p tsconfig.cjs.json",
+        "build:types": "tsc -p tsconfig.types.json",
+        "build:docs": "typedoc",
+        "lint": "eslint . && tsc --noEmit",
+        "lint:fix": "eslint . --fix",
+        "clean": "rimraf --glob './dist-*' '*.tsbuildinfo'",
+        "build:api-extractor": "api-extractor run --local"
+    },
+    "files": [
+        "dist-*/**"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git@git.wildix.com:xbs/sdk-ui.git"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "devDependencies": {
+        "@microsoft/api-extractor": "^7.47.9",
+        "@wildix/eslint-config-style-guide": "^1.2.2",
+        "eslint": "^8.55.0",
+        "rimraf": "^5.0.5",
+        "typescript": "^5.3.3"
+    },
+    "parserOptions": {
+        "project": [
+            "./tsconfig.json"
+        ]
+    },
+    "engines": {
+        "node": ">=16"
+    }
+}

package/dist-cjs/src/Client.js

@@ -0,0 +1,492 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const package_json_1 = __importDefault(require("../package.json"));
+const types_1 = require("../types");
+const enums_1 = require("./enums");
+const LocalStorageManager_1 = __importDefault(require("./helpers/LocalStorageManager"));
+const MessageListener_1 = require("./helpers/MessageListener");
+const PostMessageControllerNative_1 = __importDefault(require("./helpers/PostMessageControllerNative"));
+const PostMessageControllerWeb_1 = __importDefault(require("./helpers/PostMessageControllerWeb"));
+const TechnicalSupport_1 = __importDefault(require("./helpers/TechnicalSupport"));
+const getUrlSearchParamsMap_1 = require("./utils/url/getUrlSearchParamsMap");
+/**
+ * Client provides functionality of communication between xBees and integrated web applications via iFrame or ReactNative WebView
+ * integration creates na instance with new Client()
+ * */
+class Client {
+    static instance = null;
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new Client();
+        }
+        return this.instance;
+    }
+    static initialize(renderer) {
+        if (this.getInstance().showsUi()) {
+            try {
+                void renderer();
+            }
+            catch (error) {
+                console.error('Error on init rendering widget:', error);
+            }
+        }
+    }
+    worker;
+    listeners = [];
+    useSubscription = false;
+    userToken = '';
+    pbxDomain = '';
+    visible = false;
+    user = null;
+    userExtension = null;
+    userEmail;
+    referrer;
+    needAuthorize;
+    isParentReactNativeWebView;
+    iframeId;
+    variant = null;
+    startPage = null;
+    localStorageManager = LocalStorageManager_1.default.getInstance();
+    constructor() {
+        const params = (0, getUrlSearchParamsMap_1.getUrlSearchParamsMap)();
+        this.iframeId = params.get(enums_1.UrlParams.ID);
+        this.variant = params.get(enums_1.UrlParams.VARIANT);
+        this.userEmail = params.get(enums_1.UrlParams.USER);
+        this.referrer = params.get(enums_1.UrlParams.REFERRER);
+        this.needAuthorize = params.has(enums_1.UrlParams.AUTHORIZE);
+        this.startPage = params.get(enums_1.UrlParams.START_PAGE);
+        // @ts-expect-error window.ReactNativeWebView will be provided by ReactNative WebView
+        this.isParentReactNativeWebView = !!window.ReactNativeWebView;
+        this.worker = this.isParentReactNativeWebView ? new PostMessageControllerNative_1.default() : new PostMessageControllerWeb_1.default();
+        this.addEventListener(enums_1.EventType.PBX_TOKEN, (token) => {
+            this.userToken = token;
+        });
+        this.addEventListener(enums_1.EventType.VISIBILITY, (isActive) => (this.visible = isActive));
+    }
+    sendAsync(data) {
+        if (!this.isOpenedFromXBees()) {
+            console.warn('[xbees-connect] Application is not running inside xbees. URL:', window.location.href);
+            return new Promise(() => { });
+        }
+        return this.worker.sendAsync({
+            ...data,
+            iframeId: this.iframeId,
+        });
+    }
+    async sendAsyncErrorSafe(data) {
+        try {
+            return await this.sendAsync(data);
+        }
+        catch (error) {
+            console.debug('send error - type:', error);
+        }
+    }
+    parseMessage(message) {
+        try {
+            const data = typeof message.data === 'string' ? MessageListener_1.MessageListener.parseJSON(message.data) : message.data;
+            if (!data?.type) {
+                return null;
+            }
+            return data;
+        }
+        catch (error) {
+            console.error('parse message error', error);
+            return null;
+        }
+    }
+    onMessage(message) {
+        const data = this.parseMessage(message);
+        if (!data) {
+            return;
+        }
+        const { type, payload } = data;
+        this.listeners.forEach(({ eventName, callback }) => {
+            if (eventName === type) {
+                if (type === enums_1.EventType.ADD_CALL) {
+                    const callbackFn = callback;
+                    callbackFn(payload);
+                }
+                else {
+                    // @ts-expect-error TODO: check the type for Callback<?>
+                    const callbackFn = callback;
+                    callbackFn(payload);
+                }
+            }
+        });
+    }
+    sendDailyIntegrationUsageAnalytics() {
+        const sentUsageAnalyticsDate = this.getFromStorage('sentUsageAnalyticsDate');
+        const today = new Date().toDateString();
+        if (sentUsageAnalyticsDate !== today) {
+            this.sendAnalytics('xBeesIntegrationUsage');
+            this.saveToStorage('sentUsageAnalyticsDate', today);
+        }
+    }
+    ready(props = types_1.SupportedPlatformVariant.ALL) {
+        const payload = typeof props === 'string'
+            ? { version: this.version(), platform: props }
+            : { version: this.version(), ...props, platform: props.platform ?? types_1.SupportedPlatformVariant.ALL };
+        this.getXBeesUser();
+        return this.sendAsync({
+            type: enums_1.ClientEventType.READY,
+            payload,
+        });
+    }
+    async requestXbeesUser() {
+        const responseMessageUser = await this.sendAsync({ type: enums_1.ClientEventType.USER });
+        if (responseMessageUser.payload) {
+            const { extension, domain } = responseMessageUser.payload;
+            this.user = { ...responseMessageUser.payload, email: this.getUserEmail() };
+            if (extension) {
+                this.userExtension = extension;
+            }
+            if (domain) {
+                this.pbxDomain = domain;
+            }
+        }
+    }
+    /**
+     * @deprecated Use getXBeesUserAsync instead. This method doesn't wait for the user data to be fetched.
+     */
+    getXBeesUser() {
+        if (!this.user) {
+            this.requestXbeesUser();
+        }
+        return this.user;
+    }
+    /**
+     * Asynchronously retrieves the xBees user data.
+     * This method waits for the user data to be fetched before returning.
+     * @returns Promise that resolves to the XBeesUser or null if not available
+     */
+    async getXBeesUserAsync() {
+        if (!this.user) {
+            await this.requestXbeesUser();
+        }
+        return this.user;
+    }
+    version() {
+        return package_json_1.default.version;
+    }
+    isPlatformNative() {
+        return this.isParentReactNativeWebView;
+    }
+    isPlatformWeb() {
+        return !this.isParentReactNativeWebView;
+    }
+    isOpenedFromXBees() {
+        return this.isParentReactNativeWebView || (!!parent && parent !== window);
+    }
+    getUserPbxToken() {
+        return this.userToken;
+    }
+    getUserEmail() {
+        return this.userEmail;
+    }
+    getPbxDomain() {
+        return this.pbxDomain;
+    }
+    getUserExtension() {
+        return this.userExtension;
+    }
+    getReferrer() {
+        return this.referrer;
+    }
+    getStartPage() {
+        return this.startPage;
+    }
+    isVisible() {
+        return this.visible;
+    }
+    getBackToAppUrl() {
+        if (Client.getInstance().isPlatformNative()) {
+            return `${this.referrer}://integrations/${this.iframeId}`;
+        }
+        return `${this.referrer}/integrations/${this.iframeId}`;
+    }
+    isDataOnly() {
+        return this.variant === 'no-ui' || this.variant === 'daemon';
+    }
+    isSetupDialog() {
+        return this.variant === 'd' || this.variant === 'dialog';
+    }
+    showsUi() {
+        return !this.isDataOnly();
+    }
+    isFullsize() {
+        return this.variant === 'f';
+    }
+    isActivationOnly() {
+        return this.needAuthorize;
+    }
+    getContext() {
+        return this.sendAsync({ type: enums_1.ClientEventType.CONTEXT });
+    }
+    getCurrentContact() {
+        return this.sendAsync({ type: enums_1.ClientEventType.CURRENT_CONTACT });
+    }
+    getCurrentConversation() {
+        return this.sendAsync({ type: enums_1.ClientEventType.CURRENT_CONVERSATION });
+    }
+    getAvailableContactData() {
+        return this.sendAsync({ type: enums_1.ClientEventType.AVAILABLE_CONTACT_DATA });
+    }
+    contactUpdated(query, contact) {
+        return this.sendAsync({ type: enums_1.ClientEventType.CONTACT_CREATE_OR_UPDATE, payload: { query, contact } });
+    }
+    contactMatchUpdated(query, contact) {
+        return this.sendAsync({ type: enums_1.ClientEventType.CONTACT_MATCH_UPDATE, payload: { query, contact } });
+    }
+    getThemeMode() {
+        return this.sendAsync({ type: enums_1.ClientEventType.THEME_MODE });
+    }
+    getTheme() {
+        return this.sendAsync({ type: enums_1.ClientEventType.THEME });
+    }
+    startCall(phoneNumber) {
+        return this.sendAsync({
+            type: enums_1.ClientEventType.START_CALL,
+            payload: { phoneNumber },
+        });
+    }
+    reboot() {
+        return this.sendAsync({ type: enums_1.ClientEventType.REBOOT });
+    }
+    setViewport(payload) {
+        return this.sendAsync({ type: enums_1.ClientEventType.VIEW_PORT, payload });
+    }
+    toClipboard(payload) {
+        return this.sendAsync({ type: enums_1.ClientEventType.TO_CLIPBOARD, payload });
+    }
+    showToast(message, severity = 'INFO') {
+        return this.sendAsync({ type: enums_1.ClientEventType.TOAST, payload: { message, severity } });
+    }
+    isNotAuthorized() {
+        return this.sendAsync({ type: enums_1.ClientEventType.NOT_AUTHORIZED });
+    }
+    isAuthorized() {
+        this.sendDailyIntegrationUsageAnalytics();
+        return this.sendAsync({
+            type: enums_1.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);
+        };
+    }
+    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));
+        }
+    }
+    off(callback) {
+        this.localStorageManager.removeOnStorage(callback);
+        this.removeEventListener(null, callback);
+    }
+    onRedirectQuery(callback) {
+        return this.addEventListener(enums_1.EventType.REDIRECT_QUERY, callback);
+    }
+    onCallEnded(callback) {
+        return this.addEventListener(enums_1.EventType.TERMINATE_CALL, callback);
+    }
+    onCallStarted(callback) {
+        return this.addEventListener(enums_1.EventType.ADD_CALL, callback);
+    }
+    onPbxTokenChange(callback) {
+        return this.addEventListener(enums_1.EventType.PBX_TOKEN, callback);
+    }
+    getXBeesToken() {
+        return this.sendAsync({ type: enums_1.ClientEventType.TOKEN });
+    }
+    onSuggestContacts(callback) {
+        // send event to x-bees
+        void this.sendAsyncErrorSafe({
+            type: enums_1.ClientEventType.CONTACTS_AUTO_SUGGEST_IS_SUPPORTED,
+        });
+        return this.addEventListener(enums_1.EventType.GET_CONTACTS_AUTO_SUGGEST, (query) => {
+            const resolve = (contacts) => this.sendAsync({
+                type: enums_1.ClientEventType.CONTACTS_AUTO_SUGGEST,
+                payload: {
+                    contacts,
+                    query,
+                },
+            });
+            const reject = (reason) => {
+                console.debug(reason);
+            };
+            try {
+                callback(query, resolve, reject);
+            }
+            catch (error) {
+                reject(`${error}`);
+            }
+        });
+    }
+    onLookupAndMatchContact(callback) {
+        // send event to x-bees
+        void this.sendAsyncErrorSafe({
+            type: enums_1.ClientEventType.CONTACT_LOOK_UP_AND_MATCH_IS_SUPPORTED,
+        });
+        return this.addEventListener(enums_1.EventType.GET_LOOK_UP_AND_MATCH, (query) => {
+            const resolve = (contact) => this.sendAsync({
+                type: enums_1.ClientEventType.CONTACT_LOOKUP_AND_MATCH,
+                payload: {
+                    contact,
+                    query,
+                },
+            });
+            const reject = (reason) => {
+                console.debug(reason);
+                void this.sendAsync({
+                    type: enums_1.ClientEventType.CONTACT_LOOKUP_AND_MATCH_NOT_FOUND,
+                    payload: { query },
+                });
+            };
+            try {
+                callback(query, resolve, reject);
+            }
+            catch (error) {
+                reject(`${error}`);
+            }
+        });
+    }
+    onLookupAndMatchBatchContacts(callback) {
+        // send event to x-bees
+        void this.sendAsyncErrorSafe({
+            type: enums_1.ClientEventType.LOOK_UP_AND_MATCH_BATCH_CONTACTS_IS_SUPPORTED,
+        });
+        return this.addEventListener(enums_1.EventType.GET_LOOK_UP_AND_MATCH_BATCH, (queries) => {
+            const returnResults = (contactResultsMap) => this.sendAsync({
+                type: enums_1.ClientEventType.LOOK_UP_AND_MATCH_BATCH_CONTACTS,
+                payload: {
+                    contactResultsMap: Array.from(contactResultsMap),
+                },
+            });
+            const reject = (reason) => {
+                console.debug(reason);
+                void this.sendAsync({
+                    type: enums_1.ClientEventType.LOOKUP_AND_MATCH_BATCH_ERROR,
+                    payload: { reason },
+                });
+            };
+            try {
+                callback(queries, returnResults);
+            }
+            catch (error) {
+                reject(`${error}`);
+            }
+        });
+    }
+    createContactIsSupported() {
+        return this.sendAsync({
+            type: enums_1.ClientEventType.CREATE_CONTACT_IS_SUPPORTED,
+        });
+    }
+    createContactHasNoPermission() {
+        return this.sendAsync({
+            type: enums_1.ClientEventType.CREATE_CONTACT_HAS_NO_PERMISSION,
+        });
+    }
+    onThemeChange(callback) {
+        return this.addEventListener(enums_1.EventType.USE_THEME, callback);
+    }
+    getFromStorage(key) {
+        return this.localStorageManager.retrieve(key);
+    }
+    saveToStorage(key, value) {
+        this.localStorageManager.save(key, value);
+    }
+    deleteFromStorage(key) {
+        this.localStorageManager.delete(key);
+    }
+    onStorage(listener) {
+        return this.localStorageManager.onStorage(listener);
+    }
+    onLogout(callback) {
+        // send event to x-bees
+        void this.sendAsync({
+            type: enums_1.ClientEventType.LOGOUT_IS_SUPPORTED,
+        });
+        return this.addEventListener(enums_1.EventType.LOGOUT, callback);
+    }
+    sendAnalytics(eventName, params) {
+        void this.sendAsync({
+            type: enums_1.ClientEventType.SEND_ANALYTICS,
+            payload: {
+                eventName,
+                params,
+            },
+        });
+    }
+    setIntegrationStorageKey(integrationKey) {
+        this.localStorageManager.setIntegrationKey(integrationKey);
+    }
+    getTechnicalSupport() {
+        return TechnicalSupport_1.default.getInstance();
+    }
+    onVisibilityChange(callback) {
+        return this.addEventListener(enums_1.EventType.VISIBILITY, callback);
+    }
+    saveInXbeesStorage(key, value) {
+        void this.sendAsync({
+            type: enums_1.ClientEventType.SAVE_TO_STORAGE,
+            payload: {
+                key,
+                value: typeof value === 'string' ? value : JSON.stringify(value),
+            },
+        });
+    }
+    getFromXbeesStorage(key) {
+        return this.sendAsync({
+            type: enums_1.ClientEventType.GET_FROM_STORAGE,
+            payload: { key },
+        });
+    }
+    removeFromXbeesStorage(key) {
+        void this.sendAsync({
+            type: enums_1.ClientEventType.REMOVE_FROM_STORAGE,
+            payload: { key },
+        });
+    }
+    /** should be removed, sendCustomEvent is enough **/
+    sendDropdownVisibilityEvent(dropdownVisibilityStatus) {
+        void this.sendAsync({
+            type: enums_1.ClientEventType.DROPDOWN_VISIBILITY,
+            payload: { dropdownVisibilityStatus },
+        });
+    }
+    sendCustomEvent({ type, payload }) {
+        void this.sendAsync({
+            type: enums_1.ClientEventType.CUSTOM_EVENT,
+            payload: { type, payload },
+        });
+    }
+    onContactWeightUpdate(callback) {
+        return this.addEventListener(enums_1.EventType.CONTACT_WEIGHT_UPDATE, callback);
+    }
+    onContactRefresh(callback) {
+        return this.addEventListener(enums_1.EventType.CONTACT_REFRESH, callback);
+    }
+    onStartRedirectToEntityPage(callback) {
+        return this.addEventListener(enums_1.EventType.START_REDIRECT_TO_ENTITY_PAGE, callback);
+    }
+    onCancelRedirectToEntityPage(callback) {
+        return this.addEventListener(enums_1.EventType.CANCEL_REDIRECT_TO_ENTITY_PAGE, callback);
+    }
+}
+exports.Client = Client;

package/dist-cjs/src/enums/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartPage = exports.UrlParams = exports.ClientEventType = exports.EventType = void 0;
+var EventType;
+(function (EventType) {
+    EventType["GET_CONTACTS_AUTO_SUGGEST"] = "xBeesGetContactsAutoSuggest";
+    EventType["GET_LOOK_UP_AND_MATCH"] = "xBeesGetLookUpAndMatch";
+    EventType["GET_LOOK_UP_AND_MATCH_BATCH"] = "xBeesGetLookUpAndMatchBatch";
+    EventType["ADD_CALL"] = "xBeesAddCall";
+    EventType["TERMINATE_CALL"] = "xBeesTerminateCall";
+    EventType["USE_THEME"] = "xBeesUseTheme";
+    EventType["PBX_TOKEN"] = "xBeesPbxToken";
+    EventType["REDIRECT_QUERY"] = "xBeesRedirectQuery";
+    EventType["LOGOUT"] = "xBeesLogout";
+    EventType["VISIBILITY"] = "xBeesVisibility";
+    EventType["CONTACT_WEIGHT_UPDATE"] = "xBeesContactWeightUpdate";
+    EventType["CONTACT_REFRESH"] = "xBeesContactRefresh";
+    EventType["START_REDIRECT_TO_ENTITY_PAGE"] = "xBeesStartRedirectToEntityPage";
+    EventType["CANCEL_REDIRECT_TO_ENTITY_PAGE"] = "xBeesCancelRedirectToEntityPage";
+})(EventType || (exports.EventType = EventType = {}));
+var ClientEventType;
+(function (ClientEventType) {
+    ClientEventType["READY"] = "xBeesReady";
+    ClientEventType["CONTEXT"] = "xBeesContext";
+    ClientEventType["CURRENT_CONTACT"] = "xBeesCurrentContact";
+    ClientEventType["CURRENT_CONVERSATION"] = "xBeesCurrentConversation";
+    ClientEventType["THEME_MODE"] = "xBeesThemeMode";
+    ClientEventType["THEME"] = "xBeesTheme";
+    ClientEventType["START_CALL"] = "xBeesStartCall";
+    ClientEventType["VIEW_PORT"] = "xBeesViewPort";
+    ClientEventType["REBOOT"] = "xBeesReboot";
+    ClientEventType["TO_CLIPBOARD"] = "xBeesToClipboard";
+    ClientEventType["TOAST"] = "xBeesShowToast";
+    ClientEventType["NOT_AUTHORIZED"] = "xBeesNotAuthorized";
+    ClientEventType["AUTHORIZED"] = "xBeesAuthorized";
+    ClientEventType["TOKEN"] = "xBeesToken";
+    ClientEventType["CONTACTS_AUTO_SUGGEST"] = "xBeesContactsAutoSuggest";
+    ClientEventType["CONTACT_LOOKUP_AND_MATCH"] = "xBeesContactLookupAndMatch";
+    ClientEventType["LOOK_UP_AND_MATCH_BATCH_CONTACTS"] = "xBeesLookupAndMatchBatchContacts";
+    ClientEventType["LOOKUP_AND_MATCH_BATCH_ERROR"] = "xBeesLookupAndMatchBatchError";
+    ClientEventType["CONTACT_LOOKUP_AND_MATCH_NOT_FOUND"] = "xBeesContactLookupAndMatchNotFound";
+    ClientEventType["CONTACT_CREATE_OR_UPDATE"] = "xBeesContactCreateOrUpdate";
+    ClientEventType["CONTACT_MATCH_UPDATE"] = "xBeesContactMatchUpdate";
+    ClientEventType["CONTACTS_AUTO_SUGGEST_IS_SUPPORTED"] = "xBeesContactsAutoSuggestIsSupported";
+    ClientEventType["CONTACT_LOOK_UP_AND_MATCH_IS_SUPPORTED"] = "xBeesContactLookupAndMatchIsSupported";
+    ClientEventType["LOOK_UP_AND_MATCH_BATCH_CONTACTS_IS_SUPPORTED"] = "xBeesLookupAndMatchBatchContactsIsSupported";
+    ClientEventType["LOGOUT_IS_SUPPORTED"] = "xBeesLogoutIsSupported";
+    ClientEventType["SEND_ANALYTICS"] = "xBeesSendAnalytics";
+    ClientEventType["SEND_TECHNICAL_SUPPORT_INFORMATION"] = "xBeesSendTechInfo";
+    ClientEventType["USER"] = "xBeesUser";
+    ClientEventType["SAVE_TO_STORAGE"] = "xBeesSaveToStorage";
+    ClientEventType["GET_FROM_STORAGE"] = "xBeesRequestFromStorage";
+    ClientEventType["REMOVE_FROM_STORAGE"] = "xBeesRemoveFromStorage";
+    ClientEventType["AVAILABLE_CONTACT_DATA"] = "xBeesAvailableContactData";
+    ClientEventType["DROPDOWN_VISIBILITY"] = "xBeesDropdownVisibility";
+    ClientEventType["CUSTOM_EVENT"] = "xBeesCustomEvent";
+    ClientEventType["CREATE_CONTACT_IS_SUPPORTED"] = "xBeesCreateContactIsSupported";
+    ClientEventType["CREATE_CONTACT_HAS_NO_PERMISSION"] = "xBeesCreateContactHasNoPermission";
+})(ClientEventType || (exports.ClientEventType = ClientEventType = {}));
+var UrlParams;
+(function (UrlParams) {
+    UrlParams["TOKEN"] = "t";
+    UrlParams["ID"] = "i";
+    UrlParams["VARIANT"] = "v";
+    UrlParams["USER"] = "u";
+    UrlParams["EXTENSION"] = "e";
+    UrlParams["REFERRER"] = "r";
+    UrlParams["AUTHORIZE"] = "a";
+    UrlParams["START_PAGE"] = "sp";
+})(UrlParams || (exports.UrlParams = UrlParams = {}));
+var StartPage;
+(function (StartPage) {
+    StartPage["CREATE_CONTACT"] = "createContact";
+})(StartPage || (exports.StartPage = StartPage = {}));

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../enums");
+const getUrlSearchParamsMap_1 = require("../utils/url/getUrlSearchParamsMap");
+class ClientParams {
+    static instance = null;
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new ClientParams();
+        }
+        return this.instance;
+    }
+    userToken;
+    userEmail;
+    referrer;
+    needAuthorize;
+    iframeId;
+    variant = null;
+    userExtension = null;
+    startPage = null;
+    constructor() {
+        const params = (0, getUrlSearchParamsMap_1.getUrlSearchParamsMap)();
+        this.iframeId = params.get(enums_1.UrlParams.ID);
+        this.variant = params.get(enums_1.UrlParams.VARIANT);
+        this.userEmail = params.get(enums_1.UrlParams.USER);
+        this.userExtension = params.get(enums_1.UrlParams.EXTENSION);
+        this.userToken = params.get(enums_1.UrlParams.TOKEN);
+        this.referrer = params.get(enums_1.UrlParams.REFERRER);
+        this.needAuthorize = params.has(enums_1.UrlParams.AUTHORIZE);
+        this.startPage = params.get(enums_1.UrlParams.START_PAGE);
+    }
+    toString() {
+        const { userToken, ...props } = this;
+        return JSON.stringify({ ...props, userToken: userToken && `...${userToken.slice(-5)}` });
+    }
+}
+exports.default = ClientParams;