@inboxsdk/core 0.2.28-alpha.4 → 0.2.28-alpha.5

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

@@ -1,125 +1,79 @@
-/* @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
-) {
+"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) {
   // 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(({ 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);
+  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);
 
   // Wait for the first routeViewDriver to happen before looking for the search box.
-  const searchBoxStream: Kefir.Observable<HTMLInputElement> = driver
-    .getRouteViewDriverStream()
-    .toProperty(() => null)
-    .map(() => gmailElementGetter.getSearchInput())
-    .filter(Boolean)
-    .take(1);
+  const searchBoxStream = driver.getRouteViewDriverStream().toProperty(() => null).map(() => _gmailElementGetter.default.getSearchInput()).filter(Boolean).take(1);
 
   // Wait for the search box to be focused before looking for the suggestions box.
-  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();
+  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();
 
   // This stream emits an event after every time Gmail changes the suggestions
   // list.
-  const suggestionsBoxGmailChanges = suggestionsBoxTbodyStream
-    .flatMap((suggestionsBoxTbody) =>
-      makeMutationObserverChunkedStream(suggestionsBoxTbody, {
-        childList: true,
-      }).toProperty(() => null)
-    )
-    .map(() => null);
+  const suggestionsBoxGmailChanges = suggestionsBoxTbodyStream.flatMap(suggestionsBoxTbody => (0, _makeMutationObserverChunkedStream.default)(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) =>
-    fromEventTargetCapture(document, 'keydown').filter(
-      (event) => event.keyCode == 13 && event.target === searchBox
-    )
-  );
+  const suggestionsBoxEnterPresses = searchBoxStream.flatMap(searchBox => (0, _fromEventTargetCapture.default)(document, 'keydown').filter(event => event.keyCode == 13 && event.target === searchBox));
 
   // Stream of arrays of row elements belonging to this provider.
-  const providedRows: Kefir.Observable<HTMLElement[]> =
-    suggestionsBoxTbodyStream
-      .sampledBy(suggestionsBoxGmailChanges)
-      .map((suggestionsBoxTbody) =>
-        Array.from(suggestionsBoxTbody.children).filter(
-          (row) => row.getElementsByClassName(providerId).length > 0
-        )
-      );
-
-  providedRows.onValue((rows) => {
+  const providedRows = 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) {
@@ -131,59 +85,29 @@ export default function registerSearchSuggestionsProvider(
       }
     }
   });
-
-  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 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 itemDataSpan = row.querySelector('span[data-inboxsdk-suggestion]');
-    const itemData = itemDataSpan
-      ? JSON.parse(
-          itemDataSpan.getAttribute('data-inboxsdk-suggestion') || 'null'
-        )
-      : null;
-
-    const clearSearch = once(() => {
+    const itemData = itemDataSpan ? JSON.parse(itemDataSpan.getAttribute('data-inboxsdk-suggestion') || 'null') : null;
+    const clearSearch = (0, _once.default)(() => {
       event.stopImmediatePropagation();
       event.preventDefault();
       searchBox.blur();
       searchBox.value = '';
     });
-
     if (itemData) {
-      const { id } = itemData;
-      const suggestion = find(suggestions, (s) => s.id === id);
+      const {
+        id
+      } = itemData;
+      const suggestion = (0, _find.default)(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
@@ -204,4 +128,4 @@ export default function registerSearchSuggestionsProvider(
       window.open(itemData.externalURL);
     }
   });
-}
+}

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

@@ -1,162 +1,105 @@
-/* @flow */
+"use strict";
 
-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)
-  );
+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));
 }
-
-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 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 _setupStandardComposeElementStream() {
-  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());
+  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)());
 }
-
 function _setupStandaloneComposeElementStream() {
-  return _waitForContainerAndMonitorChildrenStream(() =>
-    GmailElementGetter.StandaloneCompose.getComposeWindowContainer()
-  );
+  return _waitForContainerAndMonitorChildrenStream(() => _gmailElementGetter.default.StandaloneCompose.getComposeWindowContainer());
 }
-
-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 _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 _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;
   };
-}
+}