@inboxsdk/core 0.2.28-alpha.6 → 0.2.28

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

@@ -1,126 +1,206 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _toValueObservable = _interopRequireDefault(require("live-set/toValueObservable"));
-var _ud = require("ud");
-var _transducers = _interopRequireDefault(require("transducers.js"));
-var _kefir = _interopRequireDefault(require("kefir"));
-var _kefirStopper = _interopRequireDefault(require("kefir-stopper"));
-var _kefirBus = _interopRequireDefault(require("kefir-bus"));
-var _asap = _interopRequireDefault(require("asap"));
-var _includes = _interopRequireDefault(require("lodash/includes"));
-var _getOrFail = _interopRequireDefault(require("../../../common/get-or-fail"));
-var _showAppIdWarning = _interopRequireDefault(require("./gmail-driver/show-app-id-warning"));
-var _makePageParserTree = _interopRequireDefault(require("./makePageParserTree"));
-var _gmailElementGetter = _interopRequireDefault(require("./gmail-element-getter"));
-var _makeXhrInterceptor = _interopRequireDefault(require("./make-xhr-interceptor"));
-var _gmailBackdrop = _interopRequireDefault(require("./views/gmail-backdrop"));
-var _gmailThreadRowView = require("./views/gmail-thread-row-view");
-var _gmailTopMessageBarDriver = _interopRequireDefault(require("./widgets/gmail-top-message-bar-driver"));
-var _gmailModalViewDriver = _interopRequireDefault(require("./widgets/gmail-modal-view-driver"));
-var _gmailMoleViewDriver = _interopRequireDefault(require("./widgets/gmail-mole-view-driver"));
-var _inboxDrawerView = _interopRequireDefault(require("../inbox/views/inbox-drawer-view"));
-var _gmailRouteProcessor = _interopRequireDefault(require("./views/gmail-route-view/gmail-route-processor"));
-var _keyboardShortcutHelpModifier = _interopRequireDefault(require("./gmail-driver/keyboard-shortcut-help-modifier"));
-var _openDraftByMessageId = _interopRequireDefault(require("./gmail-driver/open-draft-by-message-id"));
-var _userInfo = _interopRequireDefault(require("./gmail-driver/user-info"));
-var _gmailButterBarDriver = _interopRequireDefault(require("./gmail-butter-bar-driver"));
-var _trackGmailStyles = _interopRequireDefault(require("./gmail-driver/track-gmail-styles"));
-var _temporaryTrackDownloadUrlValidity = _interopRequireDefault(require("./gmail-driver/temporary-track-download-url-validity"));
-var _getGmailThreadIdForRfcMessageId = _interopRequireDefault(require("../../driver-common/getGmailThreadIdForRfcMessageId"));
-var _getRfcMessageIdForGmailThreadId = _interopRequireDefault(require("./gmail-driver/get-rfc-message-id-for-gmail-thread-id"));
-var _getGmailMessageIdForSyncMessageId = _interopRequireDefault(require("../../driver-common/getGmailMessageIdForSyncMessageId"));
-var _bimapcache = _interopRequireDefault(require("bimapcache"));
-var _getDraftIdForMessageId = _interopRequireDefault(require("./gmail-driver/get-draft-id-for-message-id"));
-var _addNavItem = _interopRequireDefault(require("./gmail-driver/add-nav-item"));
-var _addAppMenuItem = require("./gmail-driver/add-app-menu-item");
-var _addSupportItem = _interopRequireDefault(require("./gmail-driver/add-support-item"));
-var _gotoView = _interopRequireDefault(require("./gmail-driver/goto-view"));
-var _showCustomThreadList = _interopRequireDefault(require("./gmail-driver/show-custom-thread-list"));
-var _showCustomRouteView = _interopRequireDefault(require("./gmail-driver/show-custom-route-view"));
-var _showNativeRouteView = _interopRequireDefault(require("./gmail-driver/show-native-route-view"));
-var _registerSearchSuggestionsProvider = _interopRequireDefault(require("./gmail-driver/register-search-suggestions-provider"));
-var _setupComposeViewDriverStream = _interopRequireDefault(require("./gmail-driver/setup-compose-view-driver-stream"));
-var _trackEvents = _interopRequireDefault(require("./gmail-driver/track-events"));
-var _gmailLoadEvent = _interopRequireDefault(require("./gmail-driver/gmail-load-event"));
-var _threadRowIdentifier = _interopRequireDefault(require("./gmail-driver/thread-row-identifier"));
-var _customStyle = _interopRequireDefault(require("./custom-style"));
-var _overrideGmailBackButton = _interopRequireDefault(require("./gmail-driver/override-gmail-back-button"));
-var _addToolbarButtonForApp = _interopRequireDefault(require("./gmail-driver/add-toolbar-button-for-app"));
-var _setupRouteViewDriverStream = _interopRequireDefault(require("./gmail-driver/setup-route-view-driver-stream"));
-var _getNativeNavItem = _interopRequireDefault(require("./gmail-driver/get-native-nav-item"));
-var _createLink = _interopRequireDefault(require("./gmail-driver/create-link"));
-var _registerSearchQueryRewriter = _interopRequireDefault(require("./gmail-driver/register-search-query-rewriter"));
-var _openComposeWindow = _interopRequireDefault(require("./gmail-driver/open-compose-window"));
-var _gmailAppSidebarView = _interopRequireDefault(require("./views/gmail-app-sidebar-view"));
-var _suppressAddon = _interopRequireDefault(require("./gmail-driver/suppressAddon"));
-var _getSyncThreadFromSyncThreadId = _interopRequireDefault(require("./gmail-driver/getSyncThreadFromSyncThreadId"));
-var _getSyncThreadForOldGmailThreadId = _interopRequireDefault(require("./gmail-driver/getSyncThreadForOldGmailThreadId"));
-var _toItemWithLifetimeStream = _interopRequireDefault(require("../../lib/toItemWithLifetimeStream"));
-var _toLiveSet = _interopRequireDefault(require("../../lib/toLiveSet"));
-var _streamWaitFor = _interopRequireDefault(require("../../lib/stream-wait-for"));
-var _waitFor = _interopRequireDefault(require("../../lib/wait-for"));
-var _gmailNavItemView = _interopRequireDefault(require("./views/gmail-nav-item-view"));
+/* @flow */
+
+import type LiveSet from 'live-set';
+import toValueObservable from 'live-set/toValueObservable';
+import { defn } from 'ud';
+import t from 'transducers.js';
+import Kefir from 'kefir';
+import kefirStopper from 'kefir-stopper';
+import kefirBus from 'kefir-bus';
+import type { Bus } from 'kefir-bus';
+import type { TagTree } from 'tag-tree';
+import type PageParserTree from 'page-parser-tree';
+import asap from 'asap';
+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 type GmailThreadRowView from './views/gmail-thread-row-view';
+import type GmailAppToolbarButtonView from './views/gmail-app-toolbar-button-view';
+
+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 type KeyboardShortcutHandle from '../../views/keyboard-shortcut-handle';
+import getDraftIDForMessageID from './gmail-driver/get-draft-id-for-message-id';
+import type { GetDraftIdResult } from './gmail-driver/get-draft-id-for-message-id';
+import addNavItem from './gmail-driver/add-nav-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 customStyle from './custom-style';
+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';
+import promiseWaitFor from '../../lib/wait-for';
+
+import type Logger from '../../lib/logger';
+import type PageCommunicator from './gmail-page-communicator';
+import type { RouteParams } from '../../namespaces/router';
+import type ButterBar from '../../namespaces/butter-bar';
+import type { Driver, DrawerViewOptions } from '../../driver-interfaces/driver';
+import type { ComposeViewDriver } from '../../driver-interfaces/compose-view-driver';
+import type GmailComposeView from './views/gmail-compose-view';
+import type GmailMessageView from './views/gmail-message-view';
+import type GmailThreadView from './views/gmail-thread-view';
+import type GmailToolbarView from './views/gmail-toolbar-view';
+import type GmailRowListView from './views/gmail-row-list-view';
+import type GmailRouteView from './views/gmail-route-view/gmail-route-view';
+import type GmailSupportItemView from './views/gmail-support-item-view';
+import type SupportItemDescriptor from './views/gmail-support-item-view';
+import type { PiOpts, EnvData } from '../../platform-implementation';
+import type NativeGmailNavItemView from './views/native-gmail-nav-item-view';
+
+import type ContentPanelViewDriver from '../../driver-common/sidebar/ContentPanelViewDriver';
+import GmailNavItemView from './views/gmail-nav-item-view';
+
 class GmailDriver {
-  constructor(appId, LOADER_VERSION, IMPL_VERSION, logger, opts, envData) {
-    (0, _defineProperty2.default)(this, "_customRouteIDs", new Set());
-    (0, _defineProperty2.default)(this, "_customListRouteIDs", new Map());
-    (0, _defineProperty2.default)(this, "_customListSearchStringsToRouteIds", new Map());
-    (0, _defineProperty2.default)(this, "_messageIDsToThreadIDs", new Map());
-    (0, _defineProperty2.default)(this, "_stopper", (0, _kefirStopper.default)());
-    (0, _defineProperty2.default)(this, "_navMarkerHiddenChanged", (0, _kefirBus.default)());
-    (0, _defineProperty2.default)(this, "_addonSidebarHiddenChanged", (0, _kefirBus.default)());
-    (0, _defineProperty2.default)(this, "_appSidebarView", null);
-    (0, _defineProperty2.default)(this, "_recentSyncDraftIds", new Map());
-    (0, _defineProperty2.default)(this, "_selectedThreadRows", _transducers.default.mapcat(gmailRowListView => gmailRowListView.getSelectedThreadRowViewDrivers()));
-    (0, _defineProperty2.default)(this, "_threadRowViewSelectionChanges", (0, _kefirBus.default)());
-    this; // interface check
-    (0, _customStyle.default)();
+  _appId: string;
+  _logger: Logger;
+  _opts: PiOpts;
+  _envData: EnvData;
+  _customRouteIDs: Set<string> = new Set();
+  _customListRouteIDs: Map<string, Function> = new Map();
+  _customListSearchStringsToRouteIds: Map<string, string> = new Map();
+  _messageIDsToThreadIDs: Map<string, string> = new Map();
+  _threadRowIdentifier: ThreadRowIdentifier;
+  _gmailRouteProcessor: GmailRouteProcessor;
+  _keyboardShortcutHelpModifier: KeyboardShortcutHelpModifier;
+  onready: Promise<void>;
+  _page: PageParserTree;
+  _pageCommunicator: PageCommunicator;
+  _pageCommunicatorPromise: Promise<PageCommunicator>;
+  _butterBar: ?ButterBar;
+  _butterBarDriver: GmailButterBarDriver;
+  _routeViewDriverStream: Kefir.Observable<GmailRouteView>;
+  _rowListViewDriverStream: Kefir.Observable<Object>;
+  _threadRowViewDriverKefirStream: Kefir.Observable<Object>;
+  _threadViewDriverLiveSet: LiveSet<GmailThreadView>;
+  _toolbarViewDriverLiveSet: LiveSet<GmailToolbarView>;
+  _composeViewDriverStream: Kefir.Observable<GmailComposeView>;
+  _xhrInterceptorStream: Kefir.Observable<Object>;
+  _messageViewDriverStream: Kefir.Observable<GmailMessageView>;
+  _stopper = kefirStopper();
+  _navMarkerHiddenChanged: Bus<null> = kefirBus();
+  _addonSidebarHiddenChanged: Bus<null> = kefirBus();
+  _userInfo: UserInfo;
+  _timestampAccountSwitcherReady: ?number;
+  _timestampGlobalsFound: ?number;
+  _timestampOnready: ?number;
+  _lastCustomThreadListActivity: ?{ customRouteID: string, timestamp: Date };
+  _currentRouteViewDriver: GmailRouteView;
+  _appSidebarView: ?GmailAppSidebarView = null;
+
+  getGmailThreadIdForRfcMessageId: (rfcId: string) => Promise<string>;
+  getRfcMessageIdForGmailThreadId: (threadId: string) => Promise<string>;
+  getSyncThreadIdForOldGmailThreadId: (threadId: string) => Promise<string>;
+  getOldGmailThreadIdFromSyncThreadId: (threadId: string) => Promise<string>;
+  removeCachedOldGmailThreadIdFromSyncThreadId: (threadId: string) => void;
+
+  getGmailMessageIdForSyncDraftId: (syncDraftId: string) => Promise<string>;
+  getGmailMessageIdForSyncMessageId: (syncMessageId: string) => Promise<string>;
+  removeCachedGmailMessageIdForSyncMessageId: (syncMessageID: string) => void;
+
+  constructor(
+    appId: string,
+    LOADER_VERSION: string,
+    IMPL_VERSION: string,
+    logger: Logger,
+    opts: PiOpts,
+    envData: EnvData
+  ) {
+    (this: Driver); // interface check
+    customStyle();
+
     this._appId = appId;
     this._logger = logger;
     this._opts = opts;
     this._envData = envData;
-    this._page = (0, _makePageParserTree.default)(this, document);
+    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.default({
+      const rfcIdCache = new BiMapCache({
         key: 'inboxsdk__cached_thread_ids',
-        getAfromB: gmailThreadId => (0, _getRfcMessageIdForGmailThreadId.default)(this, gmailThreadId),
-        getBfromA: rfcMessageId => (0, _getGmailThreadIdForRfcMessageId.default)(this, rfcMessageId)
+        getAfromB: (gmailThreadId) =>
+          getRfcMessageIdForGmailThreadId(this, gmailThreadId),
+        getBfromA: (rfcMessageId) =>
+          getGmailThreadIdForRfcMessageId(this, rfcMessageId),
       });
-      this.getGmailThreadIdForRfcMessageId = rfcMessageId => rfcIdCache.getBfromA(rfcMessageId);
-      this.getRfcMessageIdForGmailThreadId = gmailThreadId => rfcIdCache.getAfromB(gmailThreadId);
+      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.default({
+      const syncThreadIdToOldGmailThreadIdCache = new BiMapCache({
         key: 'inboxsdk__cached_sync_thread_id_old_gmail_thread_id',
-        getAfromB: oldGmailThreadId => {
-          return (0, _getSyncThreadForOldGmailThreadId.default)(this, oldGmailThreadId).then(_ref => {
-            let {
-              syncThreadID
-            } = _ref;
-            return syncThreadID;
-          });
+        getAfromB: (oldGmailThreadId: string) => {
+          return getSyncThreadForOldGmailThreadId(this, oldGmailThreadId).then(
+            ({ syncThreadID }) => syncThreadID
+          );
+        },
+        getBfromA: (syncThreadID: string) => {
+          return getSyncThreadFromSyncThreadId(this, syncThreadID).then(
+            (syncThread) => {
+              if (syncThread) return syncThread.oldGmailThreadID;
+              else throw new Error('syncThread not found');
+            }
+          );
         },
-        getBfromA: syncThreadID => {
-          return (0, _getSyncThreadFromSyncThreadId.default)(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);
+      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
@@ -128,92 +208,111 @@ class GmailDriver {
       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');
+        localStorage.removeItem(
+          'inboxsdk__cached_gmail_and_inbox_message_ids_2'
+        );
       } catch (err) {
         // eslint-disable-next-line no-console
         console.error(err);
       }
-      const gmailMessageIdForSyncMessageIdCache = new _bimapcache.default({
+      const gmailMessageIdForSyncMessageIdCache = new BiMapCache({
         key: 'inboxsdk__cached_gmail_and_inbox_message_ids_3',
-        getAfromB: sync => (0, _getGmailMessageIdForSyncMessageId.default)(this, sync),
+        getAfromB: (sync: string) =>
+          getGmailMessageIdForSyncMessageId(this, sync),
         getBfromA() {
           throw new Error('should not happen');
-        }
+        },
       });
-      this.getGmailMessageIdForSyncMessageId = syncMessageId => gmailMessageIdForSyncMessageIdCache.getAfromB(syncMessageId);
-      this.removeCachedGmailMessageIdForSyncMessageId = syncMessageId => gmailMessageIdForSyncMessageIdCache.removeBfromCache(syncMessageId);
+      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 => (0, _getGmailMessageIdForSyncMessageId.default)(this, syncDraftId);
+      this.getGmailMessageIdForSyncDraftId = (syncDraftId) =>
+        getGmailMessageIdForSyncMessageId(this, syncDraftId);
     }
-    this._gmailRouteProcessor = new _gmailRouteProcessor.default();
-    this._keyboardShortcutHelpModifier = new _keyboardShortcutHelpModifier.default();
-    this._butterBarDriver = new _gmailButterBarDriver.default();
-    _kefir.default.later(45 * 1000).takeUntilBy((0, _toItemWithLifetimeStream.default)(this._page.tree.getAllByTag('supportMenu'))).onValue(() => {
-      this._logger.errorSite(new Error('Failed to find gmail supportMenu'));
-    });
+
+    this._gmailRouteProcessor = new GmailRouteProcessor();
+    this._keyboardShortcutHelpModifier = new KeyboardShortcutHelpModifier();
+    this._butterBarDriver = new GmailButterBarDriver();
+
+    Kefir.later(45 * 1000)
+      .takeUntilBy(
+        toItemWithLifetimeStream(this._page.tree.getAllByTag('supportMenu'))
+      )
+      .onValue(() => {
+        this._logger.errorSite(new Error('Failed to find gmail supportMenu'));
+      });
+
     this._setupEventStreams();
-    this.onready.then(() => {
-      (0, _trackEvents.default)(this);
-      (0, _gmailLoadEvent.default)(this);
-      (0, _overrideGmailBackButton.default)(this, this._gmailRouteProcessor);
-      (0, _trackGmailStyles.default)();
-      (0, _temporaryTrackDownloadUrlValidity.default)(this);
-      if (opts.suppressAddonTitle != null) {
-        (0, _suppressAddon.default)(this, opts.suppressAddonTitle);
-      }
-    }).catch(err => {
-      this._logger.error(err);
-    });
+
+    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();
-    (0, _gmailThreadRowView.removeAllThreadRowUnclaimedModifications)();
+
+    removeAllThreadRowUnclaimedModifications();
   }
-  getAppId() {
+
+  getAppId(): string {
     return this._appId;
   }
-  getOpts() {
+  getOpts(): PiOpts {
     return this._opts;
   }
-  getPageCommunicator() {
+  getPageCommunicator(): PageCommunicator {
     return this._pageCommunicator;
   }
-  getPageCommunicatorPromise() {
+  getPageCommunicatorPromise(): Promise<PageCommunicator> {
     return this._pageCommunicatorPromise;
   }
-  getLogger() {
+  getLogger(): Logger {
     return this._logger;
   }
-  getTagTree() {
+  getTagTree(): TagTree<HTMLElement> {
     return this._page.tree;
   }
-  getCustomListSearchStringsToRouteIds() {
+  getCustomListSearchStringsToRouteIds(): Map<string, string> {
     return this._customListSearchStringsToRouteIds;
   }
-  getThreadRowIdentifier() {
+  getThreadRowIdentifier(): ThreadRowIdentifier {
     return this._threadRowIdentifier;
   }
-  getButterBarDriver() {
+  getButterBarDriver(): GmailButterBarDriver {
     return this._butterBarDriver;
   }
-  getButterBar() {
+  getButterBar(): ?ButterBar {
     return this._butterBar;
   }
-  setButterBar(bb) {
+  setButterBar(bb: ButterBar) {
     this._butterBar = bb;
   }
-  getCustomRouteIDs() {
+  getCustomRouteIDs(): Set<string> {
     return this._customRouteIDs;
   }
-  getCustomListRouteIDs() {
+  getCustomListRouteIDs(): Map<string, Function> {
     return this._customListRouteIDs;
   }
-  getKeyboardShortcutHelpModifier() {
+  getKeyboardShortcutHelpModifier(): KeyboardShortcutHelpModifier {
     return this._keyboardShortcutHelpModifier;
   }
   getRouteViewDriverStream() {
@@ -226,32 +325,41 @@ class GmailDriver {
     return this._threadRowViewDriverKefirStream;
   }
   getThreadViewDriverStream() {
-    return (0, _toItemWithLifetimeStream.default)(this._threadViewDriverLiveSet).map(_ref2 => {
-      let {
-        el
-      } = _ref2;
-      return el;
-    });
+    return toItemWithLifetimeStream(this._threadViewDriverLiveSet).map(
+      ({ el }) => el
+    );
   }
   getAttachmentCardViewDriverStream() {
-    return this._messageViewDriverStream.flatMap(messageViewDriver => messageViewDriver.isLoaded() ? _kefir.default.constant(messageViewDriver) : messageViewDriver.getEventStream().filter(event => event.eventName === 'messageLoad').map(() => messageViewDriver).take(1)).map(messageView => messageView.getAttachmentCardViewDrivers()).flatten();
+    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() {
+  getXhrInterceptorStream(): Kefir.Observable<Object> {
     return this._xhrInterceptorStream;
   }
   getMessageViewDriverStream() {
     return this._messageViewDriverStream;
   }
-  getStopper() {
+  getStopper(): Kefir.Observable<null> {
     return this._stopper;
   }
-  getEnvData() {
+  getEnvData(): EnvData {
     return this._envData;
   }
-  getTimestampOnReady() {
+
+  getTimestampOnReady(): number {
     if (this._timestampOnready == null) {
       this._logger.error(new Error('getTimestampOnReady called before ready'));
       return Date.now();
@@ -261,169 +369,218 @@ class GmailDriver {
 
   // Returns a stream that emits an event once at least `time` milliseconds has
   // passed since the GmailDriver's ready event.
-  delayToTimeAfterReady(time) {
+  delayToTimeAfterReady(time: number): Kefir.Observable<void> {
     const targetTime = this.getTimestampOnReady() + time;
     const timeToWait = Math.max(0, targetTime - Date.now());
-    return _kefir.default.later(timeToWait);
+    return Kefir.later(timeToWait);
   }
-  getTimings() {
+
+  getTimings(): { [ix: string]: ?number } {
     return {
       piMainStarted: this._envData.piMainStarted,
       piLoadStarted: this._envData.piLoadStarted,
       globalsFound: this._timestampGlobalsFound,
       accountSwitcherReady: this._timestampAccountSwitcherReady,
-      onready: this._timestampOnready
+      onready: this._timestampOnready,
     };
   }
-  registerThreadButton(options) {
-    const unregister = (0, _kefirStopper.default)();
-    const removeButtonOnUnregister = button => {
+
+  registerThreadButton(options: Object) {
+    const unregister = kefirStopper();
+
+    const removeButtonOnUnregister = (button) => {
       unregister.takeUntilBy(button.getStopper()).onValue(() => {
         button.destroy();
       });
     };
-    const toolbarViewSub = (0, _toValueObservable.default)(this._toolbarViewDriverLiveSet).subscribe(_ref3 => {
-      let {
-        value: gmailToolbarView
-      } = _ref3;
+
+    const toolbarViewSub = toValueObservable(
+      this._toolbarViewDriverLiveSet
+    ).subscribe(({ value: gmailToolbarView }: { value: GmailToolbarView }) => {
       if (gmailToolbarView.isForThread()) {
-        if (!options.positions || (0, _includes.default)(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: []
-              });
-            }
-          }));
+        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 || (0, _includes.default)(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
-              });
-            }
-          }));
+        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 || (0, _includes.default)(options.positions, 'ROW')) {
-      const perThreadRow = gmailThreadRow => {
-        gmailThreadRow.addButton(_kefir.default.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 (!options.positions || includes(options.positions, 'ROW')) {
+      const perThreadRow = (gmailThreadRow: GmailThreadRowView) => {
+        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);
-        });
+        this._currentRouteViewDriver
+          .getRowListViews()
+          .forEach((gmailRowListView) => {
+            gmailRowListView.getThreadRowViewDrivers().forEach(perThreadRow);
+          });
       }
       const threadRowViewSub = this._threadRowViewDriverKefirStream.observe({
-        value: perThreadRow
+        value: perThreadRow,
       });
       unregister.onValue(() => {
         threadRowViewSub.unsubscribe();
       });
     }
+
     return () => {
       unregister.destroy();
     };
   }
-  hashChangeNoViewChange(hash) {
+
+  hashChangeNoViewChange(hash: string) {
     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
+    var hce = new (window: any).HashChangeEvent('hashchange', {
+      oldURL:
+        document.location.href.replace(/#.*$/, '') + '#inboxsdk-fake-no-vc',
+      newURL: document.location.href.replace(/#.*$/, '') + hash,
     });
     window.dispatchEvent(hce);
   }
-  addCustomRouteID(routeID) {
+
+  addCustomRouteID(routeID: string): () => void {
     this._customRouteIDs.add(routeID);
-    this._pageCommunicator.registerAllowedHashLinkStartTerm(routeID.split('/')[0]);
+    this._pageCommunicator.registerAllowedHashLinkStartTerm(
+      routeID.split('/')[0]
+    );
     return () => {
       this._customRouteIDs.delete(routeID);
     };
   }
-  addCustomListRouteID(routeID, handler) {
+
+  addCustomListRouteID(routeID: string, handler: Function): () => void {
     this._customListRouteIDs.set(routeID, handler);
-    this._pageCommunicator.registerAllowedHashLinkStartTerm(routeID.split('/')[0]);
+    this._pageCommunicator.registerAllowedHashLinkStartTerm(
+      routeID.split('/')[0]
+    );
     return () => {
       this._customListRouteIDs.delete(routeID);
     };
   }
-  signalCustomThreadListActivity(customRouteID) {
+
+  signalCustomThreadListActivity(customRouteID: string) {
     this._lastCustomThreadListActivity = {
       customRouteID,
-      timestamp: new Date()
+      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() {
+  getLastCustomThreadListActivity(): ?{
+    customRouteID: string,
+    timestamp: Date,
+  } {
     return this._lastCustomThreadListActivity;
   }
-  showCustomThreadList(customRouteID, onActivate, params) {
-    (0, _showCustomThreadList.default)(this, customRouteID, onActivate, params);
+
+  showCustomThreadList(
+    customRouteID: string,
+    onActivate: Function,
+    params: Array<string>
+  ) {
+    showCustomThreadList(this, customRouteID, onActivate, params);
   }
-  showCustomRouteView(element) {
-    (0, _showCustomRouteView.default)(this, element);
+
+  showCustomRouteView(element: HTMLElement) {
+    showCustomRouteView(this, element);
   }
+
   showNativeRouteView() {
-    (0, _showNativeRouteView.default)(this);
+    showNativeRouteView(this);
   }
-  createLink(routeID, params) {
-    return (0, _createLink.default)(this._gmailRouteProcessor, routeID, params);
+
+  createLink(routeID: string, params: ?RouteParams | string) {
+    return createLink(this._gmailRouteProcessor, routeID, params);
   }
-  goto(routeID, params) {
-    return (0, _gotoView.default)(this, routeID, params);
+
+  goto(routeID: string, params: ?RouteParams | string): Promise<void> {
+    return gotoView(this, routeID, params);
   }
-  resolveUrlRedirects(url) {
-    return this._pageCommunicatorPromise.then(pageCommunicator => pageCommunicator.resolveUrlRedirects(url));
+
+  resolveUrlRedirects(url: string): Promise<string> {
+    return this._pageCommunicatorPromise.then((pageCommunicator) =>
+      pageCommunicator.resolveUrlRedirects(url)
+    );
   }
-  registerSearchSuggestionsProvider(handler) {
-    (0, _registerSearchSuggestionsProvider.default)(this, handler);
+
+  registerSearchSuggestionsProvider(handler: Function) {
+    registerSearchSuggestionsProvider(this, handler);
   }
-  registerSearchQueryRewriter(obj) {
-    (0, _registerSearchQueryRewriter.default)(this._pageCommunicator, obj);
+
+  registerSearchQueryRewriter(obj: Object) {
+    registerSearchQueryRewriter(this._pageCommunicator, obj);
   }
-  addToolbarButtonForApp(buttonDescriptor) {
-    return (0, _addToolbarButtonForApp.default)(this, buttonDescriptor);
+
+  addToolbarButtonForApp(
+    buttonDescriptor: Object
+  ): Promise<GmailAppToolbarButtonView> {
+    return addToolbarButtonForApp(this, buttonDescriptor);
   }
-  async openNewComposeViewDriver() {
+
+  async openNewComposeViewDriver(): Promise<GmailComposeView> {
     try {
       const composeViewDriverPromise = this.getNextComposeViewDriver();
-      await (0, _openComposeWindow.default)(this);
+      await openComposeWindow(this);
       const composeViewDriver = await composeViewDriverPromise;
       return composeViewDriver;
     } catch (err) {
@@ -431,231 +588,402 @@ class GmailDriver {
       throw err;
     }
   }
-  getNextComposeViewDriver() {
-    let timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10 * 1000;
-    return this._composeViewDriverStream.merge(_kefir.default.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.default.constantError(x) : _kefir.default.constant(x)).take(1).takeErrors(1).toPromise();
-  }
-  openDraftByMessageID(messageID) {
-    return (0, _openDraftByMessageId.default)(this, messageID);
+
+  getNextComposeViewDriver(
+    timeout: number = 10 * 1000
+  ): Promise<GmailComposeView> {
+    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();
   }
-  createModalViewDriver(options) {
-    return new _gmailModalViewDriver.default(options);
+
+  openDraftByMessageID(messageID: string): Promise<void> {
+    return openDraftByMessageID(this, messageID);
   }
-  createMoleViewDriver(options) {
-    return new _gmailMoleViewDriver.default(this, options);
+
+  createModalViewDriver(options: Object): GmailModalViewDriver {
+    return new GmailModalViewDriver(options);
   }
-  createDrawerViewDriver(options) {
-    return new _inboxDrawerView.default(options);
+
+  createMoleViewDriver(options: Object): GmailMoleViewDriver {
+    return new GmailMoleViewDriver(this, options);
   }
-  createBackdrop(zIndex, target) {
-    return new _gmailBackdrop.default(zIndex, target);
+
+  createDrawerViewDriver(options: DrawerViewOptions) {
+    return new InboxDrawerView(options);
   }
-  addNavItem(appId, navItemDescriptorPropertyStream, navMenuInjectionContainer) {
-    return (0, _addNavItem.default)(this, appId, navItemDescriptorPropertyStream, navMenuInjectionContainer);
+
+  createBackdrop(zIndex?: number, target?: HTMLElement) {
+    return new GmailBackdrop(zIndex, target);
   }
-  addAppMenuItem(menuItemDescriptor) {
-    return (0, _addAppMenuItem.addAppMenuItem)(this, menuItemDescriptor);
+
+  addNavItem(
+    appId: string,
+    navItemDescriptorPropertyStream: Kefir.Observable<Object>
+  ): Promise<GmailNavItemView> {
+    return addNavItem(this, appId, navItemDescriptorPropertyStream);
   }
-  addSupportItem(supportItemDescriptor) {
-    return (0, _addSupportItem.default)(this, supportItemDescriptor);
+
+  addSupportItem(
+    supportItemDescriptor: SupportItemDescriptor
+  ): GmailSupportItemView {
+    return addSupportItem(this, supportItemDescriptor);
   }
-  getSentMailNativeNavItem() {
-    const p = (0, _getNativeNavItem.default)(this, 'sent');
-    p.catch(err => this._logger.error(err));
+
+  getSentMailNativeNavItem(): Promise<NativeGmailNavItemView> {
+    const p = getNativeNavItem(this, 'sent');
+    p.catch((err) => this._logger.error(err));
     return p;
   }
-  setShowNativeNavMarker(isNative) {
+
+  setShowNativeNavMarker(isNative: boolean) {
     this._navMarkerHiddenChanged.emit(null);
-    const leftNavContainerElement = _gmailElementGetter.default.getLeftNavContainerElement();
+    const leftNavContainerElement =
+      GmailElementGetter.getLeftNavContainerElement();
     if (leftNavContainerElement) {
       if (isNative) {
-        leftNavContainerElement.classList.remove('inboxsdk__hide_native_marker');
+        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');
+          leftNavContainerElement.classList.remove(
+            'inboxsdk__hide_native_marker'
+          );
         });
       }
     }
   }
-  setShowNativeAddonSidebar(isNative) {
+
+  setShowNativeAddonSidebar(isNative: boolean) {
     this._addonSidebarHiddenChanged.emit(null);
-    const addonContainerElement = _gmailElementGetter.default.getAddonSidebarContainerElement();
-    const mainContentBodyContainerElement = _gmailElementGetter.default.getMainContentBodyContainerElement();
+    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');
-        });
+        this._stopper
+          .takeUntilBy(this._addonSidebarHiddenChanged)
+          .onValue(() => {
+            parent.classList.remove('inboxsdk__hide_addon_container');
+          });
       }
     }
   }
-  async getGmailActionToken() {
+
+  async getGmailActionToken(): Promise<string> {
     return this._pageCommunicator.getActionTokenValue();
   }
-  getUserEmailAddress() {
+
+  getUserEmailAddress(): string {
     return this._pageCommunicator.getUserEmailAddress();
   }
-  isConversationViewDisabled() {
+
+  isConversationViewDisabled(): Promise<boolean> {
     return this._pageCommunicator.isConversationViewDisabled();
   }
-  getUserLanguage() {
+
+  getUserLanguage(): string {
     return this._pageCommunicator.getUserLanguage();
   }
-  getUserContact() {
+
+  getUserContact(): Contact {
     return {
       emailAddress: this.getUserEmailAddress(),
-      name: this._userInfo.getUserName()
+      name: this._userInfo.getUserName(),
     };
   }
-  getAccountSwitcherContactList() {
+
+  getAccountSwitcherContactList(): Contact[] {
     return this._userInfo.getAccountSwitcherContactList();
   }
-  activateShortcut(keyboardShortcutHandle, appName, appIconUrl) {
-    this.getKeyboardShortcutHelpModifier().set(keyboardShortcutHandle, this._appId, appName, appIconUrl);
+
+  activateShortcut(
+    keyboardShortcutHandle: KeyboardShortcutHandle,
+    appName: ?string,
+    appIconUrl: ?string
+  ) {
+    this.getKeyboardShortcutHelpModifier().set(
+      keyboardShortcutHandle,
+      this._appId,
+      appName,
+      appIconUrl
+    );
     keyboardShortcutHandle.once('destroy', () => {
       this.getKeyboardShortcutHelpModifier().delete(keyboardShortcutHandle);
     });
   }
+
   _setupEventStreams() {
-    var result = (0, _makeXhrInterceptor.default)();
-    this._xhrInterceptorStream = result.xhrInterceptStream.takeUntilBy(this._stopper);
+    var result = makeXhrInterceptor();
+
+    this._xhrInterceptorStream = result.xhrInterceptStream.takeUntilBy(
+      this._stopper
+    );
+
     this._pageCommunicatorPromise = result.pageCommunicatorPromise;
-    this.onready = this._pageCommunicatorPromise.then(pageCommunicator => {
+
+    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.default(this);
+      this._userInfo = new UserInfo(this);
+
       this._timestampAccountSwitcherReady = Date.now();
-      this._routeViewDriverStream = (0, _setupRouteViewDriverStream.default)(this._gmailRouteProcessor, this).takeUntilBy(this._stopper).toProperty();
-      this._routeViewDriverStream.onValue(gmailRouteView => {
+
+      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._rowListViewDriverStream = this._setupRouteSubViewDriver(
+        'newGmailRowListView'
+      ).takeUntilBy(this._stopper);
+
       this._setupThreadRowViewDriverKefirStream();
-      this._threadViewDriverLiveSet = (0, _toLiveSet.default)(this._setupRouteSubViewDriver('newGmailThreadView').takeUntilBy(this._stopper).flatMap(gmailThreadView => gmailThreadView.getReadyStream().map(() => gmailThreadView)).map(gmailThreadView => ({
-        el: gmailThreadView,
-        removalStream: gmailThreadView.getStopper()
-      })));
+      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.default(this);
+
+      this._threadRowIdentifier = new ThreadRowIdentifier(this);
+
       this._timestampOnready = Date.now();
     });
   }
+
   _setupComposeViewDriverStream() {
-    this._composeViewDriverStream = (0, _setupComposeViewDriverStream.default)(this, this._messageViewDriverStream, this._xhrInterceptorStream).takeUntilBy(this._stopper);
+    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);
+
+  _setupRouteSubViewDriver(viewName: string): Kefir.Observable<Object> {
+    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);
+    this._threadRowViewDriverKefirStream = this._rowListViewDriverStream
+      .flatMap((rowListViewDriver) =>
+        rowListViewDriver.getRowViewDriverStream()
+      )
+      .takeUntilBy(this._stopper);
   }
+
   _setupToolbarViewDriverStream() {
-    this._toolbarViewDriverLiveSet = (0, _toLiveSet.default)(_kefir.default.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 = 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);
+    this._messageViewDriverStream = this.getThreadViewDriverStream()
+      .flatMap((gmailThreadView) =>
+        gmailThreadView.getMessageViewDriverStream()
+      )
+      .takeUntilBy(this._stopper);
   }
-  async addGlobalSidebarContentPanel(descriptor) {
-    await this.waitForGlobalSidebarReady().merge(this._stopper.flatMap(() => _kefir.default.constantError(new Error('Driver instance was destroyed early')))).take(1).takeErrors(1).toPromise();
+
+  async addGlobalSidebarContentPanel(
+    descriptor: Kefir.Observable<Object>
+  ): Promise<?ContentPanelViewDriver> {
+    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.default.getCompanionSidebarContentContainerElement() && (_gmailElementGetter.default.getCompanionSidebarIconContainerElement() || _gmailElementGetter.default.getAddonSidebarContainerElement());
+
+  waitForGlobalSidebarReady(): Kefir.Observable<void> {
+    const condition = () =>
+      GmailElementGetter.getCompanionSidebarContentContainerElement() &&
+      (GmailElementGetter.getCompanionSidebarIconContainerElement() ||
+        GmailElementGetter.getAddonSidebarContainerElement());
     if (condition()) {
-      return _kefir.default.constant(undefined);
+      return Kefir.constant(undefined);
     }
-    return (0, _streamWaitFor.default)(condition).map(() => undefined);
+    return waitFor(condition).map(() => undefined);
   }
-  getGlobalSidebar() {
+
+  getGlobalSidebar(): GmailAppSidebarView {
     let appSidebarView = this._appSidebarView;
     if (!appSidebarView) {
-      const companionSidebarContentContainerEl = _gmailElementGetter.default.getCompanionSidebarContentContainerElement();
-      if (!companionSidebarContentContainerEl) throw new Error('did not find companionSidebarContentContainerEl');
-      appSidebarView = this._appSidebarView = new _gmailAppSidebarView.default(this, companionSidebarContentContainerEl);
+      const companionSidebarContentContainerEl =
+        GmailElementGetter.getCompanionSidebarContentContainerElement();
+      if (!companionSidebarContentContainerEl)
+        throw new Error('did not find companionSidebarContentContainerEl');
+      appSidebarView = this._appSidebarView = new GmailAppSidebarView(
+        this,
+        companionSidebarContentContainerEl
+      );
     }
+
     return appSidebarView;
   }
-  isRunningInPageContext() {
+
+  isRunningInPageContext(): boolean {
     return !!(global.GLOBALS && global._GM_main);
   }
-  isUsingSyncAPI() {
+
+  isUsingSyncAPI(): boolean {
     return this._pageCommunicator.isUsingSyncAPI();
   }
+
   showAppIdWarning() {
-    (0, _showAppIdWarning.default)(this);
+    showAppIdWarning(this);
   }
-  createTopMessageBarDriver(optionStream) {
-    return new _gmailTopMessageBarDriver.default(optionStream);
+
+  createTopMessageBarDriver(
+    optionStream: Kefir.Observable<?Object>
+  ): GmailTopMessageBarDriver {
+    return new GmailTopMessageBarDriver(optionStream);
   }
-  associateThreadAndMessageIDs(threadID, messageID) {
+
+  associateThreadAndMessageIDs(threadID: string, messageID: string) {
     this._messageIDsToThreadIDs.set(messageID, threadID);
   }
-  getThreadIDForMessageID(messageID) {
-    return (0, _getOrFail.default)(this._messageIDsToThreadIDs, messageID);
+
+  getThreadIDForMessageID(messageID: string): string {
+    return get(this._messageIDsToThreadIDs, messageID);
   }
-  getDraftIDForMessageID(messageID) {
-    let skipCache = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    return (0, _getDraftIdForMessageId.default)(this, messageID, skipCache);
+
+  getDraftIDForMessageID(
+    messageID: string,
+    skipCache: boolean = false
+  ): Promise<GetDraftIdResult> {
+    return getDraftIDForMessageID(this, messageID, skipCache);
   }
-  reportRecentSyncDraftId(syncDraftId) {
-    const count = this._recentSyncDraftIds.get(syncDraftId);
+
+  _recentSyncDraftIds = new Map<string, number>();
+
+  reportRecentSyncDraftId(syncDraftId: string) {
+    const count: ?number = this._recentSyncDraftIds.get(syncDraftId);
     const newCount = (count ?? 0) + 1;
     this._recentSyncDraftIds.set(syncDraftId, newCount);
   }
-  reportDraftClosed(syncDraftId) {
-    _kefir.default.later(30 * 1000).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);
-      }
-    });
+  reportDraftClosed(syncDraftId: string) {
+    Kefir.later(30 * 1000)
+      .takeUntilBy(this._stopper)
+      .onValue(() => {
+        const count: ?number = 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) {
+  isRecentSyncDraftId(syncMessageId: string): boolean {
     return this._recentSyncDraftIds.has(syncMessageId);
   }
-  getSelectedThreadRowViewDrivers() {
+
+  _selectedThreadRows = t.mapcat((gmailRowListView: GmailRowListView) =>
+    gmailRowListView.getSelectedThreadRowViewDrivers()
+  );
+  getSelectedThreadRowViewDrivers(): $ReadOnlyArray<GmailThreadRowView> {
     if (!this._currentRouteViewDriver) {
       return [];
     }
-    return _transducers.default.toArray(this._currentRouteViewDriver.getRowListViews(), this._selectedThreadRows);
+    return t.toArray(
+      this._currentRouteViewDriver.getRowListViews(),
+      this._selectedThreadRows
+    );
   }
+
+  _threadRowViewSelectionChanges = kefirBus();
+
   signalThreadRowViewSelectionChange() {
     this._threadRowViewSelectionChanges.value(undefined);
   }
-  registerThreadRowViewSelectionHandler(handler) {
+
+  registerThreadRowViewSelectionHandler(handler: () => any): () => void {
     this._threadRowViewSelectionChanges.onValue(handler);
     return () => {
       this._threadRowViewSelectionChanges.offValue(handler);
     };
   }
 }
-var _default = (0, _ud.defn)(module, GmailDriver);
-exports.default = _default;
+
+export default defn(module, GmailDriver);