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

package/src/platform-implementation-js/driver-interfaces/message-view-driver.js

@@ -1,49 +1,5 @@
-/* @flow */
+"use strict";
 
-import Kefir from 'kefir';
-import type { AttachmentCardViewDriver } from './driver';
-import SafeEventEmitter from '../lib/safe-event-emitter';
-
-export type VIEW_STATE = 'HIDDEN' | 'COLLAPSED' | 'EXPANDED';
-
-export type MessageViewLinkDescriptor = {
-  text: string,
-  html: string,
-  element: HTMLElement,
-  href: string,
-  isInQuotedArea: boolean,
-};
-
-export type MessageViewToolbarButtonDescriptor = {
-  section: 'MORE',
-  title: string,
-  iconUrl?: ?string,
-  iconClass?: ?string,
-  onClick(): void,
-  orderHint?: ?number,
-};
-
-export type AttachmentIcon = SafeEventEmitter & {};
-
-export type MessageViewDriver = {
-  getMessageID(): string,
-  getMessageIDAsync(): Promise<string>,
-  getContentsElement(): HTMLElement,
-  isElementInQuotedArea(el: HTMLElement): boolean,
-  addMoreMenuItem(options: MessageViewToolbarButtonDescriptor): void,
-  addAttachmentIcon(options: Object): AttachmentIcon,
-  getAttachmentCardViewDrivers(): Array<AttachmentCardViewDriver>,
-  addAttachmentCard(options: Object): AttachmentCardViewDriver,
-  addButtonToDownloadAllArea(options: Object): void,
-  getEventStream(): Kefir.Observable<Object>,
-  getViewState(): VIEW_STATE,
-  getDateString(): string,
-  getSender(): Contact,
-  getReadyStream(): Kefir.Observable<any>,
-  getRecipients(): Array<Contact>,
-  getRecipientEmailAddresses(): Array<string>,
-  getRecipientsFull(): Promise<Array<Contact>>,
-  getThreadViewDriver(): Object,
-  isLoaded(): boolean,
-  hasOpenReply(): boolean,
-};
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _kefir = _interopRequireDefault(require("kefir"));
+var _safeEventEmitter = _interopRequireDefault(require("../lib/safe-event-emitter"));

package/src/platform-implementation-js/driver-interfaces/mole-view-driver.js

@@ -1,29 +1 @@
-/* @flow */
-
-import type Kefir from 'kefir';
-
-export type MoleViewDriver = {
-  show(): void,
-  setTitle(title: string): void,
-  setMinimized(minimized: boolean): void,
-  getMinimized(): boolean,
-  getEventStream(): Kefir.Observable<Object>,
-  destroy(): void,
-};
-
-export type MoleButtonDescriptor = {
-  title: string,
-  iconUrl: string,
-  iconClass?: string,
-  onClick: Function,
-};
-
-export type MoleOptions = {
-  el: HTMLElement,
-  className?: string,
-  title?: string,
-  titleEl?: HTMLElement,
-  minimizedTitleEl?: HTMLElement,
-  titleButtons?: MoleButtonDescriptor[],
-  chrome?: boolean,
-};
+"use strict";

package/src/platform-implementation-js/driver-interfaces/route-view-driver.js

@@ -1,32 +1 @@
-/* @flow */
-
-import type Kefir from 'kefir';
-
-import type GmailCollapsibleSectionView from '../dom-driver/gmail/views/gmail-collapsible-section-view';
-
-// The necessary interface that Router and RouteView expect.
-export type MinRouteViewDriver = {
-  getRouteType(): string,
-  getRouteID(): string,
-  getParams(): { [ix: string]: string },
-  getEventStream(): Kefir.Observable<Object>,
-  getStopper(): Kefir.Observable<any>,
-};
-
-// The necessary interface that ListRouteView and CustomRouteView expect.
-export type RouteViewDriver = MinRouteViewDriver & {
-  refresh(): void,
-  getType(): string,
-  getHash(): string,
-  addSection(
-    sectionDescriptorProperty: Kefir.Observable<?Object>,
-    groupOrderHint: any
-  ): GmailCollapsibleSectionView,
-  addCollapsibleSection(
-    sectionDescriptorProperty: Kefir.Observable<?Object>,
-    groupOrderHint: any
-  ): GmailCollapsibleSectionView,
-
-  getCustomViewElement(): ?HTMLElement,
-  setFullWidth(fullWidth: boolean): void,
-};
+"use strict";

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/ErrorCollector.js

