@wildix/xbees-connect 1.3.4 → 1.3.5

package/dist-es/src/Client.js

@@ -0,0 +1,485 @@
+import packageJson from '../package.json';
+import { SupportedPlatformVariant, } from '../types';
+import { ClientEventType, EventType, UrlParams } from './enums';
+import LocalStorageManager from './helpers/LocalStorageManager';
+import { MessageListener } from './helpers/MessageListener';
+import PostMessageControllerNative from './helpers/PostMessageControllerNative';
+import PostMessageControllerWeb from './helpers/PostMessageControllerWeb';
+import TechnicalSupport from './helpers/TechnicalSupport';
+import { getUrlSearchParamsMap } from './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()
+ * */
+export 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.getInstance();
+    constructor() {
+        const params = getUrlSearchParamsMap();
+        this.iframeId = params.get(UrlParams.ID);
+        this.variant = params.get(UrlParams.VARIANT);
+        this.userEmail = params.get(UrlParams.USER);
+        this.referrer = params.get(UrlParams.REFERRER);
+        this.needAuthorize = params.has(UrlParams.AUTHORIZE);
+        this.startPage = params.get(UrlParams.START_PAGE);
+        // @ts-expect-error window.ReactNativeWebView will be provided by ReactNative WebView
+        this.isParentReactNativeWebView = !!window.ReactNativeWebView;
+        this.worker = this.isParentReactNativeWebView ? new PostMessageControllerNative() : new PostMessageControllerWeb();
+        this.addEventListener(EventType.PBX_TOKEN, (token) => {
+            this.userToken = token;
+        });
+        this.addEventListener(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.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 === 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 = SupportedPlatformVariant.ALL) {
+        const payload = typeof props === 'string'
+            ? { version: this.version(), platform: props }
+            : { version: this.version(), ...props, platform: props.platform ?? SupportedPlatformVariant.ALL };
+        this.getXBeesUser();
+        return this.sendAsync({
+            type: ClientEventType.READY,
+            payload,
+        });
+    }
+    async requestXbeesUser() {
+        const responseMessageUser = await this.sendAsync({ type: 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 packageJson.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: ClientEventType.CONTEXT });
+    }
+    getCurrentContact() {
+        return this.sendAsync({ type: ClientEventType.CURRENT_CONTACT });
+    }
+    getCurrentConversation() {
+        return this.sendAsync({ type: ClientEventType.CURRENT_CONVERSATION });
+    }
+    getAvailableContactData() {
+        return this.sendAsync({ type: ClientEventType.AVAILABLE_CONTACT_DATA });
+    }
+    contactUpdated(query, contact) {
+        return this.sendAsync({ type: ClientEventType.CONTACT_CREATE_OR_UPDATE, payload: { query, contact } });
+    }
+    contactMatchUpdated(query, contact) {
+        return this.sendAsync({ type: ClientEventType.CONTACT_MATCH_UPDATE, payload: { query, contact } });
+    }
+    getThemeMode() {
+        return this.sendAsync({ type: ClientEventType.THEME_MODE });
+    }
+    getTheme() {
+        return this.sendAsync({ type: ClientEventType.THEME });
+    }
+    startCall(phoneNumber) {
+        return this.sendAsync({
+            type: ClientEventType.START_CALL,
+            payload: { phoneNumber },
+        });
+    }
+    reboot() {
+        return this.sendAsync({ type: ClientEventType.REBOOT });
+    }
+    setViewport(payload) {
+        return this.sendAsync({ type: ClientEventType.VIEW_PORT, payload });
+    }
+    toClipboard(payload) {
+        return this.sendAsync({ type: ClientEventType.TO_CLIPBOARD, payload });
+    }
+    showToast(message, severity = 'INFO') {
+        return this.sendAsync({ type: ClientEventType.TOAST, payload: { message, severity } });
+    }
+    isNotAuthorized() {
+        return this.sendAsync({ type: ClientEventType.NOT_AUTHORIZED });
+    }
+    isAuthorized() {
+        this.sendDailyIntegrationUsageAnalytics();
+        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);
+        };
+    }
+    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(EventType.REDIRECT_QUERY, callback);
+    }
+    onCallEnded(callback) {
+        return this.addEventListener(EventType.TERMINATE_CALL, callback);
+    }
+    onCallStarted(callback) {
+        return this.addEventListener(EventType.ADD_CALL, callback);
+    }
+    onPbxTokenChange(callback) {
+        return this.addEventListener(EventType.PBX_TOKEN, callback);
+    }
+    getXBeesToken() {
+        return this.sendAsync({ type: ClientEventType.TOKEN });
+    }
+    onSuggestContacts(callback) {
+        // send event to x-bees
+        void this.sendAsyncErrorSafe({
+            type: ClientEventType.CONTACTS_AUTO_SUGGEST_IS_SUPPORTED,
+        });
+        return this.addEventListener(EventType.GET_CONTACTS_AUTO_SUGGEST, (query) => {
+            const resolve = (contacts) => this.sendAsync({
+                type: 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: ClientEventType.CONTACT_LOOK_UP_AND_MATCH_IS_SUPPORTED,
+        });
+        return this.addEventListener(EventType.GET_LOOK_UP_AND_MATCH, (query) => {
+            const resolve = (contact) => this.sendAsync({
+                type: ClientEventType.CONTACT_LOOKUP_AND_MATCH,
+                payload: {
+                    contact,
+                    query,
+                },
+            });
+            const reject = (reason) => {
+                console.debug(reason);
+                void this.sendAsync({
+                    type: 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: ClientEventType.LOOK_UP_AND_MATCH_BATCH_CONTACTS_IS_SUPPORTED,
+        });
+        return this.addEventListener(EventType.GET_LOOK_UP_AND_MATCH_BATCH, (queries) => {
+            const returnResults = (contactResultsMap) => this.sendAsync({
+                type: ClientEventType.LOOK_UP_AND_MATCH_BATCH_CONTACTS,
+                payload: {
+                    contactResultsMap: Array.from(contactResultsMap),
+                },
+            });
+            const reject = (reason) => {
+                console.debug(reason);
+                void this.sendAsync({
+                    type: ClientEventType.LOOKUP_AND_MATCH_BATCH_ERROR,
+                    payload: { reason },
+                });
+            };
+            try {
+                callback(queries, returnResults);
+            }
+            catch (error) {
+                reject(`${error}`);
+            }
+        });
+    }
+    createContactIsSupported() {
+        return this.sendAsync({
+            type: ClientEventType.CREATE_CONTACT_IS_SUPPORTED,
+        });
+    }
+    createContactHasNoPermission() {
+        return this.sendAsync({
+            type: ClientEventType.CREATE_CONTACT_HAS_NO_PERMISSION,
+        });
+    }
+    onThemeChange(callback) {
+        return this.addEventListener(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: ClientEventType.LOGOUT_IS_SUPPORTED,
+        });
+        return this.addEventListener(EventType.LOGOUT, callback);
+    }
+    sendAnalytics(eventName, params) {
+        void this.sendAsync({
+            type: ClientEventType.SEND_ANALYTICS,
+            payload: {
+                eventName,
+                params,
+            },
+        });
+    }
+    setIntegrationStorageKey(integrationKey) {
+        this.localStorageManager.setIntegrationKey(integrationKey);
+    }
+    getTechnicalSupport() {
+        return TechnicalSupport.getInstance();
+    }
+    onVisibilityChange(callback) {
+        return this.addEventListener(EventType.VISIBILITY, callback);
+    }
+    saveInXbeesStorage(key, value) {
+        void this.sendAsync({
+            type: ClientEventType.SAVE_TO_STORAGE,
+            payload: {
+                key,
+                value: typeof value === 'string' ? value : JSON.stringify(value),
+            },
+        });
+    }
+    getFromXbeesStorage(key) {
+        return this.sendAsync({
+            type: ClientEventType.GET_FROM_STORAGE,
+            payload: { key },
+        });
+    }
+    removeFromXbeesStorage(key) {
+        void this.sendAsync({
+            type: ClientEventType.REMOVE_FROM_STORAGE,
+            payload: { key },
+        });
+    }
+    /** should be removed, sendCustomEvent is enough **/
+    sendDropdownVisibilityEvent(dropdownVisibilityStatus) {
+        void this.sendAsync({
+            type: ClientEventType.DROPDOWN_VISIBILITY,
+            payload: { dropdownVisibilityStatus },
+        });
+    }
+    sendCustomEvent({ type, payload }) {
+        void this.sendAsync({
+            type: ClientEventType.CUSTOM_EVENT,
+            payload: { type, payload },
+        });
+    }
+    onContactWeightUpdate(callback) {
+        return this.addEventListener(EventType.CONTACT_WEIGHT_UPDATE, callback);
+    }
+    onContactRefresh(callback) {
+        return this.addEventListener(EventType.CONTACT_REFRESH, callback);
+    }
+    onStartRedirectToEntityPage(callback) {
+        return this.addEventListener(EventType.START_REDIRECT_TO_ENTITY_PAGE, callback);
+    }
+    onCancelRedirectToEntityPage(callback) {
+        return this.addEventListener(EventType.CANCEL_REDIRECT_TO_ENTITY_PAGE, callback);
+    }
+}

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

@@ -0,0 +1,71 @@
+export 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 || (EventType = {}));
+export 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 || (ClientEventType = {}));
+export 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 || (UrlParams = {}));
+export var StartPage;
+(function (StartPage) {
+    StartPage["CREATE_CONTACT"] = "createContact";
+})(StartPage || (StartPage = {}));

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

