@subiz/widget-v4 4.1.210 → 4.1.212

package/src/store/store.js

@@ -6,6 +6,7 @@ import Chain from './chain.js'
 import KV from './kv.js'
 import APIFake from './api_fake.js'
 import RealtimeFake from './realtime_fake.js'
+import {uploadAttachments} from './attachments.js'
 var Realtime = require('@subiz/wsclient')
 var cookie = require('cookie_js')
 cookie.defaults.path = '/'
@@ -15,8 +16,6 @@ let memlocalStorage = require('./inmem_localstorage.js')
 const MAX_CONVO = 20
 const page_loaded = sb.Date.now()
 
-const DEBUG_ACCOUNT_IDS = ['acqsulrowbxiugvginhw', 'acryguzgwxmamhzmqlyx'] // acc test and minvoice
-
 // available localstorage key mask, user, hasManuallyClosed, isopen, close_preview_at, lastview, bot_run_logs, plugin_run_logs
 export default class Store {
 	inmem = false
@@ -27,7 +26,6 @@ export default class Store {
 		this.CONNECTION_CHECK_INTERVAL = 3000
 		this.reconnectTimestamp = 0
 		this.g_sync = {}
-		this.agent_rt_message_sent_dict = {}
 		this._die = false
 		this.forceDevice = null
 		this.forcePlugins = {}
@@ -67,15 +65,22 @@ export default class Store {
 		// dont dupplicate seen
 		this.g_haveSentSeenM = {}
 		this.last_focused = this.now() // 0 -> in focus, timestamp -> lost focus at
-		window.addEventListener('blur', () => {
+		this._onBlur = () => {
+			if (this._die) return
 			this.last_focused = this.now()
 			this.sendPresence()
-		})
-		window.addEventListener('focus', () => {
+		}
+		this._onFocus = () => {
+			if (this._die) return
 			this.last_focused = 0 //
 			this.sendPresence()
-		})
-		window.addEventListener('beforeunload', () => this.api.sendLostFocus())
+		}
+		this._onBeforeUnload = () => {
+			if (!this._die) this.api.sendLostFocus()
+		}
+		window.addEventListener('blur', this._onBlur)
+		window.addEventListener('focus', this._onFocus)
+		window.addEventListener('beforeunload', this._onBeforeUnload)
 		this._lastPresenceURL = window.location.href
 		this._urlCheckInterval = sb.setInterval(() => {
 			if (this._die) return sb.clearInterval(this._urlCheckInterval)
@@ -110,7 +115,7 @@ export default class Store {
 			this.sendPresence()
 		}, 60000) // dont bother delete this
 
-		onVisibilityChange((val) => {
+		this._visibilityCleanup = onVisibilityChange((val) => {
 			if (this._die) return
 			this.browserVisibility = val
 			this.sendPresence()
@@ -120,12 +125,13 @@ export default class Store {
 		this.device = this.getDeviceInfo()
 
 		// try to get Google Analytics tracking id and client id by periodically checking it after an interval
-		const _gaInterval = sb.setInterval(() => {
+		this._gaInterval = sb.setInterval(() => {
+			if (this._die) return
 			let user = this.cache.match('user') || {}
 			if (!user.id) return // store not init
 			var dev = this.getDeviceInfo()
 			if (!dev.ga_tracking_ids || !dev.ga_client_id) return
-			sb.clearInterval(_gaInterval)
+			sb.clearInterval(this._gaInterval)
 			this.device = dev
 
 			// update gclient id
@@ -154,9 +160,30 @@ export default class Store {
 				console.log('publish connectionStatus', this.connectionStatus)
 				this.pubsub.publish('connection')
 			}
+			if (this.connectionStatus === 'active' && (this._needsMessageSync || currentStatus !== 'active')) {
+				this._needsMessageSync = false
+				this.syncKnownConvoEvents()
+			}
 		}
 	}
 
+	syncKnownConvoEvents() {
+		if (this._die) return Promise.resolve()
+		if (this.knownConvoSyncRequest) return this.knownConvoSyncRequest
+		const chain = this.chain
+		const request = (async () => {
+			const convos = sb.filter(this.cache.all(), (value, key) => key.startsWith('convo_'))
+			for (const convo of convos) {
+				if (this._die || chain !== this.chain) break
+				await this.syncConvoEvents(convo.id)
+			}
+		})().finally(() => {
+			if (this.knownConvoSyncRequest === request) this.knownConvoSyncRequest = null
+		})
+		this.knownConvoSyncRequest = request
+		return request
+	}
+
 	getConnectionStatus = () => this.connectionStatus
 
 	// inmem
@@ -342,7 +369,13 @@ export default class Store {
 	async _touchAcc() {
 		if (this.isInsync('account')) return
 		await this.readyGate.entry()
-		if (!this.isInsync('account')) this.reconnect()
+		if (!this.isInsync('account')) this.refreshAccount()
+	}
+
+	refreshAccount() {
+		if (this._die || sb.Date.now() < (this.accountRefreshAfter || 0)) return
+		this.accountRefreshAfter = sb.Date.now() + 30_000
+		return this.reconnect()
 	}
 
 	// must ensure only call this function after init is done
@@ -426,13 +459,18 @@ export default class Store {
 		await this.readyGate.entry()
 		await this.reconnectGate.entry(undefined, true)
 
-		// do nothing when account is synced
-		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()
+		try {
+			if (this._die || this.isInsync(cid)) return
+			this.convoFetchAfter = this.convoFetchAfter || {}
+			if (sb.Date.now() < (this.convoFetchAfter[cid] || 0)) return
+			this.convoFetchAfter[cid] = sb.Date.now() + 15_000
+			let {body: convo, error} = await this.api.getConversation(cid)
+			if (convo && !error) this._setConvo(convo)
+		} catch (error) {
+			return {error}
+		} finally {
+			this.reconnectGate.open()
+		}
 	}
 
 	list_provinces = () => this.api.list_provinces()
@@ -447,28 +485,111 @@ export default class Store {
 		return this.chain.listM(id)
 	}
 
-	fetchMoreEvents = async (convoid) => {
-		if (!convoid) return
-		if (convoid.startsWith('cslight')) return [[], '']
-		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)
+	fetchMoreEvents = (cid, limit = 150) => {
+		this.historyRequests = this.historyRequests || new Map()
+		if (this.historyRequests.has(cid)) return this.historyRequests.get(cid)
+		this.historyFailures = this.historyFailures || {}
+		const failure = this.historyFailures[cid]
+		if (failure && sb.Date.now() < failure.retryAt) return Promise.resolve({error: failure.error})
+		const request = this._fetchMoreEvents(cid, limit).then(result => {
+			if (result.error) this.historyFailures[cid] = {error: result.error, retryAt: sb.Date.now() + 15_000}
+			else delete this.historyFailures[cid]
+			return result
+		}).finally(() => {
+			if (this.historyRequests.get(cid) === request) this.historyRequests.delete(cid)
+		})
+		this.historyRequests.set(cid, request)
+		return request
+	}
 
-			// reset anchor
-			await this.chain.reload(convoid, () => {
-				return [[], '']
-			})
-			let out = await this._doFetchMsg(convoid)
-			this.reconnectGate.open()
+	async _fetchMoreEvents(convoid, limit = 150) {
+		if (!convoid || convoid.startsWith('cslight')) return {}
+		await this.readyGate.entry()
+		await this.reconnectGate.entry(undefined, true)
+		try {
+			if (this._die) return dieErr
+			const refresh = !this.isInsync('events' + convoid)
+			if (refresh) {
+				this.chain.anchorCache[convoid] = ''
+				delete this.outofmsgM[convoid]
+			}
+			const out = await this._doFetchMsg(convoid, limit)
+			if (!out.error) this.markSync('events' + convoid)
 			return out
+		} catch (error) {
+			return {error}
+		} finally {
+			this.reconnectGate.open()
 		}
+	}
+
+	// Fetch from the newest page independently of the older-history cursor.
+	// A realtime arrival must not advance this watermark: it could hide a gap.
+	syncConvoEvents = (cid) => {
+		if (this._die || !cid || cid.startsWith('cslight')) return Promise.resolve({})
+		this.messageSyncRequests = this.messageSyncRequests || new Map()
+		if (this.messageSyncRequests.has(cid)) return this.messageSyncRequests.get(cid)
+		this.messageSyncNextAt = this.messageSyncNextAt || {}
+		if (sb.Date.now() < (this.messageSyncNextAt[cid] || 0)) return Promise.resolve({skipped: true})
+		const chain = this.chain
+		const request = this._syncConvoEvents(cid, chain).then(result => {
+			if (chain === this.chain && !this._die) {
+				this.messageSyncFailures = this.messageSyncFailures || {}
+				const failures = result.error ? Math.min((this.messageSyncFailures[cid] || 0) + 1, 4) : 0
+				this.messageSyncFailures[cid] = failures
+				this.messageSyncNextAt[cid] = sb.Date.now() + (failures ? 15_000 * 2 ** (failures - 1) : 15_000)
+			}
+			return result
+		}).finally(() => {
+			if (this.messageSyncRequests.get(cid) === request) this.messageSyncRequests.delete(cid)
+		})
+		this.messageSyncRequests.set(cid, request)
+		return request
+	}
 
-		return this._doFetchMsg(convoid)
+	async _syncConvoEvents(cid, chain) {
+		await this.readyGate.entry()
+		await this.reconnectGate.entry(undefined, true)
+		try {
+			if (this._die || chain !== this.chain) return dieErr
+			this.messageSyncTimes = this.messageSyncTimes || {}
+			this.messageSyncProgress = this.messageSyncProgress || {}
+			let progress = this.messageSyncProgress[cid]
+			if (!progress) {
+				const cached = Object.values(chain.listM(cid))
+				const boundary = this.messageSyncTimes[cid] || cached.reduce((min, ev) => Math.min(min, sb.getMs(ev.created)), Infinity)
+				progress = this.messageSyncProgress[cid] = {boundary, anchor: '', newest: 0, visited: new Set()}
+			}
+			// Bound each batch; the next trigger resumes at the saved cursor.
+			for (let page = 0; page < 5; page++) {
+				const wait = (this.nextMessageSyncRequestAt || 0) - sb.Date.now()
+				if (wait > 0) await sb.sleep(wait)
+				if (this._die || chain !== this.chain) return dieErr
+				this.nextMessageSyncRequestAt = sb.Date.now() + 250
+				const [items, next, error, end] = await this.listmessageapi(cid, progress.anchor, 150)
+				if (this._die || chain !== this.chain) return dieErr
+				if (error) return {error}
+				chain.merge(cid, items)
+				for (const item of items) progress.newest = Math.max(progress.newest, item.index)
+				this.pubsub.publish('account')
+				if (end || !items.length || items.some(item => item.index < progress.boundary)) {
+					if (progress.newest) this.messageSyncTimes[cid] = progress.newest
+					delete this.messageSyncProgress[cid]
+					return {}
+				}
+				progress.visited.add(progress.anchor)
+				if (!next || progress.visited.has(next)) {
+					delete this.messageSyncProgress[cid]
+					return {error: 'message_cursor_stalled'}
+				}
+				progress.anchor = next
+			}
+			return {pending: true}
+		} catch (error) {
+			return {error}
+		} finally {
+			this.reconnectGate.open()
+		}
 	}
 
 	reloadConvoEvents = async (convoid) => {
@@ -483,8 +604,8 @@ export default class Store {
 		return {error}
 	}
 
-	_doFetchMsg = async (convoid) => {
-		let {error} = await this.chain.fetchMore(convoid, 150, async (type, anchor, limit) => {
+	_doFetchMsg = async (convoid, limit = 150) => {
+		let {error} = await this.chain.fetchMore(convoid, limit, 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
@@ -621,7 +742,6 @@ export default class Store {
 
 	async _initResource(accid, auth, realtimep) {
 		this.g_sync = {}
-		this._current_acc_id = accid
 
 		let user = await this.api.setAuth(auth)
 		if (typeof sbz_info != 'undefined') sbz_info.store_7 = true
@@ -635,6 +755,7 @@ export default class Store {
 		let lightConvos = this.kv.match('light_convos') || {}
 		this.lightConvos = {}
 		sb.map(lightConvos, (convo) => {
+			if (convo.light_type === 'widget' && (convo.account_id !== accid || convo.initial_by !== user.id)) return
 			let in7Day = convo.created > sb.Date.now() - 7 * 24 * 3_600_000
 			let events = sb.filter(convo.events, (ev) => ev.type === 'message_sent')
 
@@ -652,8 +773,10 @@ export default class Store {
 
 		this.realtime.onEvent(this.onWs.bind(this))
 		this.realtime.onInterrupted(async () => {
+			if (this._die) return
+			this._needsMessageSync = true
 			await this.reconnectWs(accid, user.id)
-			this.reconnect()
+			await this.refreshAccount()
 		})
 
 		if (typeof sbz_info != 'undefined') sbz_info.store_8 = true
@@ -709,7 +832,7 @@ export default class Store {
 				if (this.g_haveSentSeenM[lastmsgsent.id]) return
 
 				// ignore sending message
-				if (lastmsgsent.id === lastmsgsent.data.message.idempotency_key) return
+				if (lastmsgsent.id === lastmsgsent.source_event_id) return
 
 				// fire own event so guest code can update unread number
 				this.pubsub.publish('events', {
@@ -765,40 +888,53 @@ export default class Store {
 		await this.readyGate.entry()
 	}
 
-	async reconnect(p) {
+	reconnect(p) {
+		if (this.reconnectRequest) return this.reconnectRequest
+		const request = this._reconnect(p).finally(() => {
+			if (this.reconnectRequest === request) this.reconnectRequest = null
+		})
+		this.reconnectRequest = request
+		return request
+	}
+
+	async _reconnect(p) {
 		if (this._die) return
 		// make sure we only run reconnect once in a time
 		await this.reconnectGate.entry(undefined, true)
-		// do nothing when account is synced
-		// if (this.isInsync('account')) return this.reconnectGate.open()
-		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({bot_id: this.forceBotId})])
-
-		let error = sb.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)
-		// refetch convo
-		let convob = await this.api.listConversations()
-
-		error = convob.error
-		let body = convob.body
-		if (!error) {
-			let convos = sb.get(body, 'conversations', [])
-			// clear all old convo from two week
-			sb.map(this.cache.all(), (value, k) => {
-				if (k.startsWith('convo_')) {
-					if (this.now() - sb.getMs(sb.get(value, 'actived')) > 1209600000) this.cache.del(k)
-				}
-			})
-			sb.map(convos, (convo) => this._setConvo(convo))
-		}
+		try {
+
+			let fetchuser = p && p.user ? Promise.resolve({body: p.user}) : this.api.getUser()
+			let outs = await Promise.all([fetchuser, this.api.getAccountSetting({bot_id: this.forceBotId})])
+
+			let error = sb.find(outs, (out) => out.error)
+			if (error) return error
+
+			let set = outs[1].body
+			set.user = outs[0].body
+			await this._setSetting(set)
+			// refetch convo
+			let convob = await this.api.listConversations()
+
+			error = convob.error
+			let body = convob.body
+			if (!error) {
+				let convos = sb.get(body, 'conversations', [])
+				// clear all old convo from two week
+				sb.map(this.cache.all(), (value, k) => {
+					if (k.startsWith('convo_')) {
+						if (this.now() - sb.getMs(sb.get(value, 'actived')) > 1209600000) this.cache.del(k)
+					}
+				})
+				sb.map(convos, (convo) => this._setConvo(convo))
+			}
 
-		return this.reconnectGate.open()
+			if (error) return {error}
+			this.markSync('account')
+		} catch (error) {
+			return {error}
+		} finally {
+			this.reconnectGate.open()
+		}
 	}
 
 	async submitForm(formid, data, user) {
@@ -949,39 +1085,18 @@ export default class Store {
 	matchTrafficSource = () => this.kv.match('traffic_source')
 
 	async onWs(ev) {
-		await this.wsGate.entry()
-		this.wsGate.close()
-		await this._onWs(ev)
-		this.wsGate.open()
-	}
-
-	sendBugReport = (str) => this.api.sendBugReport(str)
-
-	matchDebugAccountIds = () => DEBUG_ACCOUNT_IDS
-
-	handleLogCompare(ev) {
-		if (!DEBUG_ACCOUNT_IDS.includes(this._current_acc_id)) return
-		if (ev.type !== 'message_sent') return
-		let byType = sb.get(ev, 'by.type')
-		if (byType === 'user') return
-
-		this.agent_rt_message_sent_dict[ev.id] = ev
-	}
-
-	sbzListConversations = () => {
-		return this.api.listConversations()
-	}
-
-	sbzListMessages = (cid) => {
-		return this.api.listMessages(cid, 100, '')
-	}
-
-	listAgentRealtimeMessageSent = () => {
-		return this.agent_rt_message_sent_dict
+		await this.wsGate.entry(undefined, true)
+		try {
+			await this._onWs(ev)
+		} catch (error) {
+			console.error(error)
+			return {error}
+		} finally {
+			this.wsGate.open()
+		}
 	}
 
 	async _onWs(ev) {
-		this.handleLogCompare(ev)
 		if (this._die) return
 		if (!ev || !ev.type) return
 		ev.created = sb.getMs(ev.created)
@@ -1063,7 +1178,7 @@ export default class Store {
 		}
 
 		if (sb.startsWith(ev.type, 'message_') || sb.startsWith(ev.type, 'conversation_')) {
-			this.restConvoEvent(ev)
+			await this.restConvoEvent(ev)
 			if (ev.type === 'message_sent' && sb.get(ev, 'by.id') !== user.id) {
 				sendEventToThirdParty('SUBIZ Chat', 'Received', 'User')
 			}
@@ -1116,8 +1231,8 @@ export default class Store {
 		// dont store pong and typing
 		if (ev.type !== 'message_pong' && ev.type !== 'conversation_typing') {
 			if (ev.type === 'message_sent') {
-				let idemkey = sb.get(ev, 'data.message.idempotency_key')
-				let found = sb.find(this.listEvents(cid), (oldev) => oldev.id === idemkey)
+				let sourceEventId = sb.get(ev, 'source_event_id')
+				let found = sb.find(this.listEvents(cid), (oldev) => oldev.id === sourceEventId)
 				if (found) {
 					// keeping old created so the ui can be static
 					this.chain.del(cid, found.id)
@@ -1149,6 +1264,39 @@ export default class Store {
 		this.kv.put('light_convos', this.lightConvos)
 	}
 
+	startWidgetConvo(greeting, locale) {
+		const user = this.matchUser()
+		const existing = sb.find(this.lightConvos, convo => convo.light_type === 'widget' && convo.account_id === user.account_id && convo.initial_by === user.id)
+		if (existing) return {convo: existing}
+		const id = 'cslightwidget_' + sb.randomString(24)
+		const ev = sb.cloneDeep(greeting)
+		ev.data.message.conversation_id = id
+		const convo = {
+			id, account_id: user.account_id, initial_by: user.id, locale,
+			light_type: 'widget', state: 'pending', created: ev.created,
+			members: [{id: user.id, type: 'user', seen_at: ev.created + 1}],
+			events: [ev], last_message_sent: ev,
+			touchpoint: {id, channel: 'subiz', source: 'web'},
+		}
+		this.lightConvos[id] = convo
+		this.kv.put('light_convos', this.lightConvos)
+		this.pubsub.publish('account')
+		return {convo}
+	}
+
+	promoteWidgetConvo(localId, cid) {
+		// Keep the mounted timeline and its message keys across draft promotion.
+		this.widgetConvoOrigins = this.widgetConvoOrigins || {}
+		this.widgetConvoOrigins[cid] = localId
+		const greeting = sb.cloneDeep(sb.get(this.lightConvos, [localId, 'events', 0]))
+		if (greeting) {
+			greeting.source_event_id = greeting.id
+			greeting.data.message.conversation_id = cid
+			this.chain.merge(cid, [{id: greeting.id, index: greeting.created, value: greeting}])
+		}
+		this.deleteLightConvo(localId)
+	}
+
 	startLightConvo(botid, messages, locale, is_testing, botversion) {
 		let convoid = 'cslight' + botid + '_' + this.now()
 		let user = this.cache.match('user') || {}
@@ -1229,11 +1377,11 @@ export default class Store {
 
 	async sendConvoEvent(cid, type, data) {
 		await this.readyGate.entry()
-		var idempotency = sb.randomString(36)
+		var sourceEventId = sb.randomString(36)
 		let user = this.cache.match('user') || {}
 
 		var event = {
-			id: idempotency,
+			id: sourceEventId,
 			by: {id: user.id, type: 'user', device: this.device},
 			data,
 			type,
@@ -1242,7 +1390,7 @@ export default class Store {
 		sb.convoToEv(cid, event)
 		let files = []
 		if (type === 'message_sent') {
-			event.data.message.idempotency_key = idempotency
+			event.source_event_id = sourceEventId
 			event.data.message.conversation_id = cid
 
 			// pre upload image files
@@ -1263,14 +1411,9 @@ export default class Store {
 		await this.convoGate.entry()
 		// upload file first
 
-		await flow.map(files, 1, async (att) => {
-			const {body, url, error} = await this.api.uploadToS3(att._file)
-			if (sb.get(body, 'code') == 'invalid_field_size') {
-				event._error_message = 'cannot_send_too_big_file'
-			}
-			event._error = error
-			att.url = url
-		})
+		const uploaded = await uploadAttachments(files, (file) => this.api.uploadToS3(file))
+		event._error = uploaded.error
+		if (uploaded.errorMessage) event._error_message = uploaded.errorMessage
 
 		if (event._error) return this.onWs(event) // dont send error msg
 		if (cid && cid.startsWith('cslight')) return
@@ -1413,9 +1556,12 @@ export default class Store {
 
 	async listmessageapi(type, anchor, limit) {
 		let convoid = type
-		if (convoid && convoid.startsWith('cslight')) return [fakeevents, '', undefined, true]
+		if (convoid && convoid.startsWith('cslight')) {
+			let events = sb.map(this.listEvents(convoid), (ev) => ({id: ev.id, index: ev.created, value: ev}))
+			return [events, '', undefined, true]
+		}
 		let {body: events, code, error} = await this.api.listMessages(convoid, -limit, anchor)
-		if (error || code !== 200) return [[], anchor, error]
+		if (error || code !== 200) return [[], anchor, error || 'message_fetch_failed']
 		anchor = sb.get(sb.last(events), 'id')
 
 		events = sb.map(events, (event) => {
@@ -1450,15 +1596,17 @@ export default class Store {
 		let startms = this.now()
 
 		// store not init
-		if (!this.cache || !sb.get(this.cache.match('user'), 'id')) return sb.setTimeout(() => this.loopTime(), 240000)
+		if (!this.cache || !sb.get(this.cache.match('user'), 'id'))
+			return (this._timeTimeout = sb.setTimeout(() => this.loopTime(), 240000))
 
 		let {body: t, error} = await this.api.time()
-		if (error) return sb.setTimeout(() => this.loopTime(), 30000)
+		if (this._die) return
+		if (error) return (this._timeTimeout = sb.setTimeout(() => this.loopTime(), 30000))
 		var latences = Math.abs(this.now() - startms) / 2
 		var serverMs = new sb.Date(t).getTime() + latences
 		var localMs = this.now()
 		this.timeDiff = Math.floor(serverMs - localMs)
-		sb.setTimeout(() => this.loopTime(), 240000)
+		this._timeTimeout = sb.setTimeout(() => this.loopTime(), 240000)
 	}
 
 	replaceFileUrl(src) {
@@ -1497,6 +1645,14 @@ export default class Store {
 		this.kv = new KV(new LSDB('sbz2023', this.inmem), 'kv')
 		if (this.chain) this.chain.destroy()
 		this.chain = new Chain(new LSDB('cbz2023', true), 'ch')
+		this.outofmsgM = {}
+		this.messageSyncTimes = {}
+		this.messageSyncNextAt = {}
+		this.messageSyncFailures = {}
+		this.messageSyncProgress = {}
+		this.accountRefreshAfter = 0
+		this.historyFailures = {}
+		this.convoFetchAfter = {}
 		if (this.realtime) this.realtime.stop()
 		if (this.cache) this.cache.destroy()
 		this.pubsub.publish('destroy')
@@ -1506,14 +1662,22 @@ export default class Store {
 		return this._die
 	}
 	destroy() {
+		if (this._die) return
 		this._die = true
 		this.clearBrowserData()
 		sb.clearInterval(this._seenInterval)
 		sb.clearInterval(this._urlCheckInterval)
+		sb.clearInterval(this._presenceInterval1)
+		sb.clearInterval(this._presenceInterval2)
+		sb.clearInterval(this._gaInterval)
+		sb.clearTimeout(this._timeTimeout)
 		if (this.realtime) this.realtime.stop()
-		this.readyGate.close()
-		window.removeEventListener('blur', this.sendPresence)
-		window.removeEventListener('focus', this.sendPresence)
+		if (this.readyGate) this.readyGate.close()
+		window.removeEventListener('blur', this._onBlur)
+		window.removeEventListener('focus', this._onFocus)
+		window.removeEventListener('beforeunload', this._onBeforeUnload)
+		if (this._visibilityCleanup) this._visibilityCleanup()
+		this.pubsub.clear()
 	}
 }
 
@@ -1543,16 +1707,29 @@ const ImageTypes = ['image/gif', 'image/jpeg', 'image/png', 'image/svg+xml']
 
 function onVisibilityChange(cb) {
 	var hidden = 'hidden'
+	let target = document,
+		eventName
+	let previous = {}
 
 	// Standards:
-	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)
+	if (hidden in document) eventName = 'visibilitychange'
+	else if ((hidden = 'mozHidden') in document) eventName = 'mozvisibilitychange'
+	else if ((hidden = 'webkitHidden') in document) eventName = 'webkitvisibilitychange'
+	else if ((hidden = 'msHidden') in document) eventName = 'msvisibilitychange'
 	// IE 9 and lower:
-	else if ('onfocusin' in document) document.onfocusin = document.onfocusout = onchange
+	else if ('onfocusin' in document) {
+		previous = {onfocusin: document.onfocusin, onfocusout: document.onfocusout}
+		document.onfocusin = document.onfocusout = onchange
+	}
 	// All others:
-	else window.onpageshow = window.onpagehide = window.onfocus = window.onblur = onchange
+	else {
+		target = window
+		for (const key of ['onpageshow', 'onpagehide', 'onfocus', 'onblur']) {
+			previous[key] = window[key]
+			window[key] = onchange
+		}
+	}
+	if (eventName) target.addEventListener(eventName, onchange)
 
 	function onchange(evt) {
 		var v = 'visible'
@@ -1566,6 +1743,12 @@ function onVisibilityChange(cb) {
 
 	// set the initial state (but only if browser supports the Page Visibility API)
 	if (document[hidden] !== undefined) onchange({type: document[hidden] ? 'blur' : 'focus'})
+	return () => {
+		if (eventName) target.removeEventListener(eventName, onchange)
+		for (const key of Object.keys(previous)) {
+			if (target[key] === onchange) target[key] = previous[key]
+		}
+	}
 }
 
 const inmemCookie = {