@inboxsdk/core 0.2.28-alpha.0 → 0.2.28-alpha.1

package/src/platform-implementation-js/constants/nav-item-types.d.ts

@@ -14,3 +14,4 @@ declare const navItemTypes: Readonly<{
     readonly MANAGE: "MANAGE";
 }>;
 export default navItemTypes;
+//# sourceMappingURL=nav-item-types.d.ts.map

package/src/platform-implementation-js/constants/nav-item-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nav-item-types.d.ts","sourceRoot":"","sources":["../../../../../src/platform-implementation-js/constants/nav-item-types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,QAAA,MAAM,YAAY;IAChB;;OAEG;;IAGH;;OAEG;;;;EASM,CAAC;AAEZ,eAAe,YAAY,CAAC"}

package/src/platform-implementation-js/constants/router.js

@@ -0,0 +1,53 @@
+/* @flow */
+
+export const NATIVE_ROUTE_IDS: { [k: string]: string } = Object.freeze({
+  INBOX: 'inbox/:page',
+  ALL_MAIL: 'all/:page',
+  SENT: 'sent/:page',
+  STARRED: 'starred/:page',
+  DRAFTS: 'drafts/:page',
+  SNOOZED: 'snoozed/:page',
+  DONE: 'done',
+  REMINDERS: 'reminders',
+  LABEL: 'label/:labelName/:page',
+  TRASH: 'trash/:page',
+  SPAM: 'spam/:page',
+  IMPORTANT: 'imp/:page',
+  SEARCH: 'search/:query/:page',
+  THREAD: 'inbox/:threadID',
+  CHATS: 'chats/:page',
+  CHAT: 'chats/:chatID',
+  CONTACTS: 'contacts/:page',
+  CONTACT: 'contacts/:contactID',
+  SETTINGS: 'settings/:section',
+  CHAT_WELCOME: 'chat/welcome',
+  SPACES: 'rooms/welcome',
+  MEET: 'calls',
+  ANY_LIST: '*',
+});
+
+export const NATIVE_LIST_ROUTE_IDS: { [k: string]: string } = Object.freeze({
+  INBOX: NATIVE_ROUTE_IDS.INBOX,
+  ALL_MAIL: NATIVE_ROUTE_IDS.ALL_MAIL,
+  SENT: NATIVE_ROUTE_IDS.SENT,
+  STARRED: NATIVE_ROUTE_IDS.STARRED,
+  DRAFTS: NATIVE_ROUTE_IDS.DRAFTS,
+  SNOOZED: NATIVE_ROUTE_IDS.SNOOZED,
+  DONE: NATIVE_ROUTE_IDS.DONE,
+  REMINDERS: NATIVE_ROUTE_IDS.REMINDERS,
+  LABEL: NATIVE_ROUTE_IDS.LABEL,
+  TRASH: NATIVE_ROUTE_IDS.TRASH,
+  SPAM: NATIVE_ROUTE_IDS.SPAM,
+  IMPORTANT: NATIVE_ROUTE_IDS.IMPORTANT,
+  SEARCH: NATIVE_ROUTE_IDS.SEARCH,
+  ANY_LIST: NATIVE_ROUTE_IDS.ANY_LIST,
+});
+
+export const ROUTE_TYPES: { [k: string]: string } = Object.freeze({
+  LIST: 'LIST',
+  THREAD: 'THREAD',
+  SETTINGS: 'SETTINGS',
+  CHAT: 'CHAT',
+  CUSTOM: 'CUSTOM',
+  UNKNOWN: 'UNKNOWN',
+});

package/src/platform-implementation-js/constants/toolbars.js

@@ -0,0 +1,7 @@
+/* @flow */
+
+export const SECTION_NAMES: { [k: string]: string } = Object.freeze({
+  INBOX_STATE: 'INBOX_STATE',
+  METADATA_STATE: 'METADATA_STATE',
+  OTHER: 'OTHER',
+});

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