@@ -0,0 +1,34 @@
+import { UrlParams } from '../enums';
+import { getUrlSearchParamsMap } from '../utils/url/getUrlSearchParamsMap';
+export default 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 = getUrlSearchParamsMap();
+        this.iframeId = params.get(UrlParams.ID);
+        this.variant = params.get(UrlParams.VARIANT);
+        this.userEmail = params.get(UrlParams.USER);
+        this.userExtension = params.get(UrlParams.EXTENSION);
+        this.userToken = params.get(UrlParams.TOKEN);
+        this.referrer = params.get(UrlParams.REFERRER);
+        this.needAuthorize = params.has(UrlParams.AUTHORIZE);
+        this.startPage = params.get(UrlParams.START_PAGE);
+    }
+    toString() {
+        const { userToken, ...props } = this;
+        return JSON.stringify({ ...props, userToken: userToken && `...${userToken.slice(-5)}` });
+    }
+}

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

@@ -0,0 +1,72 @@
+class LocalStorageManager {
+    static instance = null;
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new LocalStorageManager();
+        }
+        return this.instance;
+    }
+    listeners = new Set();
+    integrationKey = '';
+    setIntegrationKey(integrationKey) {
+        this.integrationKey = integrationKey;
+    }
+    getStorageKey(key) {
+        return !this.integrationKey ? key : `${this.integrationKey}_${key}`;
+    }
+    getKey(key) {
+        return !this.integrationKey ? key : key.slice(`${this.integrationKey}_`.length);
+    }
+    constructor() {
+        if (this.shouldUseIntegrationKey()) {
+            this.integrationKey = this.calculateIntegrationKey();
+        }
+        window.addEventListener('storage', (event) => {
+            if (!event.key)
+                return;
+            const key = this.getKey(event.key);
+            this.listeners.forEach((listener) => listener({ ...event, key }));
+        });
+    }
+    calculateIntegrationKey() {
+        const pattern = /^\/(\S+)?\/index\.html$/;
+        const match = window.location.pathname.match(pattern);
+        if (match && match[1]) {
+            const [, key] = match;
+            return key;
+        }
+        return '';
+    }
+    shouldUseIntegrationKey() {
+        return window.location.host.endsWith('integrations.x-bees.com');
+    }
+    save(key, value) {
+        // Save data to localStorage
+        localStorage.setItem(this.getStorageKey(key), typeof value === 'string' ? value : JSON.stringify(value));
+    }
+    delete(key) {
+        // Save data to localStorage
+        localStorage.removeItem(this.getStorageKey(key));
+    }
+    retrieve(key) {
+        // Retrieve data from localStorage
+        const data = localStorage.getItem(this.getStorageKey(key));
+        try {
+            return !data ? data : JSON.parse(data);
+        }
+        catch (error) {
+            return data;
+        }
+    }
+    get(key) {
+        return localStorage.getItem(this.getStorageKey(key));
+    }
+    onStorage(listener) {
+        this.listeners.add(listener);
+        return () => this.removeOnStorage(listener);
+    }
+    removeOnStorage(listener) {
+        this.listeners.delete(listener);
+    }
+}
+export default LocalStorageManager;