@inboxsdk/core 1.2.4 → 1.2.7

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver.js

@@ -1,723 +0,0 @@
-import toValueObservable from 'live-set/toValueObservable';
-import t from 'transducers.js';
-import * as Kefir from 'kefir';
-import kefirStopper from 'kefir-stopper';
-import kefirBus from 'kefir-bus';
-import includes from 'lodash/includes';
-import get from '../../../common/get-or-fail';
-import showAppIdWarning from './gmail-driver/show-app-id-warning';
-import makePageParserTree from './makePageParserTree';
-import GmailElementGetter from './gmail-element-getter';
-import makeXhrInterceptor from './make-xhr-interceptor';
-import GmailBackdrop from './views/gmail-backdrop';
-import { removeAllThreadRowUnclaimedModifications } from './views/gmail-thread-row-view';
-import GmailTopMessageBarDriver from './widgets/gmail-top-message-bar-driver';
-import GmailModalViewDriver from './widgets/gmail-modal-view-driver';
-import GmailMoleViewDriver from './widgets/gmail-mole-view-driver';
-import InboxDrawerView from '../inbox/views/inbox-drawer-view';
-import GmailRouteProcessor from './views/gmail-route-view/gmail-route-processor';
-import KeyboardShortcutHelpModifier from './gmail-driver/keyboard-shortcut-help-modifier';
-import openDraftByMessageID from './gmail-driver/open-draft-by-message-id';
-import UserInfo from './gmail-driver/user-info';
-import GmailButterBarDriver from './gmail-butter-bar-driver';
-import trackGmailStyles from './gmail-driver/track-gmail-styles';
-import temporaryTrackDownloadUrlValidity from './gmail-driver/temporary-track-download-url-validity';
-import getGmailThreadIdForRfcMessageId from '../../driver-common/getGmailThreadIdForRfcMessageId';
-import getRfcMessageIdForGmailThreadId from './gmail-driver/get-rfc-message-id-for-gmail-thread-id';
-import getGmailMessageIdForSyncMessageId from '../../driver-common/getGmailMessageIdForSyncMessageId';
-import BiMapCache from 'bimapcache';
-import getDraftIDForMessageID from './gmail-driver/get-draft-id-for-message-id';
-import addNavItem from './gmail-driver/add-nav-item';
-import { addAppMenuItem } from './gmail-driver/add-app-menu-item';
-import addSupportItem from './gmail-driver/add-support-item';
-import gotoView from './gmail-driver/goto-view';
-import showCustomThreadList from './gmail-driver/show-custom-thread-list';
-import showCustomRouteView from './gmail-driver/show-custom-route-view';
-import showNativeRouteView from './gmail-driver/show-native-route-view';
-import registerSearchSuggestionsProvider from './gmail-driver/register-search-suggestions-provider';
-import setupComposeViewDriverStream from './gmail-driver/setup-compose-view-driver-stream';
-import trackEvents from './gmail-driver/track-events';
-import gmailLoadEvent from './gmail-driver/gmail-load-event';
-import ThreadRowIdentifier from './gmail-driver/thread-row-identifier';
-import overrideGmailBackButton from './gmail-driver/override-gmail-back-button';
-import addToolbarButtonForApp from './gmail-driver/add-toolbar-button-for-app';
-import setupRouteViewDriverStream from './gmail-driver/setup-route-view-driver-stream';
-import getNativeNavItem from './gmail-driver/get-native-nav-item';
-import createLink from './gmail-driver/create-link';
-import registerSearchQueryRewriter from './gmail-driver/register-search-query-rewriter';
-import openComposeWindow from './gmail-driver/open-compose-window';
-import GmailAppSidebarView from './views/gmail-app-sidebar-view';
-import suppressAddon from './gmail-driver/suppressAddon';
-import getSyncThreadFromSyncThreadId from './gmail-driver/getSyncThreadFromSyncThreadId';
-import getSyncThreadForOldGmailThreadId from './gmail-driver/getSyncThreadForOldGmailThreadId';
-import toItemWithLifetimeStream from '../../lib/toItemWithLifetimeStream';
-import toLiveSet from '../../lib/toLiveSet';
-import waitFor from '../../lib/stream-wait-for';
-class GmailDriver {
-    _appId;
-    _logger;
-    _opts;
-    _envData;
-    _customRouteIDs = new Set();
-    _customListRouteIDs = new Map();
-    _customListSearchStringsToRouteIds = new Map();
-    _messageIDsToThreadIDs = new Map();
-    _threadRowIdentifier;
-    _gmailRouteProcessor;
-    _keyboardShortcutHelpModifier;
-    onready;
-    _page;
-    _pageCommunicator;
-    _pageCommunicatorPromise;
-    _butterBar;
-    _butterBarDriver;
-    _routeViewDriverStream;
-    _rowListViewDriverStream;
-    _threadRowViewDriverKefirStream;
-    _threadViewDriverLiveSet;
-    _toolbarViewDriverLiveSet;
-    _composeViewDriverStream;
-    _xhrInterceptorStream;
-    _messageViewDriverStream;
-    _stopper = kefirStopper();
-    _navMarkerHiddenChanged = kefirBus();
-    _addonSidebarHiddenChanged = kefirBus();
-    _userInfo;
-    _timestampAccountSwitcherReady;
-    _timestampGlobalsFound;
-    _timestampOnready;
-    _lastCustomThreadListActivity;
-    _currentRouteViewDriver;
-    _appSidebarView = null;
-    getGmailThreadIdForRfcMessageId;
-    getRfcMessageIdForGmailThreadId;
-    getSyncThreadIdForOldGmailThreadId;
-    getOldGmailThreadIdFromSyncThreadId;
-    removeCachedOldGmailThreadIdFromSyncThreadId;
-    getGmailMessageIdForSyncDraftId;
-    getGmailMessageIdForSyncMessageId;
-    removeCachedGmailMessageIdForSyncMessageId;
-    constructor(appId, LOADER_VERSION, IMPL_VERSION, logger, opts, envData) {
-        this._appId = appId;
-        this._logger = logger;
-        this._opts = opts;
-        this._envData = envData;
-        this._page = makePageParserTree(this, document);
-        this._stopper.onValue(() => this._page.dump());
-        // Manages the mapping between RFC Message Ids and Gmail Message Ids. Caches to
-        // localStorage. Used for custom thread lists.
-        {
-            const rfcIdCache = new BiMapCache({
-                key: 'inboxsdk__cached_thread_ids',
-                getAfromB: (gmailThreadId) => getRfcMessageIdForGmailThreadId(this, gmailThreadId),
-                getBfromA: (rfcMessageId) => getGmailThreadIdForRfcMessageId(this, rfcMessageId),
-            });
-            this.getGmailThreadIdForRfcMessageId = (rfcMessageId) => rfcIdCache.getBfromA(rfcMessageId);
-            this.getRfcMessageIdForGmailThreadId = (gmailThreadId) => rfcIdCache.getAfromB(gmailThreadId);
-        }
-        // Manages mapping between old hex thread ids and new sync based thread ids
-        {
-            const syncThreadIdToOldGmailThreadIdCache = new BiMapCache({
-                key: 'inboxsdk__cached_sync_thread_id_old_gmail_thread_id',
-                getAfromB: (oldGmailThreadId) => {
-                    return getSyncThreadForOldGmailThreadId(this, oldGmailThreadId).then(({ syncThreadID }) => syncThreadID);
-                },
-                getBfromA: (syncThreadID) => {
-                    return getSyncThreadFromSyncThreadId(this, syncThreadID).then((syncThread) => {
-                        if (syncThread)
-                            return syncThread.oldGmailThreadID;
-                        else
-                            throw new Error('syncThread not found');
-                    });
-                },
-            });
-            this.getSyncThreadIdForOldGmailThreadId = (oldGmailThreadId) => syncThreadIdToOldGmailThreadIdCache.getAfromB(oldGmailThreadId);
-            this.getOldGmailThreadIdFromSyncThreadId = (syncThreadId) => syncThreadIdToOldGmailThreadIdCache.getBfromA(syncThreadId);
-            this.removeCachedOldGmailThreadIdFromSyncThreadId = (syncThreadId) => syncThreadIdToOldGmailThreadIdCache.removeAfromCache(syncThreadId);
-        }
-        // mapping between sync message ids and old message ids
-        {
-            try {
-                // TODO remove sometime after March 24 2019 to give time for this to
-                // run for most users.
-                localStorage.removeItem('inboxsdk__cached_gmail_and_inbox_message_ids_2');
-            }
-            catch (err) {
-                console.error(err);
-            }
-            const gmailMessageIdForSyncMessageIdCache = new BiMapCache({
-                key: 'inboxsdk__cached_gmail_and_inbox_message_ids_3',
-                getAfromB: (sync) => getGmailMessageIdForSyncMessageId(this, sync),
-                getBfromA() {
-                    throw new Error('should not happen');
-                },
-            });
-            this.getGmailMessageIdForSyncMessageId = (syncMessageId) => gmailMessageIdForSyncMessageIdCache.getAfromB(syncMessageId);
-            this.removeCachedGmailMessageIdForSyncMessageId = (syncMessageId) => gmailMessageIdForSyncMessageIdCache.removeBfromCache(syncMessageId);
-            // It's important that this doesn't use the same cache for looking up
-            // sync message IDs, because the legacy ID of a draft changes when it's
-            // sent. It doesn't really need to be cached so it's not here.
-            this.getGmailMessageIdForSyncDraftId = (syncDraftId) => getGmailMessageIdForSyncMessageId(this, syncDraftId);
-        }
-        this._gmailRouteProcessor = new GmailRouteProcessor();
-        this._keyboardShortcutHelpModifier = new KeyboardShortcutHelpModifier();
-        this._butterBarDriver = new GmailButterBarDriver();
-        Kefir.later(45 * 1000, undefined)
-            .takeUntilBy(toItemWithLifetimeStream(this._page.tree.getAllByTag('supportMenu')))
-            .onValue(() => {
-            this._logger.errorSite(new Error('Failed to find gmail supportMenu'));
-        });
-        this._setupEventStreams();
-        this.onready
-            .then(() => {
-            trackEvents(this);
-            gmailLoadEvent(this);
-            overrideGmailBackButton(this, this._gmailRouteProcessor);
-            trackGmailStyles();
-            temporaryTrackDownloadUrlValidity(this);
-            if (opts.suppressAddonTitle != null) {
-                suppressAddon(this, opts.suppressAddonTitle);
-            }
-        })
-            .catch((err) => {
-            this._logger.error(err);
-        });
-    }
-    destroy() {
-        this._threadRowViewSelectionChanges.end();
-        this._keyboardShortcutHelpModifier.destroy();
-        this._stopper.destroy();
-        removeAllThreadRowUnclaimedModifications();
-    }
-    getAppId() {
-        return this._appId;
-    }
-    getOpts() {
-        return this._opts;
-    }
-    getPageCommunicator() {
-        return this._pageCommunicator;
-    }
-    getPageCommunicatorPromise() {
-        return this._pageCommunicatorPromise;
-    }
-    getLogger() {
-        return this._logger;
-    }
-    getTagTree() {
-        return this._page.tree;
-    }
-    getCustomListSearchStringsToRouteIds() {
-        return this._customListSearchStringsToRouteIds;
-    }
-    getThreadRowIdentifier() {
-        return this._threadRowIdentifier;
-    }
-    getButterBarDriver() {
-        return this._butterBarDriver;
-    }
-    getButterBar() {
-        return this._butterBar;
-    }
-    setButterBar(bb) {
-        this._butterBar = bb;
-    }
-    getCustomRouteIDs() {
-        return this._customRouteIDs;
-    }
-    getCustomListRouteIDs() {
-        return this._customListRouteIDs;
-    }
-    getKeyboardShortcutHelpModifier() {
-        return this._keyboardShortcutHelpModifier;
-    }
-    getRouteViewDriverStream() {
-        return this._routeViewDriverStream;
-    }
-    getRowListViewDriverStream() {
-        return this._rowListViewDriverStream;
-    }
-    getThreadRowViewDriverStream() {
-        return this._threadRowViewDriverKefirStream;
-    }
-    getThreadViewDriverStream() {
-        return toItemWithLifetimeStream(this._threadViewDriverLiveSet).map(({ el }) => el);
-    }
-    getAttachmentCardViewDriverStream() {
-        return this._messageViewDriverStream
-            .flatMap((messageViewDriver) => messageViewDriver.isLoaded()
-            ? Kefir.constant(messageViewDriver)
-            : messageViewDriver
-                .getEventStream()
-                .filter((event) => event.eventName === 'messageLoad')
-                .map(() => messageViewDriver)
-                .take(1))
-            .map((messageView) => messageView.getAttachmentCardViewDrivers())
-            .flatten();
-    }
-    getComposeViewDriverStream() {
-        return this._composeViewDriverStream;
-    }
-    getXhrInterceptorStream() {
-        return this._xhrInterceptorStream;
-    }
-    getMessageViewDriverStream() {
-        return this._messageViewDriverStream;
-    }
-    getStopper() {
-        return this._stopper;
-    }
-    getEnvData() {
-        return this._envData;
-    }
-    getTimestampOnReady() {
-        if (this._timestampOnready == null) {
-            this._logger.error(new Error('getTimestampOnReady called before ready'));
-            return Date.now();
-        }
-        return this._timestampOnready;
-    }
-    // Returns a stream that emits an event once at least `time` milliseconds has
-    // passed since the GmailDriver's ready event.
-    delayToTimeAfterReady(time) {
-        const targetTime = this.getTimestampOnReady() + time;
-        const timeToWait = Math.max(0, targetTime - Date.now());
-        return Kefir.later(timeToWait, undefined);
-    }
-    getTimings() {
-        return {
-            piMainStarted: this._envData.piMainStarted,
-            piLoadStarted: this._envData.piLoadStarted,
-            globalsFound: this._timestampGlobalsFound,
-            accountSwitcherReady: this._timestampAccountSwitcherReady,
-            onready: this._timestampOnready,
-        };
-    }
-    registerThreadButton(options) {
-        const unregister = kefirStopper();
-        const removeButtonOnUnregister = (button) => {
-            unregister.takeUntilBy(button.getStopper()).onValue(() => {
-                button.destroy();
-            });
-        };
-        const toolbarViewSub = toValueObservable(this._toolbarViewDriverLiveSet).subscribe(({ value: gmailToolbarView }) => {
-            if (gmailToolbarView.isForThread()) {
-                if (!options.positions || includes(options.positions, 'THREAD')) {
-                    removeButtonOnUnregister(gmailToolbarView.addButton({
-                        ...options,
-                        section: options.threadSection || 'METADATA_STATE',
-                        onClick: (event) => {
-                            options.onClick({
-                                position: 'THREAD',
-                                dropdown: event.dropdown,
-                                selectedThreadViewDrivers: [
-                                    gmailToolbarView.getThreadViewDriver(),
-                                ],
-                                selectedThreadRowViewDrivers: [],
-                            });
-                        },
-                    }));
-                }
-            }
-            else if (gmailToolbarView.isForRowList()) {
-                if (!options.positions || includes(options.positions, 'LIST')) {
-                    removeButtonOnUnregister(gmailToolbarView.addButton({
-                        ...options,
-                        section: options.listSection || 'METADATA_STATE',
-                        onClick: (event) => {
-                            const selectedThreadRowViewDrivers = Array.from(gmailToolbarView.getThreadRowViewDrivers()).filter((gmailThreadRow) => gmailThreadRow.isSelected());
-                            options.onClick({
-                                position: 'LIST',
-                                dropdown: event.dropdown,
-                                selectedThreadViewDrivers: [],
-                                selectedThreadRowViewDrivers,
-                            });
-                        },
-                    }));
-                }
-            }
-        });
-        unregister.onValue(() => {
-            toolbarViewSub.unsubscribe();
-        });
-        if (!options.positions || includes(options.positions, 'ROW')) {
-            const perThreadRow = (gmailThreadRow) => {
-                gmailThreadRow.addButton(Kefir.constant({
-                    hasDropdown: options.hasDropdown,
-                    iconClass: options.iconClass,
-                    iconUrl: options.iconUrl,
-                    orderHint: options.orderHint,
-                    onClick: (event) => {
-                        if (!options.onClick)
-                            return;
-                        options.onClick({
-                            position: 'ROW',
-                            dropdown: event.dropdown,
-                            selectedThreadViewDrivers: [],
-                            selectedThreadRowViewDrivers: [gmailThreadRow],
-                        });
-                    },
-                }).merge(unregister));
-            };
-            if (this._currentRouteViewDriver) {
-                this._currentRouteViewDriver
-                    .getRowListViews()
-                    .forEach((gmailRowListView) => {
-                    gmailRowListView.getThreadRowViewDrivers().forEach(perThreadRow);
-                });
-            }
-            const threadRowViewSub = this._threadRowViewDriverKefirStream.observe({
-                value: perThreadRow,
-            });
-            unregister.onValue(() => {
-                threadRowViewSub.unsubscribe();
-            });
-        }
-        return () => {
-            unregister.destroy();
-        };
-    }
-    hashChangeNoViewChange(hash) {
-        if (hash[0] !== '#') {
-            throw new Error('bad hash');
-        }
-        window.history.replaceState(null, null, hash);
-        var hce = new window.HashChangeEvent('hashchange', {
-            oldURL: document.location.href.replace(/#.*$/, '') + '#inboxsdk-fake-no-vc',
-            newURL: document.location.href.replace(/#.*$/, '') + hash,
-        });
-        window.dispatchEvent(hce);
-    }
-    addCustomRouteID(routeID) {
-        this._customRouteIDs.add(routeID);
-        this._pageCommunicator.registerAllowedHashLinkStartTerm(routeID.split('/')[0]);
-        return () => {
-            this._customRouteIDs.delete(routeID);
-        };
-    }
-    addCustomListRouteID(routeID, handler) {
-        this._customListRouteIDs.set(routeID, handler);
-        this._pageCommunicator.registerAllowedHashLinkStartTerm(routeID.split('/')[0]);
-        return () => {
-            this._customListRouteIDs.delete(routeID);
-        };
-    }
-    signalCustomThreadListActivity(customRouteID) {
-        this._lastCustomThreadListActivity = {
-            customRouteID,
-            timestamp: new Date(),
-        };
-    }
-    // Returns the last time a request for a custom thread list search has gone
-    // out or we got a response, and the customRouteID for that.
-    getLastCustomThreadListActivity() {
-        return this._lastCustomThreadListActivity;
-    }
-    showCustomThreadList(customRouteID, onActivate, params) {
-        showCustomThreadList(this, customRouteID, onActivate, params);
-    }
-    showCustomRouteView(element) {
-        showCustomRouteView(this, element);
-    }
-    showNativeRouteView() {
-        showNativeRouteView(this);
-    }
-    createLink(routeID, params) {
-        return createLink(this._gmailRouteProcessor, routeID, params);
-    }
-    goto(routeID, params) {
-        return gotoView(this, routeID, params);
-    }
-    resolveUrlRedirects(url) {
-        return this._pageCommunicatorPromise.then((pageCommunicator) => pageCommunicator.resolveUrlRedirects(url));
-    }
-    registerSearchSuggestionsProvider(handler) {
-        registerSearchSuggestionsProvider(this, handler);
-    }
-    registerSearchQueryRewriter(obj) {
-        registerSearchQueryRewriter(this._pageCommunicator, obj);
-    }
-    addToolbarButtonForApp(buttonDescriptor) {
-        return addToolbarButtonForApp(this, buttonDescriptor);
-    }
-    async openNewComposeViewDriver() {
-        try {
-            const composeViewDriverPromise = this.getNextComposeViewDriver();
-            await openComposeWindow(this);
-            const composeViewDriver = await composeViewDriverPromise;
-            return composeViewDriver;
-        }
-        catch (err) {
-            this._logger.error(err);
-            throw err;
-        }
-    }
-    getNextComposeViewDriver(timeout = 10 * 1000) {
-        return this._composeViewDriverStream
-            .merge(Kefir.later(timeout, new Error('Reached timeout while waiting for getNextComposeViewDriver')))
-            .beforeEnd(() => new Error('Driver was shut down before a new compose was found'))
-            .flatMap((x) => x instanceof Error ? Kefir.constantError(x) : Kefir.constant(x))
-            .take(1)
-            .takeErrors(1)
-            .toPromise();
-    }
-    openDraftByMessageID(messageID) {
-        return openDraftByMessageID(this, messageID);
-    }
-    createModalViewDriver(options) {
-        return new GmailModalViewDriver(options);
-    }
-    createMoleViewDriver(options) {
-        return new GmailMoleViewDriver(this, options);
-    }
-    createDrawerViewDriver(options) {
-        return new InboxDrawerView(options);
-    }
-    createBackdrop(zIndex, target) {
-        return new GmailBackdrop(zIndex, target);
-    }
-    addNavItem(appId, navItemDescriptorPropertyStream, navMenuInjectionContainer) {
-        return addNavItem(this, appId, navItemDescriptorPropertyStream, navMenuInjectionContainer);
-    }
-    addAppMenuItem(menuItemDescriptor) {
-        return addAppMenuItem(this, menuItemDescriptor);
-    }
-    addSupportItem(supportItemDescriptor) {
-        return addSupportItem(this, supportItemDescriptor);
-    }
-    getSentMailNativeNavItem() {
-        const p = getNativeNavItem(this, 'sent');
-        p.catch((err) => this._logger.error(err));
-        return p;
-    }
-    setShowNativeNavMarker(isNative) {
-        this._navMarkerHiddenChanged.emit(null);
-        const leftNavContainerElement = GmailElementGetter.getLeftNavContainerElement();
-        if (leftNavContainerElement) {
-            if (isNative) {
-                leftNavContainerElement.classList.remove('inboxsdk__hide_native_marker');
-            }
-            else {
-                leftNavContainerElement.classList.add('inboxsdk__hide_native_marker');
-                this._stopper.takeUntilBy(this._navMarkerHiddenChanged).onValue(() => {
-                    leftNavContainerElement.classList.remove('inboxsdk__hide_native_marker');
-                });
-            }
-        }
-    }
-    setShowNativeAddonSidebar(isNative) {
-        this._addonSidebarHiddenChanged.emit(null);
-        const addonContainerElement = GmailElementGetter.getAddonSidebarContainerElement();
-        const mainContentBodyContainerElement = GmailElementGetter.getMainContentBodyContainerElement();
-        if (addonContainerElement && mainContentBodyContainerElement) {
-            const parent = mainContentBodyContainerElement.parentElement;
-            if (!parent)
-                return;
-            if (isNative) {
-                parent.classList.remove('inboxsdk__hide_addon_container');
-            }
-            else {
-                parent.classList.add('inboxsdk__hide_addon_container');
-                this._stopper
-                    .takeUntilBy(this._addonSidebarHiddenChanged)
-                    .onValue(() => {
-                    parent.classList.remove('inboxsdk__hide_addon_container');
-                });
-            }
-        }
-    }
-    async getGmailActionToken() {
-        return this._pageCommunicator.getActionTokenValue();
-    }
-    getUserEmailAddress() {
-        return this._pageCommunicator.getUserEmailAddress();
-    }
-    isConversationViewDisabled() {
-        return this._pageCommunicator.isConversationViewDisabled();
-    }
-    getUserLanguage() {
-        return this._pageCommunicator.getUserLanguage();
-    }
-    getUserContact() {
-        return {
-            emailAddress: this.getUserEmailAddress(),
-            name: this._userInfo.getUserName(),
-        };
-    }
-    getAccountSwitcherContactList() {
-        return this._userInfo.getAccountSwitcherContactList();
-    }
-    activateShortcut(keyboardShortcutHandle, appName, appIconUrl) {
-        this.getKeyboardShortcutHelpModifier().set(keyboardShortcutHandle, this._appId, appName, appIconUrl);
-        keyboardShortcutHandle.once('destroy', () => {
-            this.getKeyboardShortcutHelpModifier().delete(keyboardShortcutHandle);
-        });
-    }
-    _setupEventStreams() {
-        var result = makeXhrInterceptor();
-        this._xhrInterceptorStream = result.xhrInterceptStream.takeUntilBy(this._stopper);
-        this._pageCommunicatorPromise = result.pageCommunicatorPromise;
-        this.onready = this._pageCommunicatorPromise.then((pageCommunicator) => {
-            this._timestampGlobalsFound = Date.now();
-            this._pageCommunicator = pageCommunicator;
-            this._logger.setUserEmailAddress(this.getUserEmailAddress());
-            this._logger.setIsUsingSyncAPI(pageCommunicator.isUsingSyncAPI());
-            this._userInfo = new UserInfo(this);
-            this._timestampAccountSwitcherReady = Date.now();
-            this._routeViewDriverStream = setupRouteViewDriverStream(this._gmailRouteProcessor, this)
-                .takeUntilBy(this._stopper)
-                .toProperty();
-            this._routeViewDriverStream.onValue((gmailRouteView) => {
-                this._currentRouteViewDriver = gmailRouteView;
-            });
-            this._rowListViewDriverStream = this._setupRouteSubViewDriver('newGmailRowListView').takeUntilBy(this._stopper);
-            this._setupThreadRowViewDriverKefirStream();
-            this._threadViewDriverLiveSet = toLiveSet(this._setupRouteSubViewDriver('newGmailThreadView')
-                .takeUntilBy(this._stopper)
-                .flatMap((gmailThreadView) => gmailThreadView.getReadyStream().map(() => gmailThreadView))
-                .map((gmailThreadView) => ({
-                el: gmailThreadView,
-                removalStream: gmailThreadView.getStopper(),
-            })));
-            this._setupToolbarViewDriverStream();
-            this._setupMessageViewDriverStream();
-            this._setupComposeViewDriverStream();
-            this._threadRowIdentifier = new ThreadRowIdentifier(this);
-            this._timestampOnready = Date.now();
-        });
-    }
-    _setupComposeViewDriverStream() {
-        this._composeViewDriverStream = setupComposeViewDriverStream(this, this._messageViewDriverStream, this._xhrInterceptorStream).takeUntilBy(this._stopper);
-    }
-    _setupRouteSubViewDriver(viewName) {
-        return this._routeViewDriverStream.flatMap((gmailRouteView) => {
-            return gmailRouteView
-                .getEventStream()
-                .filter((event) => event.eventName === viewName)
-                .map((event) => event.view);
-        });
-    }
-    _setupThreadRowViewDriverKefirStream() {
-        this._threadRowViewDriverKefirStream = this._rowListViewDriverStream
-            .flatMap((rowListViewDriver) => rowListViewDriver.getRowViewDriverStream())
-            .takeUntilBy(this._stopper);
-    }
-    _setupToolbarViewDriverStream() {
-        this._toolbarViewDriverLiveSet = toLiveSet(Kefir.merge([
-            this._rowListViewDriverStream.map((gmailRowListView) => gmailRowListView.getToolbarView()),
-            this.getThreadViewDriverStream().map((gmailThreadView) => gmailThreadView.getToolbarView()),
-        ])
-            .filter(Boolean)
-            .flatMap((gmailToolbarView) => gmailToolbarView.waitForReady())
-            .map((gmailToolbarView) => ({
-            el: gmailToolbarView,
-            removalStream: gmailToolbarView.getStopper(),
-        }))
-            .takeUntilBy(this._stopper));
-        this._toolbarViewDriverLiveSet.subscribe({});
-    }
-    _setupMessageViewDriverStream() {
-        this._messageViewDriverStream = this.getThreadViewDriverStream()
-            .flatMap((gmailThreadView) => gmailThreadView.getMessageViewDriverStream())
-            .takeUntilBy(this._stopper);
-    }
-    async addGlobalSidebarContentPanel(descriptor) {
-        await this.waitForGlobalSidebarReady()
-            .merge(this._stopper.flatMap(() => Kefir.constantError(new Error('Driver instance was destroyed early'))))
-            .take(1)
-            .takeErrors(1)
-            .toPromise();
-        const appSidebar = this.getGlobalSidebar();
-        return appSidebar.addGlobalSidebarContentPanel(descriptor);
-    }
-    waitForGlobalSidebarReady() {
-        const condition = () => GmailElementGetter.getCompanionSidebarContentContainerElement() &&
-            (GmailElementGetter.getCompanionSidebarIconContainerElement() ||
-                GmailElementGetter.getAddonSidebarContainerElement());
-        if (condition()) {
-            return Kefir.constant(undefined);
-        }
-        return waitFor(condition).map(() => undefined);
-    }
-    getGlobalSidebar() {
-        let appSidebarView = this._appSidebarView;
-        if (!appSidebarView) {
-            const companionSidebarContentContainerEl = GmailElementGetter.getCompanionSidebarContentContainerElement();
-            if (!companionSidebarContentContainerEl)
-                throw new Error('did not find companionSidebarContentContainerEl');
-            appSidebarView = this._appSidebarView = new GmailAppSidebarView(this, companionSidebarContentContainerEl);
-        }
-        return appSidebarView;
-    }
-    isRunningInPageContext() {
-        return !!(global.GLOBALS && global._GM_main);
-    }
-    isUsingSyncAPI() {
-        return this._pageCommunicator.isUsingSyncAPI();
-    }
-    showAppIdWarning() {
-        showAppIdWarning(this);
-    }
-    createTopMessageBarDriver(optionStream) {
-        return new GmailTopMessageBarDriver(optionStream);
-    }
-    associateThreadAndMessageIDs(threadID, messageID) {
-        this._messageIDsToThreadIDs.set(messageID, threadID);
-    }
-    getThreadIDForMessageID(messageID) {
-        return get(this._messageIDsToThreadIDs, messageID);
-    }
-    getDraftIDForMessageID(messageID, skipCache = false) {
-        return getDraftIDForMessageID(this, messageID, skipCache);
-    }
-    _recentSyncDraftIds = new Map();
-    reportRecentSyncDraftId(syncDraftId) {
-        const count = this._recentSyncDraftIds.get(syncDraftId);
-        const newCount = (count ?? 0) + 1;
-        this._recentSyncDraftIds.set(syncDraftId, newCount);
-    }
-    reportDraftClosed(syncDraftId) {
-        Kefir.later(30 * 1000, undefined)
-            .takeUntilBy(this._stopper)
-            .onValue(() => {
-            const count = this._recentSyncDraftIds.get(syncDraftId);
-            let newCount;
-            if (count == null || count < 1) {
-                newCount = 0;
-                this._logger.error(new Error('_recentSyncDraftIds count had unexpected value'), {
-                    count,
-                });
-            }
-            else {
-                newCount = count - 1;
-            }
-            if (newCount === 0) {
-                this._recentSyncDraftIds.delete(syncDraftId);
-            }
-            else {
-                this._recentSyncDraftIds.set(syncDraftId, newCount);
-            }
-        });
-    }
-    isRecentSyncDraftId(syncMessageId) {
-        return this._recentSyncDraftIds.has(syncMessageId);
-    }
-    _selectedThreadRows = t.mapcat((gmailRowListView) => gmailRowListView.getSelectedThreadRowViewDrivers());
-    getSelectedThreadRowViewDrivers() {
-        if (!this._currentRouteViewDriver) {
-            return [];
-        }
-        return t.toArray(this._currentRouteViewDriver.getRowListViews(), this._selectedThreadRows);
-    }
-    _threadRowViewSelectionChanges = kefirBus();
-    signalThreadRowViewSelectionChange() {
-        this._threadRowViewSelectionChanges.value(undefined);
-    }
-    registerThreadRowViewSelectionHandler(handler) {
-        this._threadRowViewSelectionChanges.onValue(handler);
-        return () => {
-            this._threadRowViewSelectionChanges.offValue(handler);
-        };
-    }
-}
-export default GmailDriver;