@regantis-sdk/react-native-chat 0.1.0

package/src/client.js

@@ -0,0 +1,630 @@
+'use strict';
+
+const { Platform } = require('react-native');
+const native = require('./native');
+const { DEFAULT_SERVER_URL, DEFAULT_SETTINGS, SDK_VERSION } = require('./defaults');
+
+function normalizeServerUrl(value) {
+  return String(value || DEFAULT_SERVER_URL).trim().replace(/\/+$/, '');
+}
+
+function normalizeLanguage(value) {
+  const code = String(value || 'en').trim().toLowerCase().replace('_', '-').split('-')[0];
+  return /^[a-z]{2,3}$/.test(code) ? code : 'en';
+}
+
+function mergeMessages(current, incoming) {
+  const map = new Map();
+  [...(current || []), ...(incoming || [])].forEach(message => {
+    const id = Number(message && message.chat_message_id) || 0;
+    if (id > 0) map.set(id, message);
+  });
+  return Array.from(map.values()).sort((a, b) => Number(a.chat_message_id) - Number(b.chat_message_id));
+}
+
+function isSupportMessage(message) {
+  const type = String(message && message.sender_type || '').toLowerCase();
+  return type === 'agent' || type === 'admin' || type === 'chatbot';
+}
+
+function timezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || '';
+  } catch (_) {
+    return '';
+  }
+}
+
+function normalizeSettings(value) {
+  const settings = { ...DEFAULT_SETTINGS, ...(value || {}) };
+  [
+    'use_profile_names',
+    'chat_background_opacity',
+    'desktop_side_spacing',
+    'desktop_bottom_spacing',
+    'mobile_enabled',
+    'mobile_same_as_desktop',
+    'mobile_side_spacing',
+    'mobile_bottom_spacing',
+    'show_logo',
+    'show_agent_photo',
+    'sound_enabled',
+    'rating_enabled',
+    'transcript_enabled',
+    'before_you_go_enabled',
+    'white_label',
+  ].forEach(key => {
+    if (settings[key] !== undefined && settings[key] !== null && settings[key] !== '') settings[key] = Number(settings[key]);
+  });
+  return settings;
+}
+
+class RegantisChatClient {
+  constructor(config) {
+    config = config || {};
+    if (!/^[a-f0-9]{64}$/i.test(String(config.apiKey || ''))) {
+      throw new Error('RegantisChat requires a valid apiKey');
+    }
+
+    this.options = {
+      apiKey: String(config.apiKey).toLowerCase(),
+      serverUrl: normalizeServerUrl(config.serverUrl),
+      language: normalizeLanguage(config.language),
+      translationLanguage: String(config.translationLanguage || ''),
+      screen: String(config.screen || 'chat'),
+      customer: config.customer || null,
+      theme: config.theme || null,
+      texts: config.texts || null,
+      onMessage: typeof config.onMessage === 'function' ? config.onMessage : null,
+      onUnreadChange: typeof config.onUnreadChange === 'function' ? config.onUnreadChange : null,
+      onError: typeof config.onError === 'function' ? config.onError : null,
+    };
+
+    this.listeners = new Set();
+    this.appInfo = { appId: '', appVersion: '', platform: Platform.OS };
+    this.ws = null;
+    this.wsReady = false;
+    this.wsReconnectTimer = null;
+    this.wsBackoff = 1000;
+    this.pollingTimer = null;
+    this.typingTimer = null;
+    this.destroyed = false;
+    this.syncing = false;
+    this.visible = true;
+    this.pageInstanceId = `${Platform.OS}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+
+    this.state = {
+      loading: true,
+      initialized: false,
+      error: '',
+      banned: false,
+      config: null,
+      settings: { ...DEFAULT_SETTINGS },
+      texts: {},
+      languages: [],
+      translationCustomerEnabled: false,
+      visitorKey: '',
+      conversation: {
+        conversation_id: 0,
+        status: 1,
+        contact_name: '',
+        contact_email: '',
+        contact_confirmed: 0,
+        translation_language_code: '',
+        routing_mode: '',
+        feedback_submitted: false,
+      },
+      messages: [],
+      hasMore: false,
+      upload: null,
+      realtime: null,
+      realtimeConnected: false,
+      remoteTyping: '',
+      sending: false,
+      uploading: false,
+      unread: 0,
+      customerDataProvided: false,
+    };
+  }
+
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.state);
+    return () => this.listeners.delete(listener);
+  }
+
+  getState() {
+    return this.state;
+  }
+
+  setState(patch) {
+    if (this.destroyed) return;
+    this.state = { ...this.state, ...patch };
+    this.listeners.forEach(listener => listener(this.state));
+  }
+
+  emitError(error) {
+    const message = error && error.message ? error.message : String(error || 'UNKNOWN_ERROR');
+    if (this.options.onError) this.options.onError(error);
+    return message;
+  }
+
+  storageKey() {
+    return `regantis_chat_visitor_${this.options.apiKey}`;
+  }
+
+  async start() {
+    this.destroyed = false;
+    this.setState({ loading: true, error: '' });
+
+    try {
+      this.appInfo = await native.getAppInfo();
+      await this.loadConfig();
+      const visitorKey = String(await native.getItem(this.storageKey()) || '').toLowerCase();
+      await this.initialize(visitorKey);
+      this.setState({ loading: false, initialized: true });
+      this.connectRealtime();
+      this.startPolling();
+      return this.state;
+    } catch (error) {
+      const message = this.emitError(error);
+      this.setState({ loading: false, error: message });
+      throw error;
+    }
+  }
+
+  stop() {
+    this.destroyed = true;
+    this.disconnectRealtime();
+    this.stopPolling();
+    if (this.typingTimer) clearTimeout(this.typingTimer);
+    this.listeners.clear();
+  }
+
+  setVisible(visible) {
+    this.visible = !!visible;
+    if (this.visible) {
+      this.markRead().catch(() => {});
+      this.syncHistory().catch(() => {});
+    }
+  }
+
+  setSoundEnabled(enabled) {
+    this.setState({ settings: { ...this.state.settings, sound_enabled: enabled ? 1 : 0 } });
+  }
+
+  async loadConfig() {
+    const url = `${this.options.serverUrl}/chat/widget/sdkConfig?key=${encodeURIComponent(this.options.apiKey)}&lang=${encodeURIComponent(this.options.language)}`;
+    const response = await fetch(url, { method: 'GET', headers: { Accept: 'application/json' } });
+    const data = await this.readJson(response);
+    if (!response.ok || !data.success) throw new Error(data.error || `HTTP_${response.status}`);
+
+    const settings = normalizeSettings({ ...(data.settings || {}), ...(this.options.theme || {}) });
+    const texts = { ...(data.texts || {}), ...(this.options.texts || {}) };
+    this.setState({
+      config: data,
+      settings,
+      texts,
+      languages: Array.isArray(data.languages) ? data.languages : [],
+      translationCustomerEnabled: Number(data.translation_customer_enabled || 0) === 1,
+    });
+    return data;
+  }
+
+  basePayload(extra) {
+    const payload = {
+      sdk_key: this.options.apiKey,
+      sdk_platform: Platform.OS,
+      sdk_version: SDK_VERSION,
+      app_id: String(this.appInfo.appId || ''),
+      app_version: String(this.appInfo.appVersion || ''),
+      screen: this.options.screen,
+      browser_language: this.options.language,
+      timezone: timezone(),
+      visitor_key: this.state.visitorKey,
+      page_instance_id: this.pageInstanceId,
+      ...(extra || {}),
+    };
+
+    const customer = this.options.customer || {};
+    if (customer.id || customer.customerId) payload.customer_id = String(customer.id || customer.customerId || '');
+    if (customer.name) payload.customer_name = String(customer.name);
+    if (customer.email) payload.customer_email = String(customer.email);
+    if (customer.telephone || customer.phone) payload.customer_telephone = String(customer.telephone || customer.phone);
+    if (customer.identityTimestamp) payload.customer_identity_timestamp = String(customer.identityTimestamp);
+    if (customer.identitySignature) payload.customer_identity_signature = String(customer.identitySignature);
+    return payload;
+  }
+
+  async request(endpoint, extra) {
+    const api = this.state.config && this.state.config.api;
+    const url = api && api[endpoint];
+    if (!url) throw new Error(`INVALID_ENDPOINT_${endpoint}`);
+
+    const body = new FormData();
+    const payload = this.basePayload(extra);
+    Object.keys(payload).forEach(key => {
+      const value = payload[key];
+      if (value !== undefined && value !== null) body.append(key, String(value));
+    });
+
+    const response = await fetch(url, { method: 'POST', body, headers: { Accept: 'application/json' } });
+    const data = await this.readJson(response);
+    if (!response.ok || !data.success) {
+      const error = new Error(data.error || `HTTP_${response.status}`);
+      error.code = data.error || '';
+      error.status = response.status;
+      if (error.code === 'BANNED') this.setState({ banned: true });
+      throw error;
+    }
+    return data;
+  }
+
+  async readJson(response) {
+    const text = await response.text();
+    try {
+      return text ? JSON.parse(text) : {};
+    } catch (_) {
+      throw new Error(`INVALID_SERVER_RESPONSE_${response.status}`);
+    }
+  }
+
+  async initialize(visitorKey) {
+    this.state.visitorKey = /^[a-f0-9]{64}$/.test(visitorKey || '') ? visitorKey : '';
+    let data = await this.request('initialize');
+
+    if (data.reset_visitor_key) {
+      await native.removeItem(this.storageKey());
+      this.state.visitorKey = '';
+      data = await this.request('initialize');
+    }
+
+    if (data.visitor_key) {
+      await native.setItem(this.storageKey(), data.visitor_key);
+    }
+
+    const messages = Array.isArray(data.messages) ? data.messages : [];
+    const conversation = data.conversation || this.state.conversation;
+    const patch = {
+      visitorKey: String(data.visitor_key || this.state.visitorKey || ''),
+      conversation,
+      messages,
+      hasMore: !!data.has_more,
+      upload: data.upload || null,
+      realtime: data.realtime || null,
+      customerDataProvided: !!data.customer_data_provided,
+      banned: false,
+    };
+    this.setState(patch);
+
+    if (!conversation.translation_language_code && this.options.translationLanguage && this.state.translationCustomerEnabled && Number(conversation.conversation_id || 0) > 0) {
+      await this.setTranslationLanguage(this.options.translationLanguage).catch(() => {});
+    }
+  }
+
+  async syncHistory() {
+    if (this.syncing || !this.state.visitorKey || Number(this.state.conversation.conversation_id || 0) < 1) return;
+    this.syncing = true;
+    try {
+      const last = this.state.messages.length ? this.state.messages[this.state.messages.length - 1] : null;
+      const afterId = Number(last && last.chat_message_id) || 0;
+      const data = await this.request('history', afterId ? { after_id: afterId } : {});
+      const incoming = Array.isArray(data.messages) ? data.messages : [];
+      const previousIds = new Set(this.state.messages.map(item => Number(item.chat_message_id)));
+      const newSupport = incoming.filter(item => !previousIds.has(Number(item.chat_message_id)) && isSupportMessage(item));
+      const messages = mergeMessages(this.state.messages, incoming);
+      const conversation = data.conversation || this.state.conversation;
+      let unread = this.state.unread;
+
+      if (newSupport.length) {
+        newSupport.forEach(message => this.options.onMessage && this.options.onMessage(message));
+        if (Number(this.state.settings.sound_enabled || 0) === 1) native.playIncomingSound();
+        if (!this.visible) unread += newSupport.length;
+      }
+
+      this.setState({ messages, conversation, hasMore: !!data.has_more, unread, customerDataProvided: !!data.customer_data_provided });
+      this.notifyUnread();
+      if (this.visible && newSupport.length) await this.markRead().catch(() => {});
+    } catch (error) {
+      if (error.code === 'CONVERSATION_NOT_FOUND') return;
+      this.emitError(error);
+    } finally {
+      this.syncing = false;
+    }
+  }
+
+  async loadOlder() {
+    if (!this.state.hasMore || !this.state.messages.length) return;
+    const firstId = Number(this.state.messages[0].chat_message_id) || 0;
+    const data = await this.request('history', { before_id: firstId });
+    this.setState({
+      messages: mergeMessages(data.messages || [], this.state.messages),
+      hasMore: !!data.has_more,
+      conversation: data.conversation || this.state.conversation,
+    });
+  }
+
+  async saveContact(name, email) {
+    const languageCode = this.state.conversation.translation_language_code || this.options.translationLanguage || '';
+    const data = await this.request('contact', { name, email, language_code: languageCode });
+    const messages = data.chatbot_message ? mergeMessages(this.state.messages, [data.chatbot_message]) : this.state.messages;
+    this.setState({
+      conversation: data.conversation || this.state.conversation,
+      customerDataProvided: !!data.customer_data_provided,
+      upload: data.upload || this.state.upload,
+      messages,
+    });
+    return data;
+  }
+
+  async sendMessage(message) {
+    message = String(message || '').trim();
+    if (!message || message.length > 5000 || this.state.sending) return null;
+    this.setState({ sending: true });
+    try {
+      const conversation = this.state.conversation || {};
+      const data = await this.request('send', {
+        message,
+        contact_name: conversation.contact_name || '',
+        contact_email: conversation.contact_email || '',
+        language_code: conversation.translation_language_code || '',
+      });
+      let messages = mergeMessages(this.state.messages, [data.welcome_message, data.message].filter(Boolean));
+      this.setState({
+        messages,
+        conversation: data.conversation || conversation,
+        upload: data.upload || this.state.upload,
+        realtime: data.realtime || this.state.realtime,
+        sending: false,
+      });
+      this.connectRealtime();
+      this.startPolling();
+      if (data.message && this.wsReady) this.sendRealtime({ type: 'message', roomId: this.roomId(), conversationId: this.conversationId(), messageId: Number(data.message.chat_message_id) });
+      if (Number(data.chatbot_enabled || 0) === 1 && data.message) this.requestChatbot(data.message.chat_message_id);
+      return data.message;
+    } catch (error) {
+      this.setState({ sending: false });
+      throw error;
+    }
+  }
+
+  async requestChatbot(messageId) {
+    this.setState({ remoteTyping: 'chatbot' });
+    try {
+      const data = await this.request('chatbot', { trigger_message_id: Number(messageId) });
+      if (data.message) {
+        const already = this.state.messages.some(item => Number(item.chat_message_id) === Number(data.message.chat_message_id));
+        if (!already) {
+          this.setState({ messages: mergeMessages(this.state.messages, [data.message]) });
+          if (this.options.onMessage) this.options.onMessage(data.message);
+          if (Number(this.state.settings.sound_enabled || 0) === 1) native.playIncomingSound();
+        }
+      }
+      if (data.handoff && data.handoff.routing_mode) {
+        this.setState({ conversation: { ...this.state.conversation, routing_mode: data.handoff.routing_mode } });
+      }
+    } catch (error) {
+      this.emitError(error);
+    } finally {
+      this.setState({ remoteTyping: '' });
+      this.syncHistory().catch(() => {});
+    }
+  }
+
+  async uploadAttachment(file, kind) {
+    if (!file || !file.uri || !this.state.upload || !this.state.upload.enabled || !this.state.upload.token) {
+      throw new Error('UPLOAD_UNAVAILABLE');
+    }
+    this.setState({ uploading: true });
+    try {
+      const body = new FormData();
+      body.append('upload_token', String(this.state.upload.token));
+      body.append('upload_type', kind === 'image' ? 'image' : 'file');
+      body.append('attachment', {
+        uri: file.uri,
+        name: file.name || (kind === 'image' ? 'image.jpg' : 'attachment'),
+        type: file.type || (kind === 'image' ? 'image/jpeg' : 'application/octet-stream'),
+      });
+      const response = await fetch(this.state.upload.url, { method: 'POST', body, headers: { Accept: 'application/json' } });
+      const data = await this.readJson(response);
+      if (!response.ok || !data.success) throw new Error(data.error || `HTTP_${response.status}`);
+      this.setState({ messages: mergeMessages(this.state.messages, data.message ? [data.message] : []), uploading: false });
+      if (data.message && this.wsReady) this.sendRealtime({ type: 'message', roomId: this.roomId(), conversationId: this.conversationId(), messageId: Number(data.message.chat_message_id) });
+      return data.message;
+    } catch (error) {
+      this.setState({ uploading: false });
+      throw error;
+    }
+  }
+
+  async pickAndUpload(kind) {
+    const type = kind === 'image' ? 'image' : 'file';
+    const file = kind === 'screenshot' ? await native.captureScreenshot() : await native.pickAttachment(type);
+    if (!file) return null;
+    return this.uploadAttachment(file, kind === 'screenshot' ? 'image' : type);
+  }
+
+  async setTranslationLanguage(languageCode) {
+    if (!this.state.translationCustomerEnabled || this.conversationId() < 1) return;
+    const data = await this.request('language', { language_code: String(languageCode || '') });
+    this.setState({ conversation: data.conversation || this.state.conversation, messages: Array.isArray(data.messages) ? data.messages : this.state.messages });
+    await this.reloadHistory();
+  }
+
+  async reloadHistory() {
+    if (this.conversationId() < 1) return;
+    const data = await this.request('history');
+    this.setState({ messages: data.messages || [], conversation: data.conversation || this.state.conversation, hasMore: !!data.has_more });
+  }
+
+  async closeChat() {
+    if (this.conversationId() < 1) return;
+    const data = await this.request('end');
+    this.setState({ conversation: data.conversation || this.state.conversation, upload: null });
+    this.disconnectRealtime();
+    return data;
+  }
+
+  async reopenChat() {
+    const c = this.state.conversation || {};
+    const data = await this.request('reopen', { name: c.contact_name || '', email: c.contact_email || '' });
+    this.setState({
+      conversation: data.conversation || c,
+      customerDataProvided: !!data.customer_data_provided,
+      upload: data.upload || null,
+      messages: data.chatbot_message ? mergeMessages(this.state.messages, [data.chatbot_message]) : this.state.messages,
+    });
+    await this.initialize(this.state.visitorKey);
+    this.connectRealtime();
+    return data;
+  }
+
+  async rate(rating) {
+    const data = await this.request('feedback', { action: 'rate', rating: Number(rating) === 1 ? '1' : '0' });
+    this.setState({ conversation: data.conversation || this.state.conversation, messages: data.message ? mergeMessages(this.state.messages, [data.message]) : this.state.messages });
+    return data;
+  }
+
+  async rateComment(comment) {
+    const data = await this.request('feedback', { action: 'comment', comment: String(comment || '') });
+    this.setState({ conversation: data.conversation || this.state.conversation, messages: data.message ? mergeMessages(this.state.messages, [data.message]) : this.state.messages });
+    return data;
+  }
+
+  sendTranscript(email) {
+    return this.request('transcript', { email: String(email || '') });
+  }
+
+  async markRead() {
+    if (this.conversationId() < 1) return;
+    const data = await this.request('read');
+    if (this.wsReady) this.sendRealtime({ type: 'read', roomId: this.roomId(), conversationId: this.conversationId(), messageId: Number(data.message_id || 0) });
+    if (this.state.unread !== 0) {
+      this.setState({ unread: 0 });
+      this.notifyUnread();
+    }
+  }
+
+  notifyUnread() {
+    if (this.options.onUnreadChange) this.options.onUnreadChange(this.state.unread);
+  }
+
+  conversationId() {
+    return Number(this.state.conversation && this.state.conversation.conversation_id) || 0;
+  }
+
+  roomId() {
+    return this.state.realtime && this.state.realtime.room_id || '';
+  }
+
+  connectRealtime() {
+    const realtime = this.state.realtime;
+    if (this.destroyed || Number(this.state.conversation.status || 0) !== 1 || !realtime || !realtime.enabled || !realtime.url || !realtime.token || this.conversationId() < 1) return;
+    if (this.ws && (this.ws.readyState === 0 || this.ws.readyState === 1)) return;
+
+    const separator = String(realtime.url).includes('?') ? '&' : '?';
+    try {
+      this.ws = new WebSocket(`${realtime.url}${separator}token=${encodeURIComponent(realtime.token)}`);
+    } catch (_) {
+      this.scheduleReconnect();
+      return;
+    }
+
+    this.ws.onopen = () => {
+      this.wsReady = true;
+      this.wsBackoff = 1000;
+      this.setState({ realtimeConnected: true });
+      this.sendRealtime({ type: 'join', roomId: this.roomId() });
+      this.startPolling();
+    };
+
+    this.ws.onmessage = event => {
+      let payload;
+      try { payload = JSON.parse(event.data); } catch (_) { return; }
+      this.handleRealtime(payload);
+    };
+
+    this.ws.onclose = () => {
+      this.wsReady = false;
+      this.setState({ realtimeConnected: false });
+      this.startPolling();
+      this.scheduleReconnect();
+    };
+
+    this.ws.onerror = () => {};
+  }
+
+  disconnectRealtime() {
+    if (this.wsReconnectTimer) clearTimeout(this.wsReconnectTimer);
+    this.wsReconnectTimer = null;
+    this.wsReady = false;
+    if (this.ws) {
+      try { this.ws.close(1000, 'SDK closed'); } catch (_) {}
+    }
+    this.ws = null;
+    if (!this.destroyed) this.setState({ realtimeConnected: false });
+  }
+
+  scheduleReconnect() {
+    if (this.destroyed || Number(this.state.conversation.status || 0) !== 1 || this.wsReconnectTimer || this.conversationId() < 1) return;
+    const delay = Math.min(this.wsBackoff, 20000);
+    this.wsBackoff = Math.min(this.wsBackoff * 2, 20000);
+    this.wsReconnectTimer = setTimeout(() => {
+      this.wsReconnectTimer = null;
+      this.connectRealtime();
+    }, delay);
+  }
+
+  sendRealtime(payload) {
+    if (!this.wsReady || !this.ws || this.ws.readyState !== 1) return false;
+    try {
+      this.ws.send(JSON.stringify(payload));
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+
+  sendTyping(text) {
+    const value = String(text || '');
+    if (this.conversationId() < 1) return;
+    this.sendRealtime({ type: 'typing', roomId: this.roomId(), conversationId: this.conversationId(), isTyping: value.trim().length > 0, draftText: value.slice(0, 5000) });
+    if (this.typingTimer) clearTimeout(this.typingTimer);
+    if (value.trim()) {
+      this.typingTimer = setTimeout(() => this.sendRealtime({ type: 'typing', roomId: this.roomId(), conversationId: this.conversationId(), isTyping: false, draftText: '' }), 1800);
+    }
+  }
+
+  handleRealtime(payload) {
+    if (!payload || typeof payload !== 'object') return;
+    if (payload.type === 'message' || payload.type === 'conversation') {
+      this.syncHistory().catch(() => {});
+      return;
+    }
+    if (payload.type === 'typing') {
+      const role = String(payload.senderRole || payload.senderType || '').toLowerCase();
+      if (role === 'agent' || role === 'admin' || role === 'chatbot') {
+        this.setState({ remoteTyping: payload.isTyping ? role : '' });
+        if (payload.isTyping && role !== 'chatbot') {
+          setTimeout(() => {
+            if (this.state.remoteTyping === role) this.setState({ remoteTyping: '' });
+          }, 4000);
+        }
+      }
+    }
+  }
+
+  startPolling() {
+    this.stopPolling();
+    if (this.destroyed || Number(this.state.conversation.status || 0) !== 1 || this.conversationId() < 1) return;
+    const delay = this.wsReady ? 60000 : 8000;
+    this.pollingTimer = setInterval(() => this.syncHistory().catch(() => {}), delay);
+  }
+
+  stopPolling() {
+    if (this.pollingTimer) clearInterval(this.pollingTimer);
+    this.pollingTimer = null;
+  }
+}
+
+module.exports = { RegantisChatClient };

package/src/defaults.js

@@ -0,0 +1,43 @@
+'use strict';
+
+module.exports = {
+  DEFAULT_SERVER_URL: 'https://www.crm.regantis.technology',
+  SDK_VERSION: '0.1.0',
+  DEFAULT_SETTINGS: {
+    operator_name: 'Operator',
+    use_profile_names: 0,
+    minimized_type: 'bubble',
+    theme_mode: 'light',
+    color_mode: 'theme',
+    theme_color: '#0B63E5',
+    launcher_background: '#0B63E5',
+    launcher_icon_color: '#FFFFFF',
+    chat_background: '#F5F7FB',
+    chat_background_opacity: 100,
+    primary_color: '#0B63E5',
+    customer_bubble: '#0B63E5',
+    customer_text: '#FFFFFF',
+    agent_bubble: '#FFFFFF',
+    agent_text: '#17181B',
+    system_text: '#6F7480',
+    desktop_align: 'right',
+    desktop_side_spacing: 20,
+    desktop_bottom_spacing: 20,
+    desktop_visibility: 'always',
+    mobile_enabled: 1,
+    mobile_same_as_desktop: 1,
+    mobile_minimized_type: 'bubble',
+    mobile_align: 'right',
+    mobile_side_spacing: 0,
+    mobile_bottom_spacing: 0,
+    mobile_visibility: 'always',
+    show_logo: 1,
+    logo_url: '',
+    show_agent_photo: 1,
+    sound_enabled: 1,
+    rating_enabled: 1,
+    transcript_enabled: 1,
+    before_you_go_enabled: 0,
+    white_label: 0,
+  },
+};