@@ -0,0 +1,22 @@
+/* @flow */
+
+import type Kefir from 'kefir';
+import udKefir from 'ud-kefir';
+import rewriteCssWithIdMap from '../../lib/rewriteCssWithIdMap';
+var fs = require('fs');
+var cssContent: Kefir.Observable<string> = udKefir(
+  module,
+  fs.readFileSync(__dirname + '/../../style/gmail.css', 'utf8')
+);
+
+export default function customStyle() {
+  if (!document.getElementById('inboxsdk__style')) {
+    var style = document.createElement('style');
+    style.id = 'inboxsdk__style';
+    cssContent.onValue((css) => {
+      style.textContent = rewriteCssWithIdMap(css);
+    });
+    if (!document.head) throw new Error('missing head');
+    document.head.appendChild(style);
+  }
+}

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

@@ -0,0 +1,214 @@
+/* @flow */
+
+import Kefir from 'kefir';
+
+import streamWaitFor from '../../lib/stream-wait-for';
+import querySelector from '../../lib/dom/querySelectorOrFail';
+import makeMutationObserverChunkedStream from '../../lib/dom/make-mutation-observer-chunked-stream';
+
+const elements = streamWaitFor(() =>
+  ((document.body: any): HTMLElement).querySelector('div.b8[role="alert"]')
+)
+  .map((noticeContainer: HTMLElement) => {
+    const googleNotice = querySelector(
+      noticeContainer,
+      '.vh:not(.inboxsdk__butterbar)'
+    );
+    let sdkNotice = noticeContainer.querySelector('.vh.inboxsdk__butterbar');
+    if (!sdkNotice) {
+      sdkNotice = document.createElement('div');
+      sdkNotice.classList.add('vh', 'inboxsdk__butterbar');
+      sdkNotice.style.display = 'none';
+
+      const textAndButtonsContainer = document.createElement('span');
+      textAndButtonsContainer.classList.add('aT');
+
+      const textContainer = document.createElement('span');
+      textContainer.classList.add('inboxsdk__butterbar-text', 'bAq');
+
+      const buttonsContainer = document.createElement('span');
+      buttonsContainer.classList.add('inboxsdk__butterbar-buttons', 'bAo');
+      buttonsContainer.innerHTML = '  ';
+
+      const noticeCloseButton = document.createElement('div');
+      noticeCloseButton.classList.add('inboxsdk__butterbar-close', 'bBe');
+      noticeCloseButton.innerHTML = '<div class="bBf"></div>';
+      noticeCloseButton.setAttribute('role', 'button');
+      noticeCloseButton.tabIndex = 0;
+
+      textAndButtonsContainer.appendChild(textContainer);
+      textAndButtonsContainer.appendChild(buttonsContainer);
+
+      sdkNotice.appendChild(textAndButtonsContainer);
+      sdkNotice.appendChild(noticeCloseButton);
+
+      const parentNode = googleNotice.parentNode;
+      if (!parentNode) {
+        throw new Error('parentNode not found');
+      }
+      parentNode.insertBefore(sdkNotice, googleNotice.nextSibling);
+    }
+    return { noticeContainer, googleNotice, sdkNotice };
+  })
+  .toProperty();
+
+const googleNoticeMutationChunks = elements.flatMapLatest(({ googleNotice }) =>
+  makeMutationObserverChunkedStream(googleNotice, { childList: true })
+);
+const googleAddedNotice = googleNoticeMutationChunks.filter((mutations) =>
+  mutations.some((m) => m.addedNodes.length > 0)
+);
+const googleRemovedNotice = googleNoticeMutationChunks.filter(
+  (mutations) => !mutations.some((m) => m.addedNodes.length > 0)
+);
+
+const sdkRemovedNotice = elements
+  .flatMapLatest(({ sdkNotice }) =>
+    makeMutationObserverChunkedStream(sdkNotice, {
+      attributes: true,
+      attributeFilter: ['data-inboxsdk-id'],
+    }).map(() => sdkNotice.getAttribute('data-inboxsdk-id'))
+  )
+  .filter((id) => id == null);
+
+const noticeAvailableStream = Kefir.merge([
+  googleRemovedNotice,
+  sdkRemovedNotice,
+]);
+
+function hideMessage(noticeContainer, googleNotice, sdkNotice) {
+  googleNotice.style.display = '';
+  noticeContainer.style.top = '-10000px';
+  noticeContainer.style.position = 'relative';
+  noticeContainer.classList.remove('bAp');
+  sdkNotice.style.display = 'none';
+  sdkNotice.removeAttribute('data-inboxsdk-id');
+}
+
+export default class GmailButterBarDriver {
+  constructor() {
+    Kefir.combine([elements, googleAddedNotice]).onValue(
+      ([{ googleNotice, sdkNotice }]) => {
+        googleNotice.style.display = '';
+        sdkNotice.style.display = 'none';
+        sdkNotice.setAttribute('data-inboxsdk-id', 'gmail');
+      }
+    );
+
+    // Force stream to be in active state. sdkRemovedNotice is prone to missing
+    // events if it only becomes active once a message has started.
+    noticeAvailableStream.onValue(() => {});
+  }
+
+  getNoticeAvailableStream(): Kefir.Observable<any> {
+    return noticeAvailableStream;
+  }
+
+  getSharedMessageQueue(): Array<Object> {
+    const attr = (document.head: any).getAttribute(
+      'data-inboxsdk-butterbar-queue'
+    );
+    return attr ? JSON.parse(attr) : [];
+  }
+
+  setSharedMessageQueue(queue: Object) {
+    const attr = JSON.stringify(queue);
+    (document.head: any).setAttribute('data-inboxsdk-butterbar-queue', attr);
+  }
+
+  // Immediately displays the message, overriding anything else on the screen.
+  // Priority and queuing logic is handled by butter-bar.js above this.
+  showMessage(rawOptions: Object): { destroy(): void } {
+    const instanceId = Date.now() + '-' + Math.random();
+
+    const destroy = () => {
+      elements
+        .take(1)
+        .onValue(({ noticeContainer, googleNotice, sdkNotice }) => {
+          if (sdkNotice.getAttribute('data-inboxsdk-id') === instanceId) {
+            if (rawOptions.className) {
+              sdkNotice.classList.remove(rawOptions.className);
+            }
+            hideMessage(noticeContainer, googleNotice, sdkNotice);
+          }
+        });
+    };
+
+    elements.take(1).onValue(({ noticeContainer, googleNotice, sdkNotice }) => {
+      noticeContainer.style.visibility = 'visible';
+      noticeContainer.style.top = '';
+      // The bAp css class is added to noticeContainer whenever a native butter is active in
+      // Material Gmail. We replicate this native behavior by adding bAp to noticeContainer
+      // when we show an SDK butter and removing it when the butter expires (see the
+      // hideMessage function above).
+      // The bAp class also causes butters to be styled and positioned as Snack Bars instead
+      // (as opposed to butters).
+      noticeContainer.classList.add('bAp');
+
+      googleNotice.style.display = 'none';
+      sdkNotice.className = googleNotice.className;
+      sdkNotice.classList.add('inboxsdk__butterbar');
+
+      const textContainer = querySelector(
+        sdkNotice,
+        '.inboxsdk__butterbar-text'
+      );
+      while (textContainer.firstChild) {
+        textContainer.removeChild(textContainer.firstChild);
+      }
+
+      const buttonsContainer = querySelector(
+        sdkNotice,
+        '.inboxsdk__butterbar-buttons'
+      );
+      while (buttonsContainer.firstChild) {
+        buttonsContainer.removeChild(buttonsContainer.firstChild);
+      }
+
+      if (rawOptions.html) {
+        textContainer.innerHTML = rawOptions.html;
+      } else if (rawOptions.el) {
+        textContainer.appendChild(rawOptions.el);
+      } else {
+        textContainer.textContent = rawOptions.text;
+      }
+
+      if (rawOptions.buttons) {
+        rawOptions.buttons.forEach((buttonDescriptor) => {
+          const button = document.createElement('span');
+          button.classList.add('ag', 'a8k');
+          button.onclick = (e) => buttonDescriptor.onClick(e);
+          button.setAttribute('role', 'button');
+          button.tabIndex = 0;
+          button.textContent = buttonDescriptor.title;
+          buttonsContainer.appendChild(button);
+        });
+      }
+
+      const closeButton = querySelector(
+        sdkNotice,
+        '.inboxsdk__butterbar-close'
+      );
+      if (closeButton) {
+        Kefir.fromEvents(closeButton, 'click').take(1).onValue(destroy);
+      }
+
+      if (rawOptions.className) {
+        sdkNotice.classList.add(rawOptions.className);
+      }
+
+      sdkNotice.style.display = '';
+      sdkNotice.setAttribute('data-inboxsdk-id', instanceId);
+    });
+
+    return { destroy };
+  }
+
+  hideGmailMessage() {
+    elements.take(1).onValue(({ noticeContainer, googleNotice, sdkNotice }) => {
+      if (sdkNotice.getAttribute('data-inboxsdk-id') === 'gmail') {
+        hideMessage(noticeContainer, googleNotice, sdkNotice);
+      }
+    });
+  }
+}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-app-menu-item.d.ts