@@ -0,0 +1,47 @@
+import Logger from './logger';
+export default class ErrorCollector {
+    _name;
+    _runCount = 0;
+    _errorLogs = [];
+    _hasReported = false;
+    constructor(name) {
+        this._name = name;
+    }
+    run(name, cb) {
+        if (this._hasReported) {
+            throw new Error('Has already reported');
+        }
+        this._runCount++;
+        try {
+            return cb();
+        }
+        catch (e) {
+            this._errorLogs.push({
+                name,
+                message: e.message,
+            });
+            return null;
+        }
+    }
+    report(errorDataCb) {
+        if (this._hasReported) {
+            throw new Error('Has already reported');
+        }
+        this._hasReported = true;
+        if (this._errorLogs.length) {
+            Logger.error(new Error(`Error Collector: ${this._name}`), {
+                errorLogs: this._errorLogs,
+                extra: errorDataCb(),
+            });
+        }
+    }
+    getErrorLogs() {
+        return this._errorLogs;
+    }
+    runCount() {
+        return this._runCount;
+    }
+    errorCount() {
+        return this._errorLogs.length;
+    }
+}

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

@@ -0,0 +1,22 @@
+// Used to make the *View objects out of our *ViewDriver objects, and to make
+// sure we return the same *View object back if we've already made one for
+// given *ViewDriver.
+export default class Membrane {
+    _mappers;
+    _map = new WeakMap();
+    constructor(mappers) {
+        this._mappers = new Map(mappers);
+    }
+    get(wet) {
+        let dry = this._map.get(wet);
+        if (!dry) {
+            const mapperFn = this._mappers.get(wet.constructor);
+            if (!mapperFn) {
+                throw new Error(`Unknown class ${wet.constructor.name}`);
+            }
+            dry = mapperFn(wet);
+            this._map.set(wet, dry);
+        }
+        return dry;
+    }
+}

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

@@ -0,0 +1,30 @@
+import containByScreen from 'contain-by-screen';
+import Kefir from 'kefir';
+import kefirBus from 'kefir-bus';
+import kefirStopper from 'kefir-stopper';
+import fromEventsWithOptions from './fromEventsWithOptions';
+export default class ScrollableContainByScreen {
+    _manualRepositions = kefirBus();
+    _stopper = kefirStopper();
+    constructor(element, anchorPoint, options) {
+        Kefir.merge([
+            this._manualRepositions,
+            Kefir.fromEvents(window, 'resize'),
+            fromEventsWithOptions(window, 'scroll', {
+                capture: true,
+                passive: true,
+            }).filter((event) => event.target.contains(anchorPoint)),
+        ])
+            .toProperty(() => null)
+            .takeUntilBy(this._stopper)
+            .onValue(() => {
+            containByScreen(element, anchorPoint, options);
+        });
+    }
+    reposition() {
+        this._manualRepositions.emit(null);
+    }
+    destroy() {
+        this._stopper.destroy();
+    }
+}

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/attemptWithRetries.js

@@ -0,0 +1,16 @@
+export default async function attemptWithRetries(fn, attemptCount, errorsToRetry = () => true) {
+    if (attemptCount < 1) {
+        throw new Error('Attempt count must be positive');
+    }
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (attemptCount > 1 && errorsToRetry(err)) {
+            return attemptWithRetries(fn, attemptCount - 1, errorsToRetry);
+        }
+        else {
+            throw err;
+        }
+    }
+}