@inboxsdk/core 0.2.28-alpha.6 → 0.2.28

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/register-search-suggestions-provider.js

@@ -1,79 +1,125 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = registerSearchSuggestionsProvider;
-var _once = _interopRequireDefault(require("lodash/once"));
-var _find = _interopRequireDefault(require("lodash/find"));
-var _kefir = _interopRequireDefault(require("kefir"));
-var _fromEventTargetCapture = _interopRequireDefault(require("../../../lib/from-event-target-capture"));
-var _simulateMouseEvent = require("../../../lib/dom/simulate-mouse-event");
-var _makeElementChildStream = _interopRequireDefault(require("../../../lib/dom/make-element-child-stream"));
-var _makeMutationObserverChunkedStream = _interopRequireDefault(require("../../../lib/dom/make-mutation-observer-chunked-stream"));
-var _gmailElementGetter = _interopRequireDefault(require("../gmail-element-getter"));
-var _copyAndValidateAutocompleteResults = _interopRequireDefault(require("../../../lib/copyAndValidateAutocompleteResults"));
-function registerSearchSuggestionsProvider(driver, handler) {
+/* @flow */
+
+import once from 'lodash/once';
+import find from 'lodash/find';
+import Kefir from 'kefir';
+import fromEventTargetCapture from '../../../lib/from-event-target-capture';
+import { simulateClick } from '../../../lib/dom/simulate-mouse-event';
+import makeElementChildStream from '../../../lib/dom/make-element-child-stream';
+import makeMutationObserverChunkedStream from '../../../lib/dom/make-mutation-observer-chunked-stream';
+import gmailElementGetter from '../gmail-element-getter';
+import copyAndValidateAutocompleteResults from '../../../lib/copyAndValidateAutocompleteResults';
+
+import type GmailDriver from '../gmail-driver';
+import type {
+  AutocompleteSearchResult,
+  AutocompleteSearchResultWithId,
+} from '../../../../injected-js/gmail/modify-suggestions';
+
+export default function registerSearchSuggestionsProvider(
+  driver: GmailDriver,
+  handler: Function
+) {
   // We inject the app-provided suggestions into Gmail's AJAX response. Then we
   // watch the DOM for our injected suggestions to show up and attach click and
   // enter handlers to them to let them do custom actions.
 
-  const providerId = 'inboxsdk__suggestions_' + ('' + Date.now() + Math.random()).replace(/\D+/g, '');
+  const providerId =
+    'inboxsdk__suggestions_' +
+    ('' + Date.now() + Math.random()).replace(/\D+/g, '');
   const pageCommunicator = driver.getPageCommunicator();
   pageCommunicator.registerSuggestionsModifier(providerId);
 
   // Listen for the AJAX requests, call the application's handler function, and
   // give the application's suggestions back to the pageCommunicator for it to
   // inject into the AJAX responses.
-  const suggestionsStream = pageCommunicator.ajaxInterceptStream.filter(event => event.type === 'suggestionsRequest').flatMapLatest(_ref => {
-    let {
-      query
-    } = _ref;
-    return _kefir.default.fromPromise(Promise.resolve(handler(query))).flatMap(results => {
-      try {
-        const validatedResults = (0, _copyAndValidateAutocompleteResults.default)(driver, results);
-        const validatedResultsWithIds = validatedResults.map(result => ({
-          ...result,
-          providerId,
-          id: `${Date.now()}-${Math.random()}`
-        }));
-        return _kefir.default.constant(validatedResultsWithIds);
-      } catch (e) {
-        return _kefir.default.constantError(e);
-      }
-    }).mapErrors(err => {
-      driver.getLogger().error(err);
-      return [];
-    }).map(suggestions => {
-      return {
-        query,
-        suggestions
-      };
-    });
-  }).onValue(event => {
-    pageCommunicator.provideAutocompleteSuggestions(providerId, event.query, event.suggestions);
-  }).map(event => event.suggestions);
+  const suggestionsStream = pageCommunicator.ajaxInterceptStream
+    .filter((event) => event.type === 'suggestionsRequest')
+    .flatMapLatest(({ query }) =>
+      Kefir.fromPromise(Promise.resolve(handler(query)))
+        .flatMap((results: Array<AutocompleteSearchResult>) => {
+          try {
+            const validatedResults = copyAndValidateAutocompleteResults(
+              driver,
+              results
+            );
+
+            const validatedResultsWithIds = validatedResults.map((result) => ({
+              ...result,
+              providerId,
+              id: `${Date.now()}-${Math.random()}`,
+            }));
+
+            return Kefir.constant(validatedResultsWithIds);
+          } catch (e) {
+            return Kefir.constantError(e);
+          }
+        })
+        .mapErrors((err) => {
+          driver.getLogger().error(err);
+          return [];
+        })
+        .map((suggestions) => {
+          return { query, suggestions };
+        })
+    )
+    .onValue((event) => {
+      pageCommunicator.provideAutocompleteSuggestions(
+        providerId,
+        event.query,
+        event.suggestions
+      );
+    })
+    .map((event) => event.suggestions);
 
   // Wait for the first routeViewDriver to happen before looking for the search box.
-  const searchBoxStream = driver.getRouteViewDriverStream().toProperty(() => null).map(() => _gmailElementGetter.default.getSearchInput()).filter(Boolean).take(1);
+  const searchBoxStream: Kefir.Observable<HTMLInputElement> = driver
+    .getRouteViewDriverStream()
+    .toProperty(() => null)
+    .map(() => gmailElementGetter.getSearchInput())
+    .filter(Boolean)
+    .take(1);
 
   // Wait for the search box to be focused before looking for the suggestions box.
-  const suggestionsBoxTbodyStream = searchBoxStream.flatMapLatest(searchBox => _kefir.default.fromEvents(searchBox, 'focus')).map(() => _gmailElementGetter.default.getSearchSuggestionsBoxParent()).filter(Boolean).flatMapLatest(_makeElementChildStream.default).map(x => x.el.firstElementChild).take(1).toProperty();
+  const suggestionsBoxTbodyStream: Kefir.Observable<HTMLElement> =
+    searchBoxStream
+      .flatMapLatest((searchBox) => Kefir.fromEvents(searchBox, 'focus'))
+      .map(() => gmailElementGetter.getSearchSuggestionsBoxParent())
+      .filter(Boolean)
+      .flatMapLatest(makeElementChildStream)
+      .map((x) => (x.el: any).firstElementChild)
+      .take(1)
+      .toProperty();
 
   // This stream emits an event after every time Gmail changes the suggestions
   // list.
-  const suggestionsBoxGmailChanges = suggestionsBoxTbodyStream.flatMap(suggestionsBoxTbody => (0, _makeMutationObserverChunkedStream.default)(suggestionsBoxTbody, {
-    childList: true
-  }).toProperty(() => null)).map(() => null);
+  const suggestionsBoxGmailChanges = suggestionsBoxTbodyStream
+    .flatMap((suggestionsBoxTbody) =>
+      makeMutationObserverChunkedStream(suggestionsBoxTbody, {
+        childList: true,
+      }).toProperty(() => null)
+    )
+    .map(() => null);
 
   // We listen to the event on the document node so that the event can be
   // canceled before Gmail receives it.
-  const suggestionsBoxEnterPresses = searchBoxStream.flatMap(searchBox => (0, _fromEventTargetCapture.default)(document, 'keydown').filter(event => event.keyCode == 13 && event.target === searchBox));
+  const suggestionsBoxEnterPresses = searchBoxStream.flatMap((searchBox) =>
+    fromEventTargetCapture(document, 'keydown').filter(
+      (event) => event.keyCode == 13 && event.target === searchBox
+    )
+  );
 
   // Stream of arrays of row elements belonging to this provider.
-  const providedRows = suggestionsBoxTbodyStream.sampledBy(suggestionsBoxGmailChanges).map(suggestionsBoxTbody => Array.from(suggestionsBoxTbody.children).filter(row => row.getElementsByClassName(providerId).length > 0));
-  providedRows.onValue(rows => {
+  const providedRows: Kefir.Observable<HTMLElement[]> =
+    suggestionsBoxTbodyStream
+      .sampledBy(suggestionsBoxGmailChanges)
+      .map((suggestionsBoxTbody) =>
+        Array.from(suggestionsBoxTbody.children).filter(
+          (row) => row.getElementsByClassName(providerId).length > 0
+        )
+      );
+
+  providedRows.onValue((rows) => {
     if (rows[0] && rows[0].previousElementSibling) {
       const prevFirstChild = rows[0].previousElementSibling.firstElementChild;
       if (prevFirstChild) {
@@ -85,29 +131,59 @@ function registerSearchSuggestionsProvider(driver, handler) {
       }
     }
   });
-  const rowSelectionEvents = providedRows.flatMapLatest(rows => _kefir.default.merge(rows.map(row => _kefir.default.merge([(0, _fromEventTargetCapture.default)(row, 'click'), suggestionsBoxEnterPresses.filter(() => row.classList.contains('gssb_i'))]).map(event => ({
-    event,
-    row
-  })))));
-  const activeSuggestionsStream = _kefir.default.merge([suggestionsStream, searchBoxStream.flatMapLatest(searchBox => _kefir.default.fromEvents(searchBox, 'blur')).map(() => [])]).toProperty();
-  _kefir.default.combine([rowSelectionEvents, searchBoxStream], [activeSuggestionsStream]).onValue(tuple => {
-    const [{
-      event,
-      row
-    }, searchBox, suggestions] = tuple;
+
+  const rowSelectionEvents: Kefir.Observable<{
+    event: Object,
+    row: HTMLElement,
+  }> = providedRows.flatMapLatest((rows) =>
+    Kefir.merge(
+      rows.map((row) =>
+        Kefir.merge([
+          fromEventTargetCapture(row, 'click'),
+          suggestionsBoxEnterPresses.filter(() =>
+            row.classList.contains('gssb_i')
+          ),
+        ]).map((event) => ({ event, row }))
+      )
+    )
+  );
+
+  const activeSuggestionsStream: Kefir.Observable<
+    Array<AutocompleteSearchResultWithId>
+  > = Kefir.merge([
+    suggestionsStream,
+    searchBoxStream
+      .flatMapLatest((searchBox) => Kefir.fromEvents(searchBox, 'blur'))
+      .map(() => []),
+  ]).toProperty();
+
+  Kefir.combine(
+    [rowSelectionEvents, searchBoxStream],
+    [activeSuggestionsStream]
+  ).onValue((tuple: any) => {
+    const [{ event, row }, searchBox, suggestions] = (tuple: [
+      { event: Object, row: HTMLElement },
+      HTMLInputElement,
+      Array<AutocompleteSearchResultWithId>
+    ]);
+
     const itemDataSpan = row.querySelector('span[data-inboxsdk-suggestion]');
-    const itemData = itemDataSpan ? JSON.parse(itemDataSpan.getAttribute('data-inboxsdk-suggestion') || 'null') : null;
-    const clearSearch = (0, _once.default)(() => {
+    const itemData = itemDataSpan
+      ? JSON.parse(
+          itemDataSpan.getAttribute('data-inboxsdk-suggestion') || 'null'
+        )
+      : null;
+
+    const clearSearch = once(() => {
       event.stopImmediatePropagation();
       event.preventDefault();
       searchBox.blur();
       searchBox.value = '';
     });
+
     if (itemData) {
-      const {
-        id
-      } = itemData;
-      const suggestion = (0, _find.default)(suggestions, s => s.id === id);
+      const { id } = itemData;
+      const suggestion = find(suggestions, (s) => s.id === id);
       if (!suggestion) {
         // I can imagine this happening if Gmail caches old suggestions
         // results. Unknown if it does that so let's log. If it does, then
@@ -128,4 +204,4 @@ function registerSearchSuggestionsProvider(driver, handler) {
       window.open(itemData.externalURL);
     }
   });
-}
+}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/setup-compose-view-driver-stream.js

@@ -1,105 +1,162 @@
-"use strict";
+/* @flow */
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = setupComposeViewDriverStream;
-var _kefir = _interopRequireDefault(require("kefir"));
-var _udKefir = _interopRequireDefault(require("ud-kefir"));
-var _streamWaitFor = _interopRequireDefault(require("../../../lib/stream-wait-for"));
-var _makeMutationObserverChunkedStream = _interopRequireDefault(require("../../../lib/dom/make-mutation-observer-chunked-stream"));
-var _makeElementChildStream = _interopRequireDefault(require("../../../lib/dom/make-element-child-stream"));
-var _elementViewMapper = _interopRequireDefault(require("../../../lib/dom/element-view-mapper"));
-var _makeElementStreamMerger = _interopRequireDefault(require("../../../lib/dom/make-element-stream-merger"));
-var _gmailElementGetter = _interopRequireDefault(require("../gmail-element-getter"));
-var _gmailComposeView = _interopRequireDefault(require("../views/gmail-compose-view"));
-var _logger = _interopRequireDefault(require("../../../lib/logger"));
-var impStream = (0, _udKefir.default)(module, imp);
-function setupComposeViewDriverStream(gmailDriver, messageViewDriverStream, xhrInterceptorStream) {
-  return impStream.flatMapLatest(imp => imp(gmailDriver, messageViewDriverStream, xhrInterceptorStream));
+import Kefir from 'kefir';
+import udKefir from 'ud-kefir';
+import streamWaitFor from '../../../lib/stream-wait-for';
+
+import kefirMakeMutationObserverChunkedStream from '../../../lib/dom/make-mutation-observer-chunked-stream';
+import makeElementChildStream from '../../../lib/dom/make-element-child-stream';
+import elementViewMapper from '../../../lib/dom/element-view-mapper';
+import makeElementStreamMerger from '../../../lib/dom/make-element-stream-merger';
+import GmailElementGetter from '../gmail-element-getter';
+
+import GmailComposeView from '../views/gmail-compose-view';
+import type GmailMessageView from '../views/gmail-message-view';
+
+import Logger from '../../../lib/logger';
+import type GmailDriver from '../gmail-driver';
+
+var impStream = udKefir(module, imp);
+
+export default function setupComposeViewDriverStream(
+  gmailDriver: GmailDriver,
+  messageViewDriverStream: Kefir.Observable<GmailMessageView>,
+  xhrInterceptorStream: Kefir.Observable<Object>
+): Kefir.Observable<GmailComposeView> {
+  return impStream.flatMapLatest((imp) =>
+    imp(gmailDriver, messageViewDriverStream, xhrInterceptorStream)
+  );
 }
-function imp(gmailDriver, messageViewDriverStream, xhrInterceptorStream) {
-  return _kefir.default.fromPromise(_gmailElementGetter.default.waitForGmailModeToSettle()).flatMap(() => {
-    var elementStream;
-    var isStandalone = false;
-    if (_gmailElementGetter.default.isStandaloneComposeWindow()) {
-      elementStream = _setupStandaloneComposeElementStream();
-      isStandalone = true;
-    } else if (_gmailElementGetter.default.isStandaloneThreadWindow()) {
-      elementStream = _kefir.default.never();
-    } else {
-      elementStream = _setupStandardComposeElementStream();
-    }
-    return elementStream.map((0, _elementViewMapper.default)(el => new _gmailComposeView.default(el, xhrInterceptorStream, gmailDriver, {
-      isStandalone,
-      isInlineReplyForm: false
-    })));
-  }).merge(messageViewDriverStream.flatMap(gmailMessageView => gmailMessageView.getReplyElementStream().map((0, _elementViewMapper.default)(el => new _gmailComposeView.default(el, xhrInterceptorStream, gmailDriver, {
-    isStandalone: false,
-    isInlineReplyForm: true
-  }))))).flatMap(composeViewDriver => composeViewDriver.ready());
+
+function imp(
+  gmailDriver: GmailDriver,
+  messageViewDriverStream: Kefir.Observable<GmailMessageView>,
+  xhrInterceptorStream: Kefir.Observable<Object>
+): Kefir.Observable<GmailComposeView> {
+  return Kefir.fromPromise(GmailElementGetter.waitForGmailModeToSettle())
+    .flatMap(() => {
+      var elementStream;
+      var isStandalone = false;
+
+      if (GmailElementGetter.isStandaloneComposeWindow()) {
+        elementStream = _setupStandaloneComposeElementStream();
+        isStandalone = true;
+      } else if (GmailElementGetter.isStandaloneThreadWindow()) {
+        elementStream = Kefir.never();
+      } else {
+        elementStream = _setupStandardComposeElementStream();
+      }
+
+      return elementStream.map(
+        elementViewMapper(
+          (el) =>
+            new GmailComposeView(el, xhrInterceptorStream, gmailDriver, {
+              isStandalone,
+              isInlineReplyForm: false,
+            })
+        )
+      );
+    })
+    .merge(
+      messageViewDriverStream.flatMap((gmailMessageView) =>
+        gmailMessageView.getReplyElementStream().map(
+          elementViewMapper(
+            (el) =>
+              new GmailComposeView(el, xhrInterceptorStream, gmailDriver, {
+                isStandalone: false,
+                isInlineReplyForm: true,
+              })
+          )
+        )
+      )
+    )
+    .flatMap((composeViewDriver: any) => composeViewDriver.ready());
 }
+
 function _setupStandardComposeElementStream() {
-  return _waitForContainerAndMonitorChildrenStream(() => _gmailElementGetter.default.getComposeWindowContainer()).flatMap(composeGrandParent => {
-    var composeParentEl = composeGrandParent.el.querySelector('div.AD');
-    if (composeParentEl) {
-      return (0, _makeElementChildStream.default)(composeParentEl).takeUntilBy(composeGrandParent.removalStream).map(_informElement('composeFullscreenStateChanged'));
-    } else {
-      return _kefir.default.never();
-    }
-  }).merge(_gmailElementGetter.default.getFullscreenComposeWindowContainerStream().flatMap(_ref => {
-    let {
-      el,
-      removalStream
-    } = _ref;
-    return (0, _makeElementChildStream.default)(el).takeUntilBy(removalStream);
-  }).map(_informElement('composeFullscreenStateChanged')).map(_ref2 => {
-    let {
-      el,
-      removalStream
-    } = _ref2;
-    // If you close a fullscreen compose while it's still saving, Gmail never
-    // removes it from the DOM, and instead only removes a specific child
-    // element. Ugh. Watch for its removal too.
-    const targetEl = el.querySelector('[role=dialog] div.aaZ');
-    if (!targetEl) return null;
-    var hiddenStream = (0, _makeMutationObserverChunkedStream.default)(targetEl, {
-      childList: true
-    }).filter(() => targetEl.childElementCount === 0).map(() => null);
-    return {
-      el,
-      removalStream: removalStream.merge(hiddenStream).take(1)
-    };
-  }).filter(Boolean)).flatMap(event => {
-    if (!event) throw new Error('Should not happen');
-    const el = event.el.querySelector('[role=dialog]');
-    if (!el || !el.querySelector('form')) {
-      return _kefir.default.never();
-    }
-    return _kefir.default.constant({
-      el,
-      removalStream: event.removalStream
-    });
-  }).flatMap((0, _makeElementStreamMerger.default)());
+  return _waitForContainerAndMonitorChildrenStream(() =>
+    GmailElementGetter.getComposeWindowContainer()
+  )
+    .flatMap((composeGrandParent) => {
+      var composeParentEl = composeGrandParent.el.querySelector('div.AD');
+      if (composeParentEl) {
+        return makeElementChildStream(composeParentEl)
+          .takeUntilBy(composeGrandParent.removalStream)
+          .map(_informElement('composeFullscreenStateChanged'));
+      } else {
+        return Kefir.never();
+      }
+    })
+    .merge(
+      GmailElementGetter.getFullscreenComposeWindowContainerStream()
+        .flatMap(({ el, removalStream }) =>
+          makeElementChildStream(el).takeUntilBy(removalStream)
+        )
+        .map(_informElement('composeFullscreenStateChanged'))
+        .map(({ el, removalStream }) => {
+          // If you close a fullscreen compose while it's still saving, Gmail never
+          // removes it from the DOM, and instead only removes a specific child
+          // element. Ugh. Watch for its removal too.
+          const targetEl = el.querySelector('[role=dialog] div.aaZ');
+          if (!targetEl) return null;
+          var hiddenStream = kefirMakeMutationObserverChunkedStream(targetEl, {
+            childList: true,
+          })
+            .filter(() => targetEl.childElementCount === 0)
+            .map(() => null);
+          return {
+            el,
+            removalStream: removalStream.merge(hiddenStream).take(1),
+          };
+        })
+        .filter(Boolean)
+    )
+    .flatMap((event) => {
+      if (!event) throw new Error('Should not happen');
+      const el = event.el.querySelector('[role=dialog]');
+      if (!el || !el.querySelector('form')) {
+        return Kefir.never();
+      }
+      return Kefir.constant({
+        el,
+        removalStream: event.removalStream,
+      });
+    })
+    .flatMap(makeElementStreamMerger());
 }
+
 function _setupStandaloneComposeElementStream() {
-  return _waitForContainerAndMonitorChildrenStream(() => _gmailElementGetter.default.StandaloneCompose.getComposeWindowContainer());
+  return _waitForContainerAndMonitorChildrenStream(() =>
+    GmailElementGetter.StandaloneCompose.getComposeWindowContainer()
+  );
 }
-function _waitForContainerAndMonitorChildrenStream(containerFn) {
-  return _kefir.default.interval(2000) // TODO replace this with page-parser-tree
-  .map(containerFn).filter().take(1).flatMap(containerEl => (0, _makeElementChildStream.default)(containerEl));
+
+function _waitForContainerAndMonitorChildrenStream(
+  containerFn: () => ?HTMLElement
+) {
+  return Kefir.interval(2000) // TODO replace this with page-parser-tree
+    .map(containerFn)
+    .filter()
+    .take(1)
+    .flatMap((containerEl) => makeElementChildStream(containerEl));
 }
+
 function _informElement(eventName) {
   return function (event) {
-    const composeEl = event && event.el && event.el.querySelector && event.el.querySelector('[role=dialog]');
+    const composeEl =
+      event &&
+      event.el &&
+      event.el.querySelector &&
+      event.el.querySelector('[role=dialog]');
     if (composeEl) {
-      composeEl.dispatchEvent(new CustomEvent(eventName, {
-        bubbles: false,
-        cancelable: false,
-        detail: null
-      }));
+      composeEl.dispatchEvent(
+        new CustomEvent(eventName, {
+          bubbles: false,
+          cancelable: false,
+          detail: null,
+        })
+      );
     }
     return event;
   };
-}
+}