@@ -0,0 +1,5 @@
+import { AppMenuItemDescriptor } from '../../../namespaces/app-menu';
+import { GmailAppMenuItemView } from '../views/gmail-app-menu-item-view';
+import GmailDriver from '../gmail-driver';
+export declare function addAppMenuItem(driver: GmailDriver, menuItemDescriptor: AppMenuItemDescriptor): Promise<GmailAppMenuItemView | undefined>;
+//# sourceMappingURL=add-app-menu-item.d.ts.map

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-app-menu-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-app-menu-item.d.ts","sourceRoot":"","sources":["../../../../../../../src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-app-menu-item.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAI1C,wBAAsB,cAAc,CAClC,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,qBAAqB,6CAuB1C"}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-collapsible-panel.d.ts

@@ -0,0 +1,5 @@
+import { AppMenuItemPanelDescriptor } from '../../../namespaces/app-menu';
+import { CollapsiblePanelView } from '../../../views/collapsible-panel-view';
+import GmailDriver from '../gmail-driver';
+export declare function addCollapsiblePanel(driver: GmailDriver, panelDescriptor: AppMenuItemPanelDescriptor): Promise<CollapsiblePanelView | undefined>;
+//# sourceMappingURL=add-collapsible-panel.d.ts.map

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-collapsible-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-collapsible-panel.d.ts","sourceRoot":"","sources":["../../../../../../../src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-collapsible-panel.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAI1E,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAE1C,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,WAAW,EACnB,eAAe,EAAE,0BAA0B,6CAgB5C"}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-nav-item.d.ts

