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

package/src/platform-implementation-js/driver-interfaces/thread-row-view-driver.js

@@ -1,11 +1 @@
-/* @flow */
-
-export type ThreadRowViewDriver = {
-  addLabel(label: Object): void,
-  addButton(buttonDescriptor: Object): void,
-  addAttachmentIcon(opts: Object): void,
-  replaceDate(opts: Object): void,
-  getSubject(): string,
-  getDateString(): string,
-  getThreadID(): string,
-};
+"use strict";

package/src/platform-implementation-js/lib/array-to-lifetimes.js

@@ -1,52 +1,53 @@
-/* @flow */
-
-import Kefir from 'kefir';
-import kefirStopper from 'kefir-stopper';
-import type { Stopper } from 'kefir-stopper';
-
-import type { ItemWithLifetime } from './dom/make-element-child-stream';
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = arrayToLifetimes;
+var _kefir = _interopRequireDefault(require("kefir"));
+var _kefirStopper = _interopRequireDefault(require("kefir-stopper"));
 // Takes in a stream of arrays of elements, and returns a stream of
 // ItemWithLifetime objects. The removalStream emits an event when the input
 // stream ends, when the input stream emits a new array not containing the
 // element, or when the output stream is unsubscribed from, similar to
 // makeElementChildStream.
-
 // TODO replace usages of this with https://www.npmjs.com/package/live-set,
 // and then remove this.
