@inboxsdk/core 0.2.28-alpha.6 → 0.2.28

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

@@ -1 +1,32 @@
-"use strict";
+/* @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,
+};

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

@@ -1 +1,11 @@
-"use strict";
+/* @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,
+};

package/src/platform-implementation-js/lib/ErrorCollector.d.ts

@@ -15,4 +15,3 @@ export default class ErrorCollector {
     errorCount(): number;
 }
 export {};
-//# sourceMappingURL=ErrorCollector.d.ts.map

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

@@ -10,4 +10,3 @@ export default class Membrane {
     get(wet: any): any;
 }
 export {};
-//# sourceMappingURL=Membrane.d.ts.map

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

@@ -6,4 +6,3 @@ export default class ScrollableContainByScreen {
     reposition(): void;
     destroy(): void;
 }
-//# sourceMappingURL=ScrollableContainByScreen.d.ts.map

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

@@ -1,53 +1,52 @@
-"use strict";
+/* @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';
 
-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.
-function arrayToLifetimes(input, keyFn) {
-  return _kefir.default.stream(emitter => {
-    const items = new Map();
+
+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 listener(event) {
       switch (event.type) {
-        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);
-              }
+        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));
             }
-            break;
           }
+          break;
+        }
         case 'error':
           emitter.error(event.value);
           break;
@@ -55,15 +54,14 @@ function arrayToLifetimes(input, keyFn) {
           emitter.end();
       }
     }
+
     input.onAny(listener);
+
     return () => {
-      items.forEach(_ref2 => {
-        let {
-          removalStream
-        } = _ref2;
+      items.forEach(({ removalStream }) => {
         removalStream.destroy();
       });
       input.offAny(listener);
     };
   });
-}
+}

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

@@ -1,155 +1,171 @@
-"use strict";
+/* @flow */
 
-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 = [];
-  (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 => {
+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) => {
   const events = [];
-  (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();
+  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();
+      });
     });
-  });
 });
-it('unsubscription triggers removal', cb => {
+
+it('keyFn works', (cb) => {
   const events = [];
-  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();
+  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();
+      });
     });
-  });
 });
-it('works with properties', cb => {
+
+it('unsubscription triggers removal', (cb) => {
   const events = [];
-  (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();
+  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();
+      });
     });
-  });
 });
-it('passes errors', cb => {
+
+it('works with properties', (cb) => {
   const events = [];
-  (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;
+  arrayToLifetimes(
+    Kefir.sequentially(0, [['a', 'c']]).toProperty(() => ['a', 'b'])
+  )
+    .onValue(({ el, removalStream }) => {
       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();
+    })
+    .onEnd(() => {
+      asap(() => {
+        expect(events).toEqual([
+          ['add', 'a'],
+          ['add', 'b'],
+          ['remove', 'b'],
+          ['add', 'c'],
+          ['remove', 'a'],
+          ['remove', 'c'],
+        ]);
+        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();
+      });
     });
-  });
-});
+});

package/src/platform-implementation-js/lib/attemptWithRetries.d.ts

@@ -1,2 +1 @@
 export default function attemptWithRetries<T>(fn: () => Promise<T>, attemptCount: number, errorsToRetry?: (error: unknown) => boolean): Promise<T>;
-//# sourceMappingURL=attemptWithRetries.d.ts.map

package/src/platform-implementation-js/lib/common-page-communicator.d.ts

@@ -17,4 +17,3 @@ export default class CommonPageCommunicator {
     silenceGmailErrorsForAMoment(): () => void;
     registerAllowedHashLinkStartTerm(term: string): void;
 }
-//# sourceMappingURL=common-page-communicator.d.ts.map

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

@@ -1,36 +1,55 @@
-"use strict";
+/* @flow */
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = copyAndValidateAutocompleteResults;
-function copyAndValidateAutocompleteResults(driver, results) {
+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> {
   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.iconURL === 'string') {
-      const iconURL = resultCopy.iconURL;
-      driver.getLogger().deprecationWarning('AutocompleteSearchResult "iconURL" property', 'AutocompleteSearchResult.iconUrl');
+    if (typeof (resultCopy: any).iconURL === 'string') {
+      const iconURL = (resultCopy: any).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.iconURL;
+      delete (resultCopy: any).iconURL;
     }
     return resultCopy;
   });
-}
+}

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

@@ -1,12 +1,8 @@
-"use strict";
+/* @flow */
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = cssSelectorEscape;
-function cssSelectorEscape(text) {
+export default function cssSelectorEscape(text: string): string {
   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/delay-asap.d.ts

@@ -1,3 +1,2 @@
 import * as Kefir from 'kefir';
 export default function delayAsap<T>(value: T): Kefir.Observable<T, never>;
-//# sourceMappingURL=delay-asap.d.ts.map

package/src/platform-implementation-js/lib/delay-idle.d.ts

@@ -1,3 +1,2 @@
 import * as Kefir from 'kefir';
 export default function delayIdle<T>(timeout: number | null, value: T): Kefir.Observable<T, never>;
-//# sourceMappingURL=delay-idle.d.ts.map

package/src/platform-implementation-js/lib/dom/block-and-reemit-keyboard-events.d.ts

@@ -1,2 +1 @@
 export default function blockAndReemiteKeyboardEvents(element: HTMLElement): void;
-//# sourceMappingURL=block-and-reemit-keyboard-events.d.ts.map

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

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

package/src/platform-implementation-js/lib/dom/generic-button-view.d.ts

@@ -10,4 +10,3 @@ export default class GenericButtonView {
     deactivate(): void;
     private _setupEventStream;
 }
-//# sourceMappingURL=generic-button-view.d.ts.map

package/src/platform-implementation-js/lib/dom/get-insert-before-element.d.ts

@@ -1,2 +1 @@
 export default function getInsertBeforeElement(checkElement: HTMLElement, childElements: ArrayLike<any>, dataAttributes: string[]): HTMLElement | null;
-//# sourceMappingURL=get-insert-before-element.d.ts.map