@@ -1,5 +1,6 @@
 import * as Kefir from 'kefir';
 import GmailNavItemView from '../views/gmail-nav-item-view';
 import GmailDriver from '../gmail-driver';
-export default function addNavItem(driver: GmailDriver, orderGroup: string, navItemDescriptor: Kefir.Observable<any, any>): Promise<GmailNavItemView>;
-export declare const waitForNavMenuReady: () => Promise<void>;
+export default function addNavItem(driver: GmailDriver, orderGroup: string, navItemDescriptor: Kefir.Observable<any, any>, navMenuInjectionContainer?: HTMLElement): Promise<GmailNavItemView>;
+export declare const waitForMenuReady: () => Promise<void>;
+//# sourceMappingURL=add-nav-item.d.ts.map

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-nav-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-nav-item.d.ts","sourceRoot":"","sources":["../../../../../../../src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-nav-item.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,gBAAgB,MAAM,8BAA8B,CAAC;AAO5D,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAG1C,wBAA8B,UAAU,CACtC,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,EAC7C,yBAAyB,CAAC,EAAE,WAAW,GACtC,OAAO,CAAC,gBAAgB,CAAC,CAyB3B;AAED,eAAO,MAAM,gBAAgB,QAAkB,QAAQ,IAAI,CAKzD,CAAC"}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-support-item.d.ts

@@ -1,3 +1,4 @@
 import GmailSupportItemView, { SupportItemDescriptor } from '../views/gmail-support-item-view';
 import GmailDriver from '../gmail-driver';
 export default function addSupportItem(driver: GmailDriver, supportItemDescriptor: SupportItemDescriptor): GmailSupportItemView;
