@subiz/widget-v4 4.1.142 → 4.1.144

package/compiled_src/store/store.js

@@ -0,0 +1,1255 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _index = _interopRequireDefault(require("../util/index.js"));
+var _api = _interopRequireDefault(require("./api.js"));
+var _lsdb = _interopRequireDefault(require("./lsdb.js"));
+var _chain = _interopRequireDefault(require("./chain.js"));
+var _kv = _interopRequireDefault(require("./kv.js"));
+var _api_fake = _interopRequireDefault(require("./api_fake.js"));
+var _realtime_fake = _interopRequireDefault(require("./realtime_fake.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var flow = require('@subiz/flow');
+var Realtime = require('@subiz/wsclient');
+var cookie = require('cookie_js');
+cookie.defaults.path = '/';
+cookie.expiresMultiplier = 60 * 60 * 24;
+cookie.defaults.expires = 3650;
+const MAX_CONVO = 20;
+const page_loaded = _index.default.Date.now();
+class Store {
+  constructor(ApiURL, FileURL, RealtimeURL, inmem, fakeapi) {
+    _defineProperty(this, "inmem", false);
+    _defineProperty(this, "cookie", cookie);
+    _defineProperty(this, "getConnectionStatus", () => this.connectionStatus);
+    _defineProperty(this, "_currentViewingProduct", {});
+    _defineProperty(this, "new_visitor", true);
+    _defineProperty(this, "matchUser", () => {
+      this._touchAcc();
+      return this.cache.match('user');
+    });
+    _defineProperty(this, "suggest_addresses", keyword => this.api.suggest_address(keyword));
+    _defineProperty(this, "matchAccount", () => this.cache.match('account'));
+    _defineProperty(this, "matchPaymentMethods", () => this.cache.match('payment_methods'));
+    _defineProperty(this, "matchUnread", () => {
+      let user = this.matchUser();
+      let allconvos = this.matchConvo('*');
+      let unreadcount = 0;
+      _index.default.map(allconvos, convo => {
+        if (!_index.default.isConvoSeen(convo, user.id)) unreadcount++;
+      });
+      return unreadcount;
+    });
+    _defineProperty(this, "matchPlugin", () => {
+      if (_index.default.size(this.forcePlugins) > 0) return _index.default.cloneDeep(this.forcePlugins);
+      return _index.default.cloneDeep(this.cache.match('plugin')) || {};
+    });
+    _defineProperty(this, "device", {});
+    _defineProperty(this, "browserVisibility", 'visible');
+    _defineProperty(this, "matchAgent", id => {
+      let agentM = this.cache.match('agent') || {};
+      if (id === '*') return agentM;
+      return agentM[id];
+    });
+    _defineProperty(this, "matchConvo", id => {
+      if (!id) return;
+      if (id === '*') {
+        this._touchAcc();
+        return _index.default.filter(this.cache.all(), (value, k) => k.startsWith('convo_'));
+      }
+      if (!this.isInsync(id)) this.fetchConvo(id);
+      return this.cache.match('convo_' + id);
+    });
+    _defineProperty(this, "fetchConvo", async cid => {
+      if (this._die) return dieErr;
+      await this.readyGate.entry();
+      await this.reconnectGate.entry(undefined, true);
+      if (this.isInsync(cid)) return this.reconnectGate.open();
+      this.markSync(cid);
+      let {
+        body: convo,
+        error
+      } = await this.api.getConversation(cid);
+      if (convo && !error) this._setConvo(convo);
+      return this.reconnectGate.open();
+    });
+    _defineProperty(this, "list_provinces", () => this.api.list_provinces());
+    _defineProperty(this, "list_districts", p => this.api.list_districts(p));
+    _defineProperty(this, "list_wards", p => this.api.list_wards(p));
+    _defineProperty(this, "outofmsgM", {});
+    _defineProperty(this, "listEvents", id => {
+      if (!id || id === '*' || typeof id !== 'string') return;
+      return this.chain.listM(id);
+    });
+    _defineProperty(this, "fetchMoreEvents", async convoid => {
+      if (!this.isInsync('events' + convoid)) {
+        await this.readyGate.entry();
+        await this.reconnectGate.entry(undefined, true);
+        if (this.isInsync('events' + convoid)) {
+          this.reconnectGate.open();
+          return {};
+        }
+        this.markSync('events' + convoid);
+        await this.chain.reload(convoid, () => {
+          return [[], ''];
+        });
+        let out = await this._doFetchMsg(convoid);
+        this.reconnectGate.open();
+        return out;
+      }
+      return this._doFetchMsg(convoid);
+    });
+    _defineProperty(this, "_doFetchMsg", async convoid => {
+      let {
+        error
+      } = await this.chain.fetchMore(convoid, 150, async (type, anchor, limit) => {
+        if (this.outofmsgM[convoid]) return [[], ''];
+        let [events, newanchor, error, outofmsg] = await this.listmessageapi(type, anchor, limit);
+        if (outofmsg) this.outofmsgM[convoid] = true;
+        return [events, newanchor, error];
+      });
+      this.pubsub.publish('account');
+      return {
+        error
+      };
+    });
+    _defineProperty(this, "matchLocation", () => this.cache.match('location') || {});
+    _defineProperty(this, "matchBot", () => this.cache.match('bot') || {});
+    _defineProperty(this, "readyGate", new _index.default.Gate());
+    _defineProperty(this, "convoGate", new _index.default.Gate(true));
+    _defineProperty(this, "reconnectGate", new _index.default.Gate(true));
+    _defineProperty(this, "wsGate", new _index.default.Gate(true));
+    _defineProperty(this, "matchLastview", () => {
+      let lastView = this.kv.match('lastview') || {};
+      let user = this.cache.match('user') || {};
+      if (!user.id) return {};
+      if (lastView.user_id != user.id) return {};
+      return lastView;
+    });
+    _defineProperty(this, "matchIsOpen", () => !!this.kv.match('isopen'));
+    _defineProperty(this, "matchHasManuallyClosed", () => !!this.kv.match('hasManuallyClosed'));
+    _defineProperty(this, "matchClosePreviewAt", () => this.kv.match('close_preview_at') || 0);
+    _defineProperty(this, "checkFormToken", (accid, token) => this.api.checkFormToken(accid, token));
+    _defineProperty(this, "submitForm2", (accid, token, data) => this.api.submitForm2(accid, token, data));
+    _defineProperty(this, "sendPresence", _index.default.throttle(async () => {
+      if (this._die) return dieErr;
+      await this.readyGate.entry();
+      if (!_index.default.get(this.cache.match('user'), 'id')) return;
+      if (_index.default.isUserBanned(this.cache.match('user'))) return;
+      if (!this._track_page_view) return;
+      let hasfocus = this.browserVisibility === 'visible' && document.hasFocus();
+      if (!hasfocus) return this.api.sendLostFocus();
+      this.api.sendContentView(this.device, location.href, document.title, this._currentViewingProduct.id, this._currentViewingProduct.source_id, this._currentViewingProduct.sku);
+    }, 1000, {
+      leading: false
+    }));
+    _defineProperty(this, "now", () => _index.default.Date.now() + this.timeDiff);
+    _defineProperty(this, "seenQueue", []);
+    _defineProperty(this, "matchTrafficSource", () => this.kv.match('traffic_source'));
+    _defineProperty(this, "_alreadyReceived", {});
+    _defineProperty(this, "_typing", _index.default.throttle(convoid => this.api.sendTyping(convoid), 3000, {
+      trailing: false
+    }));
+    _defineProperty(this, "onConvoEvent", (o, cb) => this.pubsub.on2(o, 'events', cb));
+    _defineProperty(this, "onWidgetClose", (o, cb) => this.pubsub.on2(o, 'sbz_close_widget', cb));
+    _defineProperty(this, "seenConvo", id => {
+      if (!id || id === 'create') return;
+      this.seenQueue.push(id);
+    });
+    _defineProperty(this, "onUpdate", (o, cb) => this.pubsub.on2(o, 'account', cb));
+    _defineProperty(this, "onConnection", (o, cb) => this.pubsub.on2(o, 'connection', cb));
+    _defineProperty(this, "onResetCSS", (o, cb) => this.pubsub.on2(o, 'resetCSS', cb));
+    _defineProperty(this, "onHighlight", (o, cb) => this.pubsub.on2(o, 'highlight', cb));
+    _defineProperty(this, "setHasManuallyClosed", () => this.kv.put('hasManuallyClosed', true));
+    _defineProperty(this, "setIsOpen", isopen => {
+      let lastisopen = this.kv.match('isopen');
+      this.kv.put('isopen', isopen);
+      if (!lastisopen && isopen) {
+        sendEventToThirdParty('SUBIZ Chat', 'Opened', 'Subiz Windows');
+      }
+    });
+    _defineProperty(this, "closePreview", () => this.kv.put('close_preview_at', new _index.default.Date().getTime()));
+    _defineProperty(this, "setLastview", (view, opts) => {
+      let user = this.cache.match('user') || {};
+      if (!user.id) return;
+      this.kv.put('lastview', {
+        user_id: user.id,
+        view,
+        opts
+      });
+    });
+    _defineProperty(this, "timeDiff", 0);
+    this.connectionStatus = 'active';
+    this.CONNECTION_CHECK_INTERVAL = 3000;
+    this.reconnectTimestamp = 0;
+    this.g_sync = {};
+    this._die = false;
+    this.forceDevice = null;
+    this.forcePlugins = {};
+    this.forceAcc = {};
+    this.forceChatbox = {};
+    this.RealtimeURL = RealtimeURL;
+    this.fake = fakeapi;
+    this.FileURL = FileURL;
+    this._track_page_view = true;
+    this.device_type = 'desktop';
+    if (this.fake) this.api = new _api_fake.default(ApiURL, FileURL);else this.api = new _api.default(ApiURL, FileURL);
+    if (!inmem) {
+      try {
+        document.cookie;
+        localStorage;
+      } catch (e) {
+        inmem = true;
+      }
+    }
+    if (inmem) {
+      this.inmem = inmem;
+      this.cookie = inmemCookie;
+    }
+    cleanLocalStorage();
+    this.pubsub = new _index.default.Pubsub();
+    this.kv = new _kv.default(new _lsdb.default('sbz2023', this.inmem), 'kv');
+    this.cache = new _kv.default(new _lsdb.default('sbz2023', true), 'kv');
+    this.chain = new _chain.default(new _lsdb.default('cbz2023', true), 'ch');
+    this.getLocaleContent = this.api.getLocaleContent;
+    this.g_haveSentSeenM = {};
+    this.last_focused = _index.default.Date.now();
+    window.addEventListener('blur', () => {
+      this.last_focused = _index.default.Date.now();
+      this.sendPresence();
+    });
+    window.addEventListener('focus', () => {
+      this.last_focused = 0;
+      this.sendPresence();
+    });
+    window.addEventListener('beforeunload', () => this.api.sendLostFocus());
+    this.doNotStartBot = () => {
+      this._donotstartbot = true;
+    };
+    this.autoStartBot = () => {
+      this._donotstartbot = false;
+    };
+    this.matchAutoStartBot = () => !this._donotstartbot;
+    this._presenceInterval1 = _index.default.setInterval(() => {
+      if (this._die) return _index.default.clearInterval(this._presenceInterval1);
+      if (this.browserVisibility === 'visible' && document.hasFocus()) this.sendPresence();
+    }, 20000);
+    this._presenceInterval2 = _index.default.setInterval(() => {
+      if (this._die) return _index.default.clearInterval(this._presenceInterval2);
+      if (this.browserVisibility === 'visible' && document.hasFocus()) return;
+      if (this.last_focused && _index.default.Date.now() - this.last_focused > 30 * 60000) {
+        return;
+      }
+      this.sendPresence();
+    }, 60000);
+    onVisibilityChange(val => {
+      if (this._die) return;
+      this.browserVisibility = val;
+      this.sendPresence();
+    });
+    this.loopTime();
+    this.device = this.getDeviceInfo();
+    const _gaInterval = _index.default.setInterval(() => {
+      let user = this.cache.match('user') || {};
+      if (!user.id) return;
+      var dev = this.getDeviceInfo();
+      if (!dev.ga_tracking_ids || !dev.ga_client_id) return;
+      _index.default.clearInterval(_gaInterval);
+      this.device = dev;
+      let ga_client_id = dev.ga_client_id;
+      if (ga_client_id !== _index.default.getUserAttr(user, 'ga_client_id', 'text')) {
+        this.setUser({
+          attributes: [{
+            type: 'text',
+            text: ga_client_id,
+            key: 'ga_client_id'
+          }]
+        });
+      }
+    }, 2000);
+  }
+  async loopCheckConnectionStatus() {
+    while (true) {
+      if (this._die) break;
+      await _index.default.sleep(this.CONNECTION_CHECK_INTERVAL);
+      if (!this.realtime) continue;
+      if (!this.realtime.getStatus || !this.realtime.reconnect) continue;
+      if (this.connectionStatus === 'dead') {}
+      let currentStatus = this.connectionStatus;
+      this.connectionStatus = this.realtime.getStatus();
+      if (currentStatus !== this.connectionStatus) {
+        console.log('publish connectionStatus', this.connectionStatus);
+        this.pubsub.publish('connection');
+      }
+    }
+  }
+  linkProduct(p) {
+    if (!p) {
+      this._currentViewingProduct = {};
+      return;
+    }
+    if (p.id) this._currentViewingProduct.id = (p.id + '').trim();
+    if (p.source_id) this._currentViewingProduct.source_id = (p.source_id + '').trim();
+    if (p.sku) this._currentViewingProduct.sku = (p.sku + '').trim();
+  }
+  getTrackPageview() {
+    return this._track_page_view;
+  }
+  setTrackPageview(val) {
+    this._track_page_view = !!val;
+  }
+  getLinkedProduct() {
+    return _index.default.cloneDeep(this._currentViewingProduct);
+  }
+  isInsync(key) {
+    return _index.default.Date.now() - (this.g_sync[key] || 0) < 600000;
+  }
+  async fetchShippingAddresses() {
+    let out = await this.api.fetchShippingAddresses();
+    if (out.error) return null;
+    this.cache.put('shipping_address', out.body.shipping_addresses);
+  }
+  matchShippingAddresses() {
+    return this.cache.match('shipping_address');
+  }
+  updateOrder(order) {
+    return this.api.updateOrder(order);
+  }
+  createShippingAddress(addr) {
+    return this.api.createShippingAddress(addr);
+  }
+  createTicket(ticket) {
+    return this.api.create_ticket(ticket);
+  }
+  async overrideAcc(acc) {
+    this.forceAcc = _index.default.cloneDeep(acc);
+    await this.readyGate.entry();
+    this.reconnect();
+  }
+  async overrideChatbox(chatbox) {
+    this.forceChatbox = chatbox;
+    await this.readyGate.entry();
+    await this.reconnect();
+    _index.default.setTimeout(this.pubsub.publish('resetCSS'), 10);
+  }
+  getDeviceInfo() {
+    let device = {
+      screen_resolution: window.screen.width + 'x' + window.screen.height,
+      source_referrer: document.referrer,
+      platform: window.navigator.platform,
+      language: navigator.language,
+      page_url: document.URL,
+      page_title: document.title
+    };
+    let ga_client_id = getGaClientId();
+    if (ga_client_id) device.ga_client_id = ga_client_id;
+    let ga_tracking_ids = getGaTrackingIds();
+    if (ga_tracking_ids.length > 0) device.ga_tracking_ids = ga_tracking_ids;
+    return device;
+  }
+  highlight(pluginid, ref) {
+    this.pubsub.publish('highlight', pluginid, ref);
+  }
+  emitConvoEvent(ev) {
+    this.pubsub.publish('events', ev);
+  }
+  setAIDevMode(mode) {
+    this.ai_dev_mode = mode;
+  }
+  isAIDevMode() {
+    return this.ai_dev_mode;
+  }
+  overrideDeviceType(type) {
+    this.forceDevice = type;
+    this.pubsub.publish('account');
+  }
+  isMobile() {
+    if (this.forceDevice) return this.forceDevice === 'mobile';
+    return this.device_type == 'mobile' || _index.default.get(window, 'screen.width', 1000) < 576;
+  }
+  isTablet() {
+    if (this.forceDevice) return this.forceDevice === 'tablet';
+    return this.device_type == 'tablet';
+  }
+  isDesktop() {
+    if (this.forceDevice) return this.forceDevice === 'desktop';
+    return !this.isMobile() && !this.isTable();
+  }
+  disconnect(key) {
+    this.g_sync[key] = 0;
+  }
+  pageLoaded() {
+    return page_loaded;
+  }
+  overridePlugin(plugins) {
+    if (this._die) return dieErr;
+    if (!Array.isArray(plugins)) throw 'plugins must be be an array';
+    let pluginM = {};
+    _index.default.map(plugins, function (plugin) {
+      pluginM[plugin.id] = plugin;
+    });
+    this.forcePlugins = pluginM;
+    this.pubsub.publish('account');
+    this.pubsub.publish('resetCSS');
+  }
+  markSync(key) {
+    this.g_sync[key] = _index.default.Date.now();
+  }
+  async _touchAcc() {
+    if (this.isInsync('account')) return;
+    await this.readyGate.entry();
+    if (!this.isInsync('account')) this.reconnect();
+  }
+  async init(accid, mask, userRef, options) {
+    this.readyGate.close();
+    accid = (accid || '').trim();
+    this.g_sync = {};
+    if (!options || !options.use_subdomain_cookie) {
+      if (window && window.location && window.location.hostname) {
+        cookie.defaults.domain = '.' + window.location.hostname;
+      }
+    }
+    if (!userRef) {
+      try {
+        userRef = this.cookie.get('__sbref', '');
+      } catch (e) {}
+      if (!userRef) {
+        if (!mask) {
+          try {
+            mask = this.cookie.get('__sbmask', '');
+          } catch (e) {}
+        }
+        if (mask) {
+          let parts = mask.split('@');
+          if (parts[0] != accid) {
+            userRef = _index.default.randomString(40);
+            this.new_visitor = true;
+          }
+          this.new_visitor = false;
+          this.cookie.set('__sbmask', mask);
+        } else {
+          userRef = _index.default.randomString(40);
+          this.new_visitor = true;
+        }
+      }
+    }
+    if (this.cookie.get('__sbref', userRef) != userRef) cleanMyLocalStorage();
+    this.api.setAuth({
+      accid: accid
+    });
+    if (userRef) this.cookie.set('__sbref', userRef);
+    let user = await this.api.setAuth({
+      accid: accid,
+      mask: mask,
+      ref: userRef
+    });
+    if (user.error) return console.error(user);
+    if (this.realtime) this.realtime.stop();
+    if (this.fake) this.realtime = new _realtime_fake.default();else this.realtime = new Realtime(this.RealtimeURL, {
+      account_id: accid,
+      user_ref: userRef,
+      user_mask: mask
+    }, xhrsend);
+    this.realtime.onEvent(this.onWs.bind(this));
+    this.realtime.onInterrupted(async () => {
+      await this.reconnectWs(accid, user.id);
+      this.reconnect();
+    });
+    this.seenLoop();
+    await this.reconnect({
+      user: user
+    });
+    this.readyGate.open();
+    this.reconnectWs(accid, user.id);
+    this.loopCheckConnectionStatus();
+    return user;
+  }
+  async login(accid, user_id, tokenGenerator) {
+    if (this._die) return dieErr;
+    let user = await this.api.setAuth({
+      accid: accid,
+      profile_id: user_id,
+      tokenGenerator: tokenGenerator
+    });
+    if (user.error) return user;
+    this.clearBrowserData();
+    this.readyGate.close();
+    accid = (accid || '').trim();
+    this.g_sync = {};
+    this.new_visitor = false;
+    if (this.realtime) this.realtime.stop();
+    if (this.fake) this.realtime = new _realtime_fake.default();else this.realtime = new Realtime(this.RealtimeURL, {
+      getAccessToken: () => this.api.token_generator()
+    });
+    this.realtime.onEvent(this.onWs.bind(this));
+    this.realtime.onInterrupted(async () => {
+      await this.reconnectWs(accid, user.id);
+      this.reconnect();
+    });
+    this.seenLoop();
+    await this.reconnect();
+    this.readyGate.open();
+    this.reconnectWs(accid, user.id);
+    return user;
+  }
+  logout(userRef) {
+    return this.api.setAuth({
+      ref: userRef
+    });
+  }
+  seenLoop() {
+    this.seenQueue = [];
+    _index.default.clearInterval(this._seenInterval);
+    this._seenInterval = _index.default.setInterval(() => {
+      if (this._die) return _index.default.clearInterval(this._seenInterval);
+      this.seenQueue = [...new Set(this.seenQueue)];
+      let user = this.cache.match('user') || {};
+      _index.default.map(this.seenQueue, id => {
+        var events = this.listEvents(id);
+        if (!events) return;
+        if (_index.default.size(events) === 0) return;
+        events = _index.default.filter(events, ev => ev.type === 'message_sent');
+        var lastmsgsent = events[_index.default.size(events) - 1];
+        if (!lastmsgsent) return;
+        if (this.g_haveSentSeenM[lastmsgsent.id]) return;
+        if (lastmsgsent.id === lastmsgsent.data.message.idempotency_key) return;
+        this.api.markAsSeen(id, lastmsgsent.id);
+        this.pubsub.publish('events', {
+          created: _index.default.Date.now(),
+          type: 'message_pong',
+          by: {
+            type: 'user'
+          },
+          data: {
+            message: {
+              conversation_id: id,
+              id: '*',
+              pongs: [{
+                type: 'seen',
+                created: _index.default.Date.now()
+              }]
+            }
+          }
+        });
+        let convo = this.cache.match('convo_' + id) || {};
+        let mem = _index.default.find(convo.members, m => m.id === user.id);
+        if (mem) mem.seen_at = _index.default.Date.now();
+        this._setConvo(convo);
+        this.g_haveSentSeenM[lastmsgsent.id] = true;
+      });
+      this.seenQueue = [];
+    }, 1000);
+  }
+  async reconnectWs(accid, userid) {
+    await this.realtime.subscribe([`conversation_state_updated.account.${accid}.user.${userid}`, `conversation_joined.account.${accid}.user.${userid}`, `conversation_typing.account.${accid}.user.${userid}`, `message_sent.account.${accid}.user.${userid}`, `message_pong.account.${accid}.user.${userid}`, `conversation_rating_requested.account.${accid}.user.${userid}`, `conversation_rated.account.${accid}.user.${userid}`]);
+    await this.readyGate.entry();
+  }
+  async reconnect(p) {
+    if (this._die) return;
+    await this.reconnectGate.entry(undefined, true);
+    this.markSync('account');
+    let fetchuser = p && p.user ? Promise.resolve({
+      body: p.user
+    }) : this.api.getUser();
+    let outs = await Promise.all([fetchuser, this.api.getAccountSetting()]);
+    let error = _index.default.find(outs, out => out.error);
+    if (error) return console.error(error);
+    let set = outs[1].body;
+    set.user = outs[0].body;
+    await this._setSetting(set);
+    let convob = await this.api.listConversations();
+    error = convob.error;
+    let body = convob.body;
+    if (!error) {
+      let convos = _index.default.get(body, 'conversations', []);
+      _index.default.map(this.cache.all(), (value, k) => {
+        if (k.startsWith('convo_')) {
+          if (this.now() - _index.default.getMs(_index.default.get(value, 'actived')) > 1209600000) this.cache.del(k);
+        }
+      });
+      _index.default.map(convos, convo => this._setConvo(convo));
+    }
+    return this.reconnectGate.open();
+  }
+  async submitForm(formid, data, user) {
+    await this.readyGate.entry();
+    if (user) await this.setUser(user);
+    return this.api.submitForm(formid, document.URL, this.device, data, user);
+  }
+  async setUser(user) {
+    if (!user) return;
+    await this.readyGate.entry();
+    this._setUser(user);
+    return this.api.updateUser(user);
+  }
+  async setUserDiff(user) {
+    if (!user) return;
+    await this.readyGate.entry();
+    let out = await this.api.updateUser(user);
+    if (out && out.code == 200 && out.body.id) {
+      this._setUser(out.body);
+    }
+  }
+  _setUser(user) {
+    user = _index.default.cloneDeep(user);
+    let olduser = this.cache.match('user') || {};
+    var accid = olduser.account_id || user.account_id;
+    var id = olduser.id || user.id;
+    _index.default.each(user.attributes, newattr => {
+      if (!newattr) return;
+      olduser.attributes = _index.default.filter(olduser.attributes, oldattr => {
+        if (!oldattr) return false;
+        return oldattr.key !== newattr.key;
+      });
+    });
+    olduser.attributes = olduser.attributes || [];
+    olduser.attributes = olduser.attributes.concat(user.attributes);
+    olduser.account_id = accid;
+    olduser.id = id;
+    this.cache.put('user', olduser);
+    this.pubsub.publish('account');
+  }
+  async setSetting(setting) {
+    if (!setting) return;
+    await this.readyGate.entry();
+    return this._setSetting(setting);
+  }
+  async _setSetting(setting) {
+    setting = _index.default.cloneDeep(setting) || {};
+    setting.account = Object.assign({}, setting.account, this.forceAcc);
+    if (!setting.account.logo_url) {
+      setting.account.logo_url = 'https://vcdn.subiz-cdn.com/file/fiqpezhkmeyesdscyetk-default_logo.jpg';
+    }
+    if (setting.user) {
+      setting.user.account_id = setting.account.id;
+      delete setting.user.session;
+      this._setUser(setting.user);
+    }
+    if (setting.account) {
+      setting.account.is_online = setting.is_online;
+      setting.account.is_in_business_hour = setting.is_in_business_hour;
+      this.cache.put('account', setting.account);
+      delete setting.account;
+    }
+    let location = _index.default.get(setting, 'location', []);
+    this.cache.put('location', location);
+    let bots = _index.default.get(setting, 'bots', []);
+    let botM = {};
+    _index.default.map(bots, bot => {
+      botM[bot.id] = bot;
+    });
+    this.cache.put('bot', botM);
+    this.device_type = setting.device_type || 'desktop';
+    let plugins = _index.default.get(setting, 'plugins', []);
+    let pluginM = {};
+    _index.default.map(plugins, plugin => {
+      if (plugin.type === 'chatbox') {
+        plugin = _index.default.merge(plugin, this.forceChatbox);
+      }
+      pluginM[plugin.id] = plugin;
+    });
+    this.cache.put('plugin', pluginM);
+    var agents = _index.default.get(setting, 'agents', []);
+    if (_index.default.size(agents) > 0) {
+      let agentM = {};
+      this.api.setAgentId(agents[0].id);
+      _index.default.map(agents, agent => {
+        agentM[agent.id] = agent;
+      });
+      this.cache.put('agent', agentM);
+    }
+    let pms = _index.default.get(setting, 'payment_methods', []);
+    this.cache.put('payment_methods', pms);
+    this.pubsub.publish('account');
+  }
+  async track() {
+    let out = await this.api.sendContentView(this.device, location.href, document.title, this._currentViewingProduct.id, this._currentViewingProduct.source_id, this._currentViewingProduct.sku);
+    let traffic_source = _index.default.get(out, 'body.by.device.source', '');
+    if (traffic_source) this.kv.put('traffic_source', traffic_source);
+  }
+  async onWs(ev) {
+    await this.wsGate.entry();
+    this.wsGate.close();
+    await this._onWs(ev);
+    this.wsGate.open();
+  }
+  async _onWs(ev) {
+    if (this._die) return;
+    if (!ev || !ev.type) return;
+    ev.created = _index.default.getMs(ev.created);
+    if (ev.type === 'user_info_updated') {
+      return;
+      let user = _index.default.cloneDeep(this.cache.match('user'));
+      let attrs = _index.default.get(ev, 'data.user.attributes') || [];
+      _index.default.map(attrs, attr => _index.default.setUserAttr(user, attr));
+      this._setUser(user);
+      return;
+    }
+    let user = this.cache.match('user') || {};
+    let cid = _index.default.convoOfEv(ev);
+    let convo;
+    let alreadyFetched = false;
+    if (cid) {
+      convo = this.cache.match('convo_' + cid);
+      if (!convo || !convo.id) {
+        let {
+          body: apiconvo,
+          error
+        } = await this.api.getConversation(cid);
+        if (!apiconvo) return;
+        convo = apiconvo;
+        alreadyFetched = true;
+        this._setConvo(convo);
+      }
+    }
+    if (!convo) return;
+    this.pubsub.publish('events', ev);
+    if (ev.type === 'conversation_joined') {
+      let members = _index.default.get(ev, 'data.conversation.members', []);
+      let me = _index.default.find(members, m => m.id === this.cache.match('user').id);
+      if (me) {
+        if (!alreadyFetched) {
+          let {
+            body: apiconvo
+          } = await this.api.getConversation(cid);
+          if (apiconvo) {
+            convo = apiconvo;
+            this._setConvo(convo);
+          }
+          this.pubsub.publish('account');
+        }
+      }
+    }
+    if (ev.type === 'message_sent') {
+      if (_index.default.get(ev, 'by.id') !== user.id) {
+        if (!this._alreadyReceived[ev.id]) {
+          this._alreadyReceived[ev.id] = true;
+          this.api.markAsReceived(cid, ev.id);
+        }
+      }
+    }
+    if (_index.default.startsWith(ev.type, 'message_') || _index.default.startsWith(ev.type, 'conversation_')) {
+      this.restConvoEvent(ev);
+      if (ev.type === 'message_sent' && _index.default.get(ev, 'by.id') !== user.id) {
+        sendEventToThirdParty('SUBIZ Chat', 'Received', 'User');
+      }
+      return;
+    }
+  }
+  async restConvoEvent(ev) {
+    let user = this.cache.match('user');
+    let cid = _index.default.convoOfEv(ev);
+    let convo = this.cache.match('convo_' + cid) || {};
+    if (ev.type === 'conversation_state_updated') {
+      if (!_index.default.get(convo, 'id')) {
+        let {
+          body: convo,
+          error
+        } = await this.api.getConversation(cid);
+        if (error) return;
+      }
+      convo = Object.assign(convo, _index.default.get(ev, 'data.conversation'));
+    }
+    if (ev.type === 'message_pong') {
+      var msgid = _index.default.get(ev, 'data.message.id');
+      var oldev = this.chain.match(cid, msgid);
+      if (!_index.default.get(oldev, 'data.message')) return;
+      var pongs = _index.default.get(oldev, 'data.message.pongs', []);
+      let newpongs = _index.default.get(ev, 'data.message.pongs', []) || [];
+      pongs = pongs.concat(newpongs);
+      if (newpongs.length === 1) {
+        let pongtype = newpongs[0].type;
+        if (pongtype === 'like' || pongtype === 'remove_dislike') {
+          pongs = pongs.filter(pong => pong.type !== 'dislike');
+        }
+        if (pongtype === 'dislike' || pongtype === 'remove_like') {
+          pongs = pongs.filter(pong => pong.type !== 'like');
+        }
+      }
+      oldev.data.message.pongs = pongs;
+      _index.default.map(pongs, pong => {
+        if (pong.member_id == user.id && pong.type === 'seen') {
+          let mem = _index.default.find(convo.members, mem => mem.id === user.id);
+          if (mem) mem.seen_at = pong.created;
+        }
+      });
+      this.chain.put(cid, oldev.id, _index.default.getMs(oldev.created), oldev);
+      this.pubsub.publish('events', oldev);
+    }
+    if (ev.type === 'message_sent') {
+      let idemkey = _index.default.get(ev, 'data.message.idempotency_key');
+      let found = _index.default.find(this.listEvents(cid), oldev => oldev.id === idemkey);
+      if (found) {
+        this.chain.del(cid, found.id);
+        ev.created = found.created;
+      }
+      convo.last_message_sent = ev;
+    }
+    if (ev.type !== 'message_pong' && ev.type !== 'conversation_typing') {
+      this.chain.put(cid, ev.id, _index.default.getMs(ev.created), ev);
+    }
+    this._setConvo(convo);
+    this.pubsub.publish('account');
+  }
+  emitCloseWidgetEvent() {
+    this.pubsub.publish('sbz_close_widget', {
+      type: 'chatbox_closed'
+    });
+  }
+  typing(cid) {
+    if (!cid) return;
+    this._typing(cid);
+  }
+  async startConvo(req) {
+    if (!req) req = {};
+    await this.readyGate.entry();
+    this.convoGate.close();
+    if (!req.source) req.source = document.location.href;
+    let {
+      body: convo,
+      error
+    } = await this.api.start(req);
+    this.convoGate.open();
+    if (error) return {
+      error
+    };
+    this._setConvo(convo);
+    return {
+      convo
+    };
+  }
+  fetchOrder(id) {
+    return this.api.getOrder(id);
+  }
+  lookupOrder(key) {
+    return this.api.lookupOrder(key);
+  }
+  createPostback(cid, postback) {
+    return this.api.createPostback(cid, postback);
+  }
+  sendReaction(cid, ev) {
+    return this.api.sendConvoEvent(cid, ev);
+  }
+  async sendConvoEvent(cid, type, data) {
+    await this.readyGate.entry();
+    var idempotency = _index.default.randomString(36);
+    let user = this.cache.match('user') || {};
+    var event = {
+      id: idempotency,
+      by: {
+        id: user.id,
+        type: 'user',
+        device: this.device
+      },
+      data,
+      type,
+      created: this.now()
+    };
+    _index.default.convoToEv(cid, event);
+    let files = [];
+    if (type === 'message_sent') {
+      event.data.message.idempotency_key = idempotency;
+      event.data.message.conversation_id = cid;
+      await flow.map(event.data.message.attachments, 2, async (att, i) => {
+        if (att.type !== 'file') return;
+        if (!att._file) return;
+        files.push(att);
+        if (ImageTypes.includes(att._file.type)) {
+          let {
+            width,
+            height,
+            url
+          } = await loadImage(att._file);
+          att.url = url;
+          att.width = width;
+          att.height = height;
+        }
+      });
+    }
+    this.onWs(event);
+    await this.convoGate.entry();
+    await flow.map(files, 1, async att => {
+      const {
+        body,
+        url,
+        error
+      } = await this.api.uploadToS3(att._file);
+      if (_index.default.get(body, 'code') == 'invalid_field_size') {
+        event._error_message = 'cannot_send_too_big_file';
+      }
+      event._error = error;
+      att.url = url;
+    });
+    if (event._error) return this.onWs(event);
+    let {
+      body: ret,
+      error
+    } = await this.api.sendConvoEvent(cid, event);
+    if (error) {
+      event._error = error;
+      this.onWs(event);
+      return;
+    }
+    this.onWs(ret);
+    sendEventToThirdParty('SUBIZ Chat', 'Sent', 'User');
+    let lastMsgSent = this.kv.match('last_msg_sent');
+    if (!lastMsgSent) {
+      let dataLayer = window.dataLayer || [];
+      dataLayer.push({
+        event: 'SUBIZ Chat',
+        event_action: 'Sent',
+        event_label: 'User',
+        first_interaction: 1
+      });
+    }
+    this.kv.put('last_msg_sent', _index.default.Date.now());
+    return ret;
+  }
+  _setConvo(convo) {
+    let count = 0;
+    let user = this.cache.match('user');
+    let channel = _index.default.get(convo, 'touchpoint.channel', '');
+    if (channel && channel != 'subiz') return;
+    let allconvo = {};
+    _index.default.map(this.cache.all(), (value, key) => {
+      if (key.startsWith('convo_')) {
+        allconvo[key] = value;
+      }
+    });
+    if (_index.default.size(allconvo) > MAX_CONVO - 2) {
+      allconvo = _index.default.orderBy(_index.default.map(allconvo), 'created', 'desc');
+      for (var i = MAX_CONVO - 2; i < _index.default.size(allconvo); i++) {
+        let convo = allconvo[i];
+        this.cache.del('convo_' + convo.id);
+      }
+    }
+    this.markSync(convo.id);
+    this.pubsub.publish('account');
+    this.cache.put('convo_' + convo.id, convo);
+  }
+  matchLastPluginRun(pluginid) {
+    let log = this.kv.match('plugin_run_logs') || {};
+    return log[pluginid];
+  }
+  matchLastBotRun(botid) {
+    let log = this.kv.match('bot_run_logs') || {};
+    return log[botid];
+  }
+  logBotRun(botid) {
+    let log = this.kv.match('bot_run_logs') || {};
+    log[botid] = {
+      bot_id: botid,
+      created: this.now()
+    };
+    this.kv.put('bot_run_logs', log);
+  }
+  sendImpression(id) {
+    let user = this.cache.match('user') || {};
+    let log = this.kv.match('plugin_run_logs') || {};
+    log[id] = {
+      web_plugin_id: id,
+      created: this.now()
+    };
+    this.kv.put('plugin_run_logs', log);
+    return this.api.sendImpression({
+      account_id: user.account_id,
+      campaign_id: id,
+      web_plugin_id: id,
+      user_id: user.id,
+      url: window.location.href,
+      device: this.device
+    });
+  }
+  sendConversion(id, fields, impressionToken) {
+    let user = this.cache.match('user') || {};
+    let submission = {
+      account_id: user.account_id,
+      user_id: user.id,
+      fields: fields
+    };
+    let conv = this.kv.match('conversions') || {};
+    conv[id] = true;
+    this.kv.put('conversions', conv);
+    return this.api.sendConversion({
+      account_id: user.account_id,
+      web_plugin_id: id,
+      campaign_id: id,
+      user_id: _index.default.get(user, 'id'),
+      url: window.location.href,
+      device: this.device,
+      submission,
+      impression_token: impressionToken
+    });
+  }
+  isConverted(id) {
+    let conv = this.kv.match('conversions') || {};
+    return conv[id];
+  }
+  async listmessageapi(type, anchor, limit) {
+    let convoid = type;
+    let {
+      body: events,
+      code,
+      error
+    } = await this.api.listMessages(convoid, -limit, anchor);
+    if (error || code !== 200) return [[], anchor, error];
+    anchor = _index.default.get(_index.default.last(events), 'id');
+    events = _index.default.map(events, event => {
+      event.created = _index.default.getMs(event.created);
+      return {
+        id: event.id,
+        index: event.created,
+        value: event
+      };
+    });
+    let user = this.cache.match('user') || {};
+    for (let i = 0; i < events.length; i++) {
+      let ev = events[i].value;
+      if (ev.type !== 'message_sent') continue;
+      if (_index.default.get(ev, 'by.id') === user.id) continue;
+      let pongbyme = _index.default.find(_index.default.get(ev, 'data.message.pongs'), p => p.member_id === user.id);
+      if (pongbyme) break;
+      if (!this._alreadyReceived[ev.id]) {
+        this._alreadyReceived[ev.id] = true;
+        this.api.markAsReceived(convoid, ev.id);
+      }
+      break;
+    }
+    let outofmsg = _index.default.size(events) < limit;
+    return [events, anchor, undefined, outofmsg];
+  }
+  async loopTime() {
+    if (this._die) return;
+    let startms = _index.default.Date.now();
+    if (!_index.default.get(this.cache.match('user'), 'id')) return _index.default.setTimeout(() => this.loopTime(), 240000);
+    let {
+      body: t,
+      error
+    } = await this.api.time();
+    if (error) return _index.default.setTimeout(() => this.loopTime(), 30000);
+    var latences = Math.abs(_index.default.Date.now() - startms) / 2;
+    var serverMs = new _index.default.Date(t).getTime() + latences;
+    var localMs = _index.default.Date.now();
+    this.timeDiff = Math.floor(serverMs - localMs);
+    _index.default.setTimeout(() => this.loopTime(), 240000);
+  }
+  replaceFileUrl(src) {
+    if (!src) return '';
+    if (_index.default.startsWith(src, '/')) return src;
+    if (_index.default.startsWith(src, 'data:')) return src;
+    if (!_index.default.startsWith(src, 'http://') && !_index.default.startsWith(src, 'https://') && !_index.default.startsWith(src, '//')) {
+      src = _index.default.trim(this.FileURL, '/') + '/' + _index.default.trimStart(src, '/');
+    }
+    src = src.replace('https://file-subiz.com/', this.FileURL);
+    src = src.replace('http://file-subiz.com/', this.FileURL);
+    src = src.replace('https://file-v4.subiz.com/', this.FileURL);
+    src = src.replace('http://file-v4.subiz.com/', this.FileURL);
+    src = src.replace('https://filev4.subiz.com/', this.FileURL);
+    src = src.replace('http://filev4.subiz.com/', this.FileURL);
+    src = src.replace('https://filev4-1.subiz.com/', this.FileURL);
+    src = src.replace('http://filev4-1.subiz.com/', this.FileURL);
+    src = src.replace('https://file.subiz.com/', this.FileURL);
+    src = src.replace('http://file.subiz.com/', this.FileURL);
+    src = src.replace('https://file.mysubiz.com/', this.FileURL);
+    src = src.replace('http://file.mysubiz.com/', this.FileURL);
+    return src;
+  }
+  clearBrowserData() {
+    _index.default.each(this.cookie.all(), (v, k) => {
+      if ((k || '').startsWith('__sb')) this.cookie.remove(k);
+    });
+    this.kv.destroy();
+    this.kv = new _kv.default(new _lsdb.default('sbz2023', this.inmem), 'kv');
+    this.chain.destroy();
+    this.chain = new _chain.default(new _lsdb.default('cbz2023', true), 'ch');
+  }
+  destroy() {
+    this._die = true;
+    if (this.kv) this.kv.destroy();
+    if (this.chain) this.chain.destroy();
+    _index.default.clearInterval(this._seenInterval);
+    if (this.realtime) this.realtime.stop();
+    this.readyGate.close();
+    window.removeEventListener('blur', this.sendPresence);
+    window.removeEventListener('focus', this.sendPresence);
+  }
+}
+exports.default = Store;
+function loadImage(file) {
+  return new Promise(rs => {
+    var reader = new window.FileReader();
+    reader.onload = e => {
+      let src = e.target.result;
+      let img = new Image();
+      img.onload = () => {
+        rs({
+          url: src,
+          width: img.width,
+          height: img.height
+        });
+      };
+      img.src = src;
+    };
+    reader.readAsDataURL(file);
+  });
+}
+const ImageTypes = ['image/gif', 'image/jpeg', 'image/png', 'image/svg+xml'];
+function onVisibilityChange(cb) {
+  var hidden = 'hidden';
+  if (hidden in document) document.addEventListener('visibilitychange', onchange);else if ((hidden = 'mozHidden') in document) document.addEventListener('mozvisibilitychange', onchange);else if ((hidden = 'webkitHidden') in document) document.addEventListener('webkitvisibilitychange', onchange);else if ((hidden = 'msHidden') in document) document.addEventListener('msvisibilitychange', onchange);else if ('onfocusin' in document) document.onfocusin = document.onfocusout = onchange;else window.onpageshow = window.onpagehide = window.onfocus = window.onblur = onchange;
+  function onchange(evt) {
+    var v = 'visible';
+    var h = 'hidden';
+    var evtMap = {
+      focus: v,
+      focusin: v,
+      pageshow: v,
+      blur: h,
+      focusout: h,
+      pagehide: h
+    };
+    evt = evt || window.event;
+    if (evt.type in evtMap) cb(evtMap[evt.type]);else cb(this[hidden] ? 'hidden' : 'visible');
+  }
+  if (document[hidden] !== undefined) onchange({
+    type: document[hidden] ? 'blur' : 'focus'
+  });
+}
+const inmemCookie = {
+  data: {},
+  get(k, def) {
+    return this.data[k] || def;
+  },
+  set(k, v) {
+    return this.data[k] = k;
+  },
+  all() {
+    return this.data;
+  },
+  remove(k) {
+    delete this.data[k];
+  }
+};
+function getGaClientId() {
+  if (!window.ga) return;
+  if (!window.ga.getAll) return;
+  var allTrackers = window.ga.getAll() || [];
+  let ga_client_id = '';
+  allTrackers.forEach(function (tracker) {
+    ga_client_id = tracker.get('clientId');
+  });
+  return ga_client_id;
+}
+function getGaTrackingIds() {
+  var trackingIds = [];
+  if (!(window.ga && window.ga.getAll)) return trackingIds;
+  if (!window.ga) return [];
+  if (!window.ga.getAll) return [];
+  const allTrackers = window.ga.getAll() || [];
+  allTrackers.forEach(function (tracker) {
+    var trackingId = tracker.get('trackingId');
+    if (trackingId) trackingIds.push(trackingId);
+  });
+  return trackingIds;
+}
+function sendToFBPixel(category, action, label) {
+  if (!window.fbq) return;
+  window.fbq('trackCustom', category, {
+    action: action,
+    label: label
+  });
+}
+function sendToGA(category, action, label) {
+  if (window.sbz_no_gtag) {
+    console.log('SKIPSENT.', category, action, label);
+    return;
+  }
+  let dataLayer = window.dataLayer || [];
+  dataLayer.push({
+    event: category,
+    event_action: action,
+    event_label: label
+  });
+  if (window.gtag) window.gtag('event', category, {
+    Action: action,
+    Label: label
+  });
+  if (window.ga && window.ga.getAll) {
+    const allTrackers = window.ga.getAll() || [];
+    allTrackers.forEach(function (tracker) {
+      const name = tracker.get('name');
+      window.ga(name + '.send', 'event', category, action, label);
+    });
+  }
+}
+function sendEventToThirdParty(category, action, label) {
+  document.dispatchEvent(new CustomEvent('subiz', {
+    detail: {
+      category,
+      action,
+      label
+    }
+  }));
+  sendToGA(category, action, label);
+  sendToFBPixel(category, action, label);
+}
+let cleanLocalStorage = () => {
+  try {
+    localStorage;
+  } catch (e) {
+    return;
+  }
+  _index.default.setTimeout(() => {
+    for (var key in localStorage) {
+      if (key && (key.startsWith('cbz2020') || key.startsWith('sbz2020'))) {
+        localStorage.removeItem(key);
+      }
+    }
+  });
+};
+let cleanMyLocalStorage = () => {
+  try {
+    localStorage;
+  } catch (e) {
+    return;
+  }
+  _index.default.setTimeout(() => {
+    for (var key in localStorage) {
+      if (key && (key.startsWith('cbz2020') || key.startsWith('sbz2020') || key.startsWith('sbz2022') || key.startsWith('sbz2023'))) {
+        localStorage.removeItem(key);
+      }
+    }
+  });
+};
+function dofetch(method, url, body, cb) {
+  let headers = {};
+  if (body) headers['content-type'] = 'text/plain';
+  fetch(url, {
+    method: method,
+    headers: headers,
+    body: body
+  }).then(res => res.text().then(text => cb && cb(text, res.status))).catch(err => cb && cb(err, -1));
+}
+var xhrsend = function (method, url, body, cb) {
+  if (typeof _index.default.XMLHttpRequest === 'undefined') return dofetch(method, url, body, cb);
+  var request = new _index.default.XMLHttpRequest();
+  request.onreadystatechange = function (e) {
+    if (request.readyState !== 4) return;
+    cb && cb(request.responseText, request.status);
+    cb = undefined;
+  };
+  request.onerror = function () {
+    cb && cb(request.responseText, -1);
+    cb = undefined;
+  };
+  request.open(method, url);
+  if (body) request.setRequestHeader('content-type', 'text/plain');
+  request.send(body);
+};
+const dieErr = new Error('sdk unloaded');