-
-export default function arrayToLifetimes<T>(
-  input: Kefir.Observable<Array<T> | NodeList<T>>,
-  keyFn?: (value: T) => any
-): Kefir.Observable<ItemWithLifetime<T>> {
-  return Kefir.stream((emitter) => {
-    const items: Map<any, { el: T, removalStream: Stopper }> = new Map();
-
+function arrayToLifetimes(input, keyFn) {
+  return _kefir.default.stream(emitter => {
+    const items = new Map();
     function listener(event) {
       switch (event.type) {
-        case 'value': {
-          const els = event.value;
-          const elKeys = keyFn ? Array.prototype.map.call(els, keyFn) : els;
-
-          items.forEach(({ el, removalStream }, key) => {
-            if (Array.prototype.indexOf.call(elKeys, key) < 0) {
-              items.delete(key);
-              removalStream.destroy();
-            }
-          });
-
-          for (let i = 0, len = els.length; i < len; i++) {
-            const el: T = els[i];
-            const elKey = elKeys[i];
-            if (!items.has(elKey)) {
-              const removalStream = kefirStopper();
-              const itemWithLifetime = { el, removalStream };
-              items.set(elKey, itemWithLifetime);
-              emitter.emit((itemWithLifetime: any));
+        case 'value':
+          {
+            const els = event.value;
+            const elKeys = keyFn ? Array.prototype.map.call(els, keyFn) : els;
+            items.forEach((_ref, key) => {
+              let {
+                el,
+                removalStream
+              } = _ref;
+              if (Array.prototype.indexOf.call(elKeys, key) < 0) {
+                items.delete(key);
+                removalStream.destroy();
+              }
+            });
+            for (let i = 0, len = els.length; i < len; i++) {
+              const el = els[i];
+              const elKey = elKeys[i];
+              if (!items.has(elKey)) {
+                const removalStream = (0, _kefirStopper.default)();
+                const itemWithLifetime = {
+                  el,
+                  removalStream
+                };
+                items.set(elKey, itemWithLifetime);
+                emitter.emit(itemWithLifetime);
+              }
             }
+            break;
           }
-          break;
-        }
         case 'error':
           emitter.error(event.value);
           break;
@@ -54,14 +55,15 @@ export default function arrayToLifetimes<T>(
           emitter.end();
       }
     }
-
     input.onAny(listener);
-
     return () => {
-      items.forEach(({ removalStream }) => {
+      items.forEach(_ref2 => {
+        let {
+          removalStream
+        } = _ref2;
         removalStream.destroy();
       });
       input.offAny(listener);
     };
   });
-}
+}

package/src/platform-implementation-js/lib/array-to-lifetimes.test.js

@@ -1,171 +1,155 @@
-/* @flow */
+"use strict";
 
-import asap from 'asap';
-import Kefir from 'kefir';
-import kefirStopper from 'kefir-stopper';
-import sinon from 'sinon';
-
-import arrayToLifetimes from './array-to-lifetimes';
-
-it('works', (cb) => {
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _asap = _interopRequireDefault(require("asap"));
+var _kefir = _interopRequireDefault(require("kefir"));
+var _kefirStopper = _interopRequireDefault(require("kefir-stopper"));
+var _sinon = _interopRequireDefault(require("sinon"));
+var _arrayToLifetimes = _interopRequireDefault(require("./array-to-lifetimes"));
+it('works', cb => {
   const events = [];
-  arrayToLifetimes(
-    Kefir.sequentially(0, [
-      ['a', 'b'],
-      ['b', 'd'],
-      ['a', 'b', 'c'],
-    ])
-  )
-    .onValue(({ el, removalStream }) => {
-      events.push(['add', el]);
-      removalStream.take(1).onValue(() => {
-        events.push(['remove', el]);
-      });
-    })
-    .onEnd(() => {
-      asap(() => {
-        expect(events).toEqual([
-          ['add', 'a'],
-          ['add', 'b'],
-          ['remove', 'a'],
-          ['add', 'd'],
-          ['remove', 'd'],
-          ['add', 'a'],
-          ['add', 'c'],
-          ['remove', 'b'],
-          ['remove', 'a'],
-          ['remove', 'c'],
-        ]);
-        cb();
-      });
+  (0, _arrayToLifetimes.default)(_kefir.default.sequentially(0, [['a', 'b'], ['b', 'd'], ['a', 'b', 'c']])).onValue(_ref => {
+    let {
+      el,
+      removalStream
+    } = _ref;
+    events.push(['add', el]);
+    removalStream.take(1).onValue(() => {
+      events.push(['remove', el]);
     });
+  }).onEnd(() => {
+    (0, _asap.default)(() => {
+      expect(events).toEqual([['add', 'a'], ['add', 'b'], ['remove', 'a'], ['add', 'd'], ['remove', 'd'], ['add', 'a'], ['add', 'c'], ['remove', 'b'], ['remove', 'a'], ['remove', 'c']]);
+      cb();
+    });
+  });
 });
-
-it('keyFn works', (cb) => {
+it('keyFn works', cb => {
   const events = [];
-  arrayToLifetimes(
-    Kefir.sequentially(0, [
-      [
-        { v: 'a', k: 1 },
-        { v: 'b', k: 2 },
-      ],
-      [
-        { v: 'B', k: 2 },
-        { v: 'd', k: 4 },
-      ],
-      [
-        { v: 'A', k: 1 },
-        { v: 'b', k: 2 },
-        { v: 'c', k: 3 },
-      ],
-    ]),
-    (el) => el.k
-  )
-    .onValue(({ el, removalStream }) => {
-      events.push(['add', el]);
-      removalStream.take(1).onValue(() => {
-        events.push(['remove', el]);
-      });
-    })
-    .onEnd(() => {
-      asap(() => {
-        expect(events).toEqual([
-          ['add', { v: 'a', k: 1 }],
-          ['add', { v: 'b', k: 2 }],
-          ['remove', { v: 'a', k: 1 }],
-          ['add', { v: 'd', k: 4 }],
-          ['remove', { v: 'd', k: 4 }],
-          ['add', { v: 'A', k: 1 }],
-          ['add', { v: 'c', k: 3 }],
-          ['remove', { v: 'b', k: 2 }],
-          ['remove', { v: 'A', k: 1 }],
-          ['remove', { v: 'c', k: 3 }],
-        ]);
-        cb();
-      });
+  (0, _arrayToLifetimes.default)(_kefir.default.sequentially(0, [[{
+    v: 'a',
+    k: 1
+  }, {
+    v: 'b',
+    k: 2
+  }], [{
+    v: 'B',
+    k: 2
+  }, {
+    v: 'd',
+    k: 4
+  }], [{
+    v: 'A',
+    k: 1
+  }, {
+    v: 'b',
+    k: 2
+  }, {
+    v: 'c',
+    k: 3
+  }]]), el => el.k).onValue(_ref2 => {
+    let {
+      el,
+      removalStream
+    } = _ref2;
+    events.push(['add', el]);
+    removalStream.take(1).onValue(() => {
+      events.push(['remove', el]);
+    });
+  }).onEnd(() => {
+    (0, _asap.default)(() => {
+      expect(events).toEqual([['add', {
+        v: 'a',
+        k: 1
+      }], ['add', {
+        v: 'b',
+        k: 2
+      }], ['remove', {
+        v: 'a',
+        k: 1
+      }], ['add', {
+        v: 'd',
+        k: 4
+      }], ['remove', {
+        v: 'd',
+        k: 4
+      }], ['add', {
+        v: 'A',
+        k: 1
+      }], ['add', {
+        v: 'c',
+        k: 3
+      }], ['remove', {
+        v: 'b',
+        k: 2
+      }], ['remove', {
+        v: 'A',
+        k: 1
+      }], ['remove', {
+        v: 'c',
+        k: 3
+      }]]);
+      cb();
     });
+  });
 });
-
-it('unsubscription triggers removal', (cb) => {
+it('unsubscription triggers removal', cb => {
   const events = [];
-  const stopper = kefirStopper();
-  arrayToLifetimes(Kefir.sequentially(50, [['a', 'b'], ['a'], ['a', 'b', 'c']]))
-    .takeUntilBy(stopper)
-    .onValue(({ el, removalStream }) => {
-      events.push(['add', el]);
-      removalStream.take(1).onValue(() => {
-        events.push(['remove', el]);
-        stopper.destroy();
-      });
-    })
-    .onEnd(() => {
-      asap(() => {
-        expect(events).toEqual([
-          ['add', 'a'],
-          ['add', 'b'],
-          ['remove', 'b'],
-          ['remove', 'a'],
-        ]);
-        cb();
-      });
+  const stopper = (0, _kefirStopper.default)();
+  (0, _arrayToLifetimes.default)(_kefir.default.sequentially(50, [['a', 'b'], ['a'], ['a', 'b', 'c']])).takeUntilBy(stopper).onValue(_ref3 => {
+    let {
+      el,
+      removalStream
+    } = _ref3;
+    events.push(['add', el]);
+    removalStream.take(1).onValue(() => {
+      events.push(['remove', el]);
+      stopper.destroy();
+    });
+  }).onEnd(() => {
+    (0, _asap.default)(() => {
+      expect(events).toEqual([['add', 'a'], ['add', 'b'], ['remove', 'b'], ['remove', 'a']]);
+      cb();
     });
+  });
 });
-
-it('works with properties', (cb) => {
+it('works with properties', cb => {
   const events = [];
-  arrayToLifetimes(
-    Kefir.sequentially(0, [['a', 'c']]).toProperty(() => ['a', 'b'])
-  )
-    .onValue(({ el, removalStream }) => {
-      events.push(['add', el]);
-      removalStream.take(1).onValue(() => {
-        events.push(['remove', el]);
-      });
-    })
-    .onEnd(() => {
-      asap(() => {
-        expect(events).toEqual([
-          ['add', 'a'],
-          ['add', 'b'],
-          ['remove', 'b'],
-          ['add', 'c'],
-          ['remove', 'a'],
-          ['remove', 'c'],
-        ]);
-        cb();
-      });
+  (0, _arrayToLifetimes.default)(_kefir.default.sequentially(0, [['a', 'c']]).toProperty(() => ['a', 'b'])).onValue(_ref4 => {
+    let {
+      el,
+      removalStream
+    } = _ref4;
+    events.push(['add', el]);
+    removalStream.take(1).onValue(() => {
+      events.push(['remove', el]);
     });
+  }).onEnd(() => {
+    (0, _asap.default)(() => {
+      expect(events).toEqual([['add', 'a'], ['add', 'b'], ['remove', 'b'], ['add', 'c'], ['remove', 'a'], ['remove', 'c']]);
+      cb();
+    });
+  });
 });
-
-it('passes errors', (cb) => {
+it('passes errors', cb => {
   const events = [];
-  arrayToLifetimes(
-    Kefir.merge([
-      Kefir.constantError('foo'),
-      Kefir.sequentially(0, [['a', 'b'], ['a']]),
-    ])
-  )
-    .onAny((event) => {
-      if (event.type === 'value') {
-        const { el, removalStream } = event.value;
-        events.push(['add', el]);
-        removalStream.take(1).onValue(() => {
-          events.push(['remove', el]);
-        });
-      } else if (event.type === 'error') {
-        events.push(['error', event.value]);
-      }
-    })
-    .onEnd(() => {
-      asap(() => {
-        expect(events).toEqual([
-          ['error', 'foo'],
-          ['add', 'a'],
-          ['add', 'b'],
-          ['remove', 'b'],
-          ['remove', 'a'],
-        ]);
-        cb();
+  (0, _arrayToLifetimes.default)(_kefir.default.merge([_kefir.default.constantError('foo'), _kefir.default.sequentially(0, [['a', 'b'], ['a']])])).onAny(event => {
+    if (event.type === 'value') {
+      const {
+        el,
+        removalStream
+      } = event.value;
+      events.push(['add', el]);
+      removalStream.take(1).onValue(() => {
+        events.push(['remove', el]);
       });
+    } else if (event.type === 'error') {
+      events.push(['error', event.value]);
+    }
+  }).onEnd(() => {
+    (0, _asap.default)(() => {
+      expect(events).toEqual([['error', 'foo'], ['add', 'a'], ['add', 'b'], ['remove', 'b'], ['remove', 'a']]);
+      cb();
     });
-});
+  });
+});

package/src/platform-implementation-js/lib/copyAndValidateAutocompleteResults.js

@@ -1,55 +1,36 @@
-/* @flow */
+"use strict";
 
-import type { Driver } from '../driver-interfaces/driver';
-import type { AutocompleteSearchResult } from '../../injected-js/gmail/modify-suggestions';
-
-export default function copyAndValidateAutocompleteResults(
-  driver: Driver,
-  results: Array<AutocompleteSearchResult>
-): Array<AutocompleteSearchResult> {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = copyAndValidateAutocompleteResults;
+function copyAndValidateAutocompleteResults(driver, results) {
   if (!Array.isArray(results)) {
     throw new Error('suggestions must be an array');
   }
-
-  return results.map((result) => {
-    const resultCopy = { ...result };
-    if (
-      typeof resultCopy.name !== 'string' &&
-      typeof resultCopy.nameHTML !== 'string'
-    ) {
+  return results.map(result => {
+    const resultCopy = {
+      ...result
+    };
+    if (typeof resultCopy.name !== 'string' && typeof resultCopy.nameHTML !== 'string') {
       throw new Error('suggestion must have name or nameHTML property');
     }
-    if (
-      typeof resultCopy.routeName !== 'string' &&
-      typeof resultCopy.externalURL !== 'string' &&
-      typeof resultCopy.searchTerm !== 'string' &&
-      typeof resultCopy.onClick !== 'function'
-    ) {
-      throw new Error(
-        'suggestion must have routeName, externalURL, ' +
-          'searchTerm, or onClick property'
-      );
+    if (typeof resultCopy.routeName !== 'string' && typeof resultCopy.externalURL !== 'string' && typeof resultCopy.searchTerm !== 'string' && typeof resultCopy.onClick !== 'function') {
+      throw new Error('suggestion must have routeName, externalURL, ' + 'searchTerm, or onClick property');
     }
-    if (typeof (resultCopy: any).iconURL === 'string') {
-      const iconURL = (resultCopy: any).iconURL;
-      driver
-        .getLogger()
-        .deprecationWarning(
-          'AutocompleteSearchResult "iconURL" property',
-          'AutocompleteSearchResult.iconUrl'
-        );
+    if (typeof resultCopy.iconURL === 'string') {
+      const iconURL = resultCopy.iconURL;
+      driver.getLogger().deprecationWarning('AutocompleteSearchResult "iconURL" property', 'AutocompleteSearchResult.iconUrl');
       if (!resultCopy.iconUrl) {
         if (driver.getOpts().REQUESTED_API_VERSION === 1) {
           resultCopy.iconUrl = iconURL;
         } else {
           // eslint-disable-next-line no-console
-          console.error(
-            'Support for iconURL property was dropped after API version 1'
-          );
+          console.error('Support for iconURL property was dropped after API version 1');
         }
       }
-      delete (resultCopy: any).iconURL;
+      delete resultCopy.iconURL;
     }
     return resultCopy;
   });
-}
+}

package/src/platform-implementation-js/lib/css-selector-escape.js

@@ -1,8 +1,12 @@
-/* @flow */
+"use strict";
 
-export default function cssSelectorEscape(text: string): string {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cssSelectorEscape;
+function cssSelectorEscape(text) {
   if (text.length === 0 || /^-?[0-9]/.test(text)) {
     throw new Error('Invalid CSS selector');
   }
   return text.replace(/[^a-z0-9]/g, '\\$&');
-}
+}

package/src/platform-implementation-js/lib/dom/element-view-mapper.js

@@ -1,20 +1,17 @@
-/* @flow */
-
-import type Kefir from 'kefir';
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = elementViewMapper;
 // Returns a function suitable for mapping over a stream returned from
 // makeElementChildStream or kefirMakeElementChildStream.
-type View = { destroy(): void };
-import type { ElementWithLifetime } from './make-element-child-stream';
-
-export default function elementViewMapper<T: View>(
-  viewFn: (el: HTMLElement) => T
-): (event: ElementWithLifetime) => T {
-  return (event) => {
+function elementViewMapper(viewFn) {
+  return event => {
     const view = viewFn(event.el);
     event.removalStream.take(1).onValue(() => {
       view.destroy();
     });
     return view;
   };
-}
+}

package/src/platform-implementation-js/lib/dom/get-selection.js

@@ -1,61 +1,32 @@
-/* @flow */
+"use strict";
 
-import t from 'transducers.js';
-
-function isRangeEmpty(range: Range): boolean {
-  return (
-    range.startContainer === range.endContainer &&
-    range.startOffset === range.endOffset
-  );
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSelectedHTMLInElement = getSelectedHTMLInElement;
+exports.getSelectedTextInElement = getSelectedTextInElement;
+var _transducers = _interopRequireDefault(require("transducers.js"));
+function isRangeEmpty(range) {
+  return range.startContainer === range.endContainer && range.startOffset === range.endOffset;
 }
 
 // returns true if either end appears to be inside the element
-function isRangeInElement(range: Range, el: HTMLElement): boolean {
+function isRangeInElement(range, el) {
   return el.contains(range.startContainer) || el.contains(range.endContainer);
 }
-
-function isRangeSuitable(range: Range, el: HTMLElement): boolean {
+function isRangeSuitable(range, el) {
   return !isRangeEmpty(range) && isRangeInElement(range, el);
 }
-
-export function getSelectedTextInElement(
-  element: HTMLElement,
-  lastRange?: ?Range
-): ?string {
-  const selection = (document: any).getSelection();
-  return t.toArray(
-    [
-      selection && selection.rangeCount ? selection.getRangeAt(0) : null,
-      lastRange,
-    ],
-    t.compose(
-      t.keep(),
-      t.filter((range: Range) => isRangeSuitable(range, element)),
-      t.map((range: Range) => range.toString()),
-      t.take(1)
-    )
-  )[0];
-}
-
-export function getSelectedHTMLInElement(
-  element: HTMLElement,
-  lastRange?: ?Range
-): ?string {
-  const selection = (document: any).getSelection();
-  return t.toArray(
-    [
-      selection && selection.rangeCount ? selection.getRangeAt(0) : null,
-      lastRange,
-    ],
-    t.compose(
-      t.keep(),
-      t.filter((range: Range) => isRangeSuitable(range, element)),
-      t.map((range: Range) => {
-        const div = document.createElement('div');
-        div.appendChild(range.cloneContents());
-        return div.innerHTML;
-      }),
-      t.take(1)
-    )
-  )[0];
+function getSelectedTextInElement(element, lastRange) {
+  const selection = document.getSelection();
+  return _transducers.default.toArray([selection && selection.rangeCount ? selection.getRangeAt(0) : null, lastRange], _transducers.default.compose(_transducers.default.keep(), _transducers.default.filter(range => isRangeSuitable(range, element)), _transducers.default.map(range => range.toString()), _transducers.default.take(1)))[0];
 }
+function getSelectedHTMLInElement(element, lastRange) {
+  const selection = document.getSelection();
+  return _transducers.default.toArray([selection && selection.rangeCount ? selection.getRangeAt(0) : null, lastRange], _transducers.default.compose(_transducers.default.keep(), _transducers.default.filter(range => isRangeSuitable(range, element)), _transducers.default.map(range => {
+    const div = document.createElement('div');
+    div.appendChild(range.cloneContents());
+    return div.innerHTML;
+  }), _transducers.default.take(1)))[0];
+}