+//# sourceMappingURL=add-support-item.d.ts.map

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-support-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-support-item.d.ts","sourceRoot":"","sources":["../../../../../../../src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-support-item.ts"],"names":[],"mappings":"AAAA,OAAO,oBAAoB,EAAE,EAC3B,qBAAqB,EACtB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAE1C,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,MAAM,EAAE,WAAW,EACnB,qBAAqB,EAAE,qBAAqB,GAC3C,oBAAoB,CAEtB"}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/add-toolbar-button-for-app.js

@@ -0,0 +1,21 @@
+/* @flow */
+
+import type Kefir from 'kefir';
+import GmailElementGetter from '../gmail-element-getter';
+import GmailAppToolbarButtonView from '../views/gmail-app-toolbar-button-view';
+import type GmailDriver from '../gmail-driver';
+
+export default function addToolbarButtonForApp(
+  gmailDriver: GmailDriver,
+  buttonDescriptor: Kefir.Observable<Object>
+): Promise<GmailAppToolbarButtonView> {
+  return GmailElementGetter.waitForGmailModeToSettle().then(() => {
+    if (GmailElementGetter.isStandalone()) {
+      return new Promise((resolve, reject) => {
+        //never complete
+      });
+    } else {
+      return new GmailAppToolbarButtonView(gmailDriver, buttonDescriptor);
+    }
+  });
+}

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

@@ -0,0 +1,78 @@
+/* @flow */
+
+import populateRouteID from '../../../lib/populateRouteID';
+import Logger from '../../../lib/logger';
+
+import type { RouteParams } from '../../../namespaces/router';
+import type GmailRouteProcessor from '../views/gmail-route-view/gmail-route-processor';
+
+export default function createLink(
+  GmailRouteProcessor: GmailRouteProcessor,
+  routeID: string,
+  params: ?RouteParams | string
+): string {
+  params =
+    typeof params === 'string'
+      ? params
+      : params
+      ? Object.assign({}, params)
+      : {};
+  routeID = GmailRouteProcessor.getCompatibleRouteID(routeID);
+
+  if (typeof params === 'string') {
+    var matches = routeID.match(/:/g);
+    if (matches && matches.length === 1) {
+      var paramValue = params;
+      params = {};
+      params[routeID.match(/:(\w+)($|\/)?/)[1]] = paramValue;
+    } else {
+      params = {};
+    }
+  }
+
+  const hasPageParam = routeID.match(/:page(?:\/|$)/);
+  if (hasPageParam && !params.page) {
+    params.page = 0;
+  }
+
+  const parts = routeID.split('/');
+
+  // attempt to use new, more strict populateRouteID fn, if that fails
+  // log an error and fallback to older, more permissive approach.
+  // intent is to retire the old approach once we understand the consequences.
+  let processedRoute: string;
+  try {
+    processedRoute = populateRouteID(routeID, params);
+  } catch (error) {
+    Logger.error(error, {
+      routeID,
+      paramsKey: Object.keys(params),
+    });
+
+    processedRoute = parts
+      .map(function (part) {
+        if (part.indexOf(':') === -1) {
+          return part;
+        }
+
+        const colonParts = part.split(':');
+        if (params && typeof params[colonParts[1]] !== 'undefined') {
+          return colonParts[0] + params[colonParts[1]];
+        }
+
+        return colonParts[0];
+      })
+      .map(encodeURIComponent)
+      .join('/');
+  }
+
+  //check if link is of the form inbox/p0 or search/blah/p0
+  if (
+    GmailRouteProcessor.isListRouteName(parts[0]) &&
+    processedRoute.indexOf('p0') === processedRoute.length - 2
+  ) {
+    processedRoute = processedRoute.substring(0, processedRoute.length - 3);
+  }
+
+  return '#' + processedRoute;
+}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/encodeDraftUrlId.d.ts

@@ -1 +1,2 @@
 export default function encodeDraftUrlId(syncThreadId: string, syncMessageId: string): string;
+//# sourceMappingURL=encodeDraftUrlId.d.ts.map

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/encodeDraftUrlId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeDraftUrlId.d.ts","sourceRoot":"","sources":["../../../../../../../src/platform-implementation-js/dom-driver/gmail/gmail-driver/encodeDraftUrlId.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,OAAO,UAAU,gBAAgB,CACtC,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,MAAM,CAIR"}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/get-draft-id-for-message-id.js

@@ -0,0 +1,70 @@
+/* @flow */
+
+import memoize from 'lodash/memoize';
+import { defn } from 'ud';
+import gmailAjax from '../../../driver-common/gmailAjax';
+import { readDraftId } from '../gmail-response-processor';
+import type GmailDriver from '../gmail-driver';
+import isStreakAppId from '../../../lib/isStreakAppId';
+
+export type GetDraftIdResult = {
+  draftID: ?string,
+  debugData: ?Object,
+};
+
+async function uncachedGetDraftIDForMessageID(
+  driver: GmailDriver,
+  messageID: string
+): Promise<GetDraftIdResult> {
+  const response = await gmailAjax({
+    method: 'GET',
+    url: (document.location: any).origin + document.location.pathname,
+    data: {
+      ui: '2',
+      ik: driver.getPageCommunicator().getIkValue(),
+      view: 'cv',
+      th: messageID,
+      prf: '1',
+      nsc: '1',
+      mb: '0',
+      rt: 'j',
+      search: 'drafts',
+    },
+  });
+  try {
+    const draftID = readDraftId(response.text, messageID);
+    const debugData = { responseText: response.text };
+    return { draftID, debugData };
+  } catch (err) {
+    if (isStreakAppId(driver.getAppId())) {
+      driver.getLogger().error(err, {
+        message: 'failed to read draft ID',
+        messageID,
+        text: response.text,
+      });
+    }
+    throw err;
+  }
+}
+
+const cachedGetDraftIDForMessageID: (
+  driver: GmailDriver,
+  messageID: string
+) => Promise<GetDraftIdResult> = memoize(
+  uncachedGetDraftIDForMessageID,
+  (driver, messageID) => messageID
+);
+
+function getDraftIDForMessageID(
+  driver: GmailDriver,
+  messageID: string,
+  skipCache: boolean = false
+): Promise<GetDraftIdResult> {
+  if (skipCache) {
+    return uncachedGetDraftIDForMessageID(driver, messageID);
+  } else {
+    return cachedGetDraftIDForMessageID(driver, messageID);
+  }
+}
+
+export default defn(module, getDraftIDForMessageID);

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/get-native-nav-item.js

@@ -0,0 +1,43 @@
+/* @flow */
+
+import NativeGmailNavItemView from '../views/native-gmail-nav-item-view';
+import GmailElementGetter from '../gmail-element-getter';
+import findParent from '../../../../common/find-parent';
+import waitFor from '../../../lib/wait-for';
+
+import type GmailDriver from '../gmail-driver';
+
+export default function getNativeNavItem(
+  driver: GmailDriver,
+  label: string
+): Promise<NativeGmailNavItemView> {
+  return waitFor(() => {
+    const navContainer = GmailElementGetter.getLeftNavContainerElement();
+    if (!navContainer) return null;
+    return navContainer.querySelector(`.aim a[href*="#${label}"]`);
+  }, 300 * 1000)
+    .then((labelLinkElement) => {
+      const labelElement = findParent(labelLinkElement, (el) =>
+        el.classList.contains('aim')
+      );
+
+      if (!labelElement) {
+        throw new Error('native nav item structured weird');
+      }
+
+      if (!(labelElement: any).__nativeGmailNavItemView) {
+        (labelElement: any).__nativeGmailNavItemView =
+          new NativeGmailNavItemView(driver, labelElement, label);
+      }
+
+      return (labelElement: any).__nativeGmailNavItemView;
+    })
+    .catch((err) => {
+      if (GmailElementGetter.isStandalone()) {
+        // never resolve
+        return new Promise((resolve, reject) => {});
+      }
+
+      throw err;
+    });
+}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/get-rfc-message-id-for-gmail-message-id.d.ts

@@ -1,2 +1,3 @@
 import GmailDriver from '../gmail-driver';
 export default function getRfcMessageIdForGmailMessageId(driver: GmailDriver, gmailMessageId: string): Promise<string>;
+//# sourceMappingURL=get-rfc-message-id-for-gmail-message-id.d.ts.map

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/get-rfc-message-id-for-gmail-message-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-rfc-message-id-for-gmail-message-id.d.ts","sourceRoot":"","sources":["../../../../../../../src/platform-implementation-js/dom-driver/gmail/gmail-driver/get-rfc-message-id-for-gmail-message-id.ts"],"names":[],"mappings":"AAEA,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAG1C,wBAA8B,gCAAgC,CAC5D,MAAM,EAAE,WAAW,EACnB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC,CAWjB"}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/get-rfc-message-id-for-gmail-thread-id.d.ts

@@ -1,2 +1,3 @@
 import GmailDriver from '../gmail-driver';
 export default function getRfcMessageIdForGmailThreadId(driver: GmailDriver, gmailThreadId: string): Promise<string>;
+//# sourceMappingURL=get-rfc-message-id-for-gmail-thread-id.d.ts.map

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/get-rfc-message-id-for-gmail-thread-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-rfc-message-id-for-gmail-thread-id.d.ts","sourceRoot":"","sources":["../../../../../../../src/platform-implementation-js/dom-driver/gmail/gmail-driver/get-rfc-message-id-for-gmail-thread-id.ts"],"names":[],"mappings":"AAEA,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAK1C,wBAA8B,+BAA+B,CAC3D,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC,CAyCjB"}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/get-url-object.js

@@ -0,0 +1,33 @@
+/* @flow */
+
+export type URLObject = {
+  name: string,
+  params: string[],
+  query: ?string,
+  hash: string,
+};
+
+export default function getURLObject(url: string): URLObject {
+  const m = url.match(/#([^?]*)(?:\?(.*))?/);
+  if (!m) {
+    return {
+      name: 'inbox',
+      params: [],
+      hash: '',
+      query: undefined,
+    };
+  }
+
+  const hash = m[1];
+  const hashParts = hash.split('/');
+
+  return {
+    name: decodeURIComponent(hashParts[0]),
+    params: hashParts
+      .slice(1)
+      .map((part) => part.replace(/\+/g, ' '))
+      .map(decodeURIComponent),
+    query: m[2],
+    hash,
+  };
+}

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

@@ -0,0 +1,38 @@
+/* @flow */
+
+import { defn } from 'ud';
+import BigNumber from 'bignumber.js';
+
+import getSyncThreadsForSearch from '../../../driver-common/getSyncThreadsForSearch';
+
+import gmailAjax from '../../../driver-common/gmailAjax';
+import isStreakAppId from '../../../lib/isStreakAppId';
+
+import { extractThreadsFromSearchResponse } from '../gmail-sync-response-processor';
+
+import type GmailDriver from '../gmail-driver';
+import type { SyncThread } from '../gmail-sync-response-processor';
+
+export default async function getSyncThreadForOldGmailThreadId(
+  driver: GmailDriver,
+  oldGmailThreadId: string
+): Promise<SyncThread> {
+  const { threads: threadDescriptors, _text } = await getSyncThreadsForSearch(
+    driver,
+    'threadid:' + new BigNumber(oldGmailThreadId, 16).toString(10)
+  );
+  const firstThread = threadDescriptors[0];
+  if (firstThread == null) {
+    console.error(`Thread with ID ${oldGmailThreadId} not found by Gmail`); //eslint-disable-line
+    const isStreak = isStreakAppId(driver.getAppId());
+    const err = new Error(
+      'Thread not found by getSyncThreadForOldGmailThreadId'
+    );
+    driver.getLogger().error(err, {
+      oldGmailThreadId: isStreak ? oldGmailThreadId : null,
+      responseText: isStreak ? _text : null,
+    });
+    throw err;
+  }
+  return firstThread;
+}