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

package/src/platform-implementation-js/lib/persistent-queue.js

@@ -0,0 +1,107 @@
+// Queue which tries to persist its data into localStorage so its contents
+// aren't wiped when the page is closed. It handles localStorage not being
+// present or not working (such as if we're running into quota issues).
+// Safe for use in multiple tabs on the same domain at once.
+export default class PersistentQueue {
+    _fallbackQueue = [];
+    _sid;
+    constructor(id) {
+        this._sid = 'inboxsdk__persistentqueue_' + id;
+    }
+    _getSavedQueue() {
+        let queue = JSON.parse(localStorage.getItem(this._sid));
+        if (queue == null) {
+            queue = [];
+        }
+        return queue;
+    }
+    _putSavedQueue(queue) {
+        localStorage.setItem(this._sid, JSON.stringify(queue));
+    }
+    _clearSavedQueue() {
+        localStorage.removeItem(this._sid);
+    }
+    add(val) {
+        let success = false;
+        if (typeof localStorage !== 'undefined') {
+            try {
+                const queue = this._getSavedQueue();
+                queue.push(val);
+                this._putSavedQueue(queue);
+                success = true;
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        if (!success) {
+            this._fallbackQueue.push(val);
+        }
+    }
+    remove() {
+        let ret;
+        if (typeof localStorage !== 'undefined') {
+            try {
+                const queue = this._getSavedQueue();
+                const tmpRet = queue.shift();
+                this._putSavedQueue(queue);
+                ret = tmpRet;
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        // If we didn't get anything from the localStorage queue, or if we
+        // failed to update the queue, then try the fallback instead.
+        if (ret === undefined) {
+            ret = this._fallbackQueue.shift();
+        }
+        return ret;
+    }
+    removeAll() {
+        let ret = undefined;
+        if (typeof localStorage !== 'undefined') {
+            try {
+                const queue = this._getSavedQueue();
+                this._clearSavedQueue();
+                ret = queue;
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        if (ret === undefined) {
+            ret = [];
+        }
+        ret = ret.concat(this._fallbackQueue);
+        this._fallbackQueue = [];
+        return ret;
+    }
+    peekAll() {
+        let ret = undefined;
+        if (typeof localStorage !== 'undefined') {
+            try {
+                ret = this._getSavedQueue();
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        if (ret === undefined) {
+            ret = [];
+        }
+        ret = ret.concat(this._fallbackQueue);
+        return ret;
+    }
+    clear() {
+        if (typeof localStorage !== 'undefined') {
+            try {
+                this._clearSavedQueue();
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        this._fallbackQueue.length = 0;
+    }
+}

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

@@ -1,14 +1,13 @@
-/* @flow */
+"use strict";
 
-import type { RouteParams } from '../namespaces/router';
-
-export default function populateRouteID(
-  routeID: string,
-  params: ?RouteParams
-): string {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = populateRouteID;
+function populateRouteID(routeID, params) {
   const paramsObject = params || {};
   const usedParams = new Set();
-  const result = routeID.replace(/:([^/]+)/g, (whole: string, term: string) => {
+  const result = routeID.replace(/:([^/]+)/g, (whole, term) => {
     if (term in paramsObject) {
       usedParams.add(term);
       return encodeURIComponent(String(paramsObject[term]));
@@ -20,4 +19,4 @@ export default function populateRouteID(
     throw new Error('Extra parameters given');
   }
   return result;
-}
+}

package/src/platform-implementation-js/lib/populateRouteID.test.js

@@ -1,31 +1,32 @@
-/* @flow */
-
-import populateRouteID from './populateRouteID';
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _populateRouteID = _interopRequireDefault(require("./populateRouteID"));
 test('works with no params', () => {
-  expect(populateRouteID('a/b', null)).toBe('a/b');
+  expect((0, _populateRouteID.default)('a/b', null)).toBe('a/b');
 });
-
 test('works with params', () => {
-  expect(populateRouteID('a/:id/b/:foo', { id: 'aaa', foo: '456' })).toBe(
-    'a/aaa/b/456'
-  );
+  expect((0, _populateRouteID.default)('a/:id/b/:foo', {
+    id: 'aaa',
+    foo: '456'
+  })).toBe('a/aaa/b/456');
 });
-
 test('works with params that are not preceded by a slash', () => {
-  expect(populateRouteID('a/foo:id/b', { id: 'aaa' })).toBe('a/fooaaa/b');
+  expect((0, _populateRouteID.default)('a/foo:id/b', {
+    id: 'aaa'
+  })).toBe('a/fooaaa/b');
 });
-
 test('url encodes', () => {
-  expect(populateRouteID('a/:id', { id: '%/$\'"' })).toBe("a/%25%2F%24'%22");
+  expect((0, _populateRouteID.default)('a/:id', {
+    id: '%/$\'"'
+  })).toBe("a/%25%2F%24'%22");
 });
-
 test('throws if missing params', () => {
-  expect(() => populateRouteID('a/:id', {})).toThrowError();
+  expect(() => (0, _populateRouteID.default)('a/:id', {})).toThrowError();
 });
-
 test('throws if extra params', () => {
-  expect(() =>
-    populateRouteID('a/:id', { id: '456', foo: '789' })
-  ).toThrowError();
-});
+  expect(() => (0, _populateRouteID.default)('a/:id', {
+    id: '456',
+    foo: '789'
+  })).toThrowError();
+});

package/src/platform-implementation-js/lib/react/ElementContainer.js

@@ -1,21 +1,23 @@
-/* @flow */
+"use strict";
 
-import React from 'react';
-
-type Props = {
-  className?: ?string,
-  el: HTMLElement,
-};
-export default class ElementContainer extends React.Component<Props> {
-  props: Props;
-  _content: HTMLElement;
-  _contentRefCb = (el: ?HTMLElement) => {
-    if (el) this._content = el;
-  };
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+class ElementContainer extends _react.default.Component {
+  constructor() {
+    super(...arguments);
+    (0, _defineProperty2.default)(this, "_contentRefCb", el => {
+      if (el) this._content = el;
+    });
+  }
   componentDidMount() {
     this._content.appendChild(this.props.el);
   }
-  componentDidUpdate(prevProps: Props) {
+  componentDidUpdate(prevProps) {
     if (prevProps.el !== this.props.el) {
       while (this._content.lastElementChild) {
         this._content.lastElementChild.remove();
@@ -23,13 +25,14 @@ export default class ElementContainer extends React.Component<Props> {
       this._content.appendChild(this.props.el);
     }
   }
-  shouldComponentUpdate(nextProps: Props) {
-    return (
-      this.props.className !== nextProps.className ||
-      this.props.el !== nextProps.el
-    );
+  shouldComponentUpdate(nextProps) {
+    return this.props.className !== nextProps.className || this.props.el !== nextProps.el;
   }
   render() {
-    return <div className={this.props.className} ref={this._contentRefCb} />;
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: this.props.className,
+      ref: this._contentRefCb
+    });
   }
 }
+exports.default = ElementContainer;

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

@@ -1,10 +1,11 @@
-/* @flow */
+"use strict";
 
-import idMap from './idMap';
-
-export default function rewriteCssWithIdMap(cssSource: string): string {
-  return cssSource.replace(
-    /\.IDMAP_([-a-zA-Z0-9_]+)/g,
-    (match, classname) => `.${idMap(classname)}`
-  );
-}
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = rewriteCssWithIdMap;
+var _idMap = _interopRequireDefault(require("./idMap"));
+function rewriteCssWithIdMap(cssSource) {
+  return cssSource.replace(/\.IDMAP_([-a-zA-Z0-9_]+)/g, (match, classname) => `.${(0, _idMap.default)(classname)}`);
+}

package/src/platform-implementation-js/lib/rewriteCssWithIdMap.test.js

@@ -1,26 +1,21 @@
-/* @flow */
-
-import rewriteCssWithIdMap from './rewriteCssWithIdMap';
-
-import idMap from './idMap';
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _rewriteCssWithIdMap = _interopRequireDefault(require("./rewriteCssWithIdMap"));
+var _idMap = _interopRequireDefault(require("./idMap"));
 test('rewrites single classname', () => {
-  expect(
-    rewriteCssWithIdMap(`
+  expect((0, _rewriteCssWithIdMap.default)(`
     .IDMAP_foo {
       color: red;
     }
-  `)
-  ).toBe(`
-    .${idMap('foo')} {
+  `)).toBe(`
+    .${(0, _idMap.default)('foo')} {
       color: red;
     }
   `);
 });
-
 test('only rewrites IDMAP_ classnames', () => {
-  expect(
-    rewriteCssWithIdMap(`
+  expect((0, _rewriteCssWithIdMap.default)(`
     .blaaah {
       color: blue;
     }
@@ -28,23 +23,21 @@ test('only rewrites IDMAP_ classnames', () => {
       color: red;
     }
     .xyz .IDMAP_foo::after {}
-  `)
-  ).toBe(`
+  `)).toBe(`
     .blaaah {
       color: blue;
     }
-    .foo .x.${idMap('foo')}.y .blah .${idMap('xyz-_def3')}, .x {
+    .foo .x.${(0, _idMap.default)('foo')}.y .blah .${(0, _idMap.default)('xyz-_def3')}, .x {
       color: red;
     }
-    .xyz .${idMap('foo')}::after {}
+    .xyz .${(0, _idMap.default)('foo')}::after {}
   `);
 });
-
 test('name is not present in rewritten CSS', () => {
-  const output = rewriteCssWithIdMap(`
+  const output = (0, _rewriteCssWithIdMap.default)(`
     .IDMAP_foo3 {
       color: red;
     }
   `);
   expect(output.includes('foo3')).toBe(false);
-});
+});

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

@@ -1,20 +1,15 @@
-/* @flow */
+"use strict";
 
-import memoize from 'lodash/memoize';
-import find from 'lodash/find';
-import escapeRegExp from 'lodash/escapeRegExp';
-
-const routeIDtoRegExp: (routeID: string) => RegExp = memoize(
-  (routeID) =>
-    new RegExp(
-      '^' + escapeRegExp(routeID).replace(/\/:[^/]+/g, '/([^/]+)') + '/?$'
-    )
-);
-
-export default function routeIDmatchesHash(
-  routeID: string | Array<string>,
-  hash: string
-): ?string {
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = routeIDmatchesHash;
+var _memoize = _interopRequireDefault(require("lodash/memoize"));
+var _find = _interopRequireDefault(require("lodash/find"));
+var _escapeRegExp = _interopRequireDefault(require("lodash/escapeRegExp"));
+const routeIDtoRegExp = (0, _memoize.default)(routeID => new RegExp('^' + (0, _escapeRegExp.default)(routeID).replace(/\/:[^/]+/g, '/([^/]+)') + '/?$'));
+function routeIDmatchesHash(routeID, hash) {
   const routeIDs = Array.isArray(routeID) ? routeID : [routeID];
-  return find(routeIDs, (routeID) => hash.match(routeIDtoRegExp(routeID)));
-}
+  return (0, _find.default)(routeIDs, routeID => hash.match(routeIDtoRegExp(routeID)));
+}

package/src/platform-implementation-js/lib/routeIDmatchesHash.test.js

@@ -1,23 +1,17 @@
-/* @flow */
-
-import routeIDmatchesHash from './routeIDmatchesHash';
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _routeIDmatchesHash = _interopRequireDefault(require("./routeIDmatchesHash"));
 test('single parameter-less route works', () => {
-  expect(routeIDmatchesHash('foo/bar/def', 'foo/bar/def')).toBe('foo/bar/def');
-  expect(routeIDmatchesHash('foo/bar/def', 'foo/bax/def')).toBe(undefined);
+  expect((0, _routeIDmatchesHash.default)('foo/bar/def', 'foo/bar/def')).toBe('foo/bar/def');
+  expect((0, _routeIDmatchesHash.default)('foo/bar/def', 'foo/bax/def')).toBe(undefined);
 });
-
 test('array works', () => {
-  expect(routeIDmatchesHash(['foo', 'bar'], 'foo')).toBe('foo');
-  expect(routeIDmatchesHash(['foo', 'bar'], 'bar')).toBe('bar');
-  expect(routeIDmatchesHash(['foo', 'bar'], 'blah')).toBe(undefined);
+  expect((0, _routeIDmatchesHash.default)(['foo', 'bar'], 'foo')).toBe('foo');
+  expect((0, _routeIDmatchesHash.default)(['foo', 'bar'], 'bar')).toBe('bar');
+  expect((0, _routeIDmatchesHash.default)(['foo', 'bar'], 'blah')).toBe(undefined);
 });
-
 test('parameter works', () => {
-  expect(routeIDmatchesHash('foo/:bar/def/:blah', 'foo/123/def/x1')).toBe(
-    'foo/:bar/def/:blah'
-  );
-  expect(routeIDmatchesHash('foo/:bar/def/:blah', 'foo/123/xef/x1')).toBe(
-    undefined
-  );
-});
+  expect((0, _routeIDmatchesHash.default)('foo/:bar/def/:blah', 'foo/123/def/x1')).toBe('foo/:bar/def/:blah');
+  expect((0, _routeIDmatchesHash.default)('foo/:bar/def/:blah', 'foo/123/xef/x1')).toBe(undefined);
+});

package/src/platform-implementation-js/lib/safe-event-emitter.js

@@ -0,0 +1,17 @@
+import EventEmitter from 'events';
+import Logger from './logger';
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+// Version of EventEmitter where any exceptions thrown by event handlers are
+// caught. This is used to catch exceptions from application code.
+export default class SafeEventEmitter extends EventEmitter {
+    emit(event, ...args) {
+        try {
+            return super.emit.apply(this, arguments);
+        }
+        catch (e) {
+            Logger.error(e);
+            return true;
+        }
+    }
+}

package/src/platform-implementation-js/lib/shared-style.js

@@ -1,22 +1,23 @@
-/* @flow */
+"use strict";
 
-import type Kefir from 'kefir';
-import udKefir from 'ud-kefir';
-import rewriteCssWithIdMap from './rewriteCssWithIdMap';
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = sharedStyle;
+var _udKefir = _interopRequireDefault(require("ud-kefir"));
+var _rewriteCssWithIdMap = _interopRequireDefault(require("./rewriteCssWithIdMap"));
 var fs = require('fs');
-var cssContent: Kefir.Observable<string> = udKefir(
-  module,
-  fs.readFileSync(__dirname + '/../style/shared.css', 'utf8')
-);
-
-export default function sharedStyle(root: Document = document) {
+var cssContent = (0, _udKefir.default)(module, fs.readFileSync(__dirname + '/../style/shared.css', 'utf8'));
+function sharedStyle() {
+  let root = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
   if (!root.getElementById('inboxsdk__shared_style')) {
     const style = root.createElement('style');
     style.id = 'inboxsdk__shared_style';
-    cssContent.onValue((css) => {
-      style.textContent = rewriteCssWithIdMap(css);
+    cssContent.onValue(css => {
+      style.textContent = (0, _rewriteCssWithIdMap.default)(css);
     });
     if (!root.head) throw new Error('missing head');
     root.head.appendChild(style);
   }
-}
+}

package/src/platform-implementation-js/lib/stopper-pool.js

@@ -0,0 +1,41 @@
+import * as Kefir from 'kefir';
+// An StopperPool is created from a stopper stream, and can have more stopper
+// streams added to it. It has a stream property which is a stopper stream which
+// emits a stop event and ends only after all of its input stopper streams have
+// stopped.
+export default class StopperPool {
+    _streamCount = 0;
+    _ended = false;
+    _pool = Kefir.pool();
+    stream;
+    constructor(streams) {
+        this.stream = this._pool
+            .filter(() => {
+            this._streamCount--;
+            if (this._streamCount === 0) {
+                this._ended = true;
+                return true;
+            }
+            return false;
+        })
+            .take(1)
+            .toProperty();
+        // force stream to be active so this._streamCount, this._ended, and the
+        // property's cached value will be kept up-to-date
+        this.stream.onValue(() => {
+            // ignore
+        });
+        this.add(streams);
+    }
+    add(newStreams) {
+        if (this._ended) {
+            throw new Error('Tried to add a stream to a stopped StopperPool');
+        }
+        const arrStreams = Array.isArray(newStreams) ? newStreams : [newStreams];
+        this._streamCount += arrStreams.length;
+        this._pool.plug(Kefir.merge(arrStreams.map((newStream) => newStream.take(1))));
+    }
+    getSize() {
+        return this._streamCount;
+    }
+}

package/src/platform-implementation-js/lib/stream-wait-for.js

@@ -0,0 +1,30 @@
+import * as Kefir from 'kefir';
+/**
+ * Returns a Kefir stream that repeatedly calls the condition callback until it
+ * returns a truthy value, and then the stream emits that value and ends.
+ * If the timeout passes, an error event is emitted and the error is also
+ * thrown so that it gets logged. Well-behaving code should not let the timeout
+ * get tripped.
+ */
+export default function streamWaitFor(condition, timeout = 60 * 1000, steptime = 250) {
+    // make this error here so we have a sensible stack.
+    const timeoutError = new Error('waitFor timeout');
+    const timeoutStream = Kefir.later(timeout, null).flatMap(() => {
+        const result = condition();
+        if (result) {
+            return Kefir.constant(result);
+        }
+        setTimeout(() => {
+            throw timeoutError;
+        }, 0);
+        return Kefir.constantError(timeoutError);
+    });
+    const isTruthy = Boolean;
+    return Kefir.later(0, null)
+        .merge(Kefir.interval(steptime, null))
+        .map(() => condition())
+        .filter(isTruthy)
+        .merge(timeoutStream)
+        .take(1)
+        .takeErrors(1);
+}

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

@@ -1,18 +1,19 @@
-/* @flow */
+"use strict";
 
-import type LiveSet from 'live-set';
-import toValueObservable from 'live-set/toValueObservable';
-import Kefir from 'kefir';
-import type { ItemWithLifetime } from './dom/make-element-child-stream';
-
-export default function toItemWithLifetimeStream<T>(
-  liveSet: LiveSet<T>
-): Kefir.Observable<ItemWithLifetime<T>> {
-  return Kefir.fromESObservable(
-    toValueObservable(liveSet).map((event) => {
-      const removal: Promise<void> = event.removal;
-      const removalStream = Kefir.fromPromise(removal);
-      return { el: event.value, removalStream };
-    })
-  );
-}
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toItemWithLifetimeStream;
+var _toValueObservable = _interopRequireDefault(require("live-set/toValueObservable"));
+var _kefir = _interopRequireDefault(require("kefir"));
+function toItemWithLifetimeStream(liveSet) {
+  return _kefir.default.fromESObservable((0, _toValueObservable.default)(liveSet).map(event => {
+    const removal = event.removal;
+    const removalStream = _kefir.default.fromPromise(removal);
+    return {
+      el: event.value,
+      removalStream
+    };
+  }));
+}

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

@@ -1,31 +1,33 @@
-/* @flow */
+"use strict";
 
-import LiveSet from 'live-set';
-import type Kefir from 'kefir';
-import type { ItemWithLifetime } from './dom/make-element-child-stream';
-
-export default function toLiveSet<T>(
-  itemWithLifetimeStream: Kefir.Observable<ItemWithLifetime<T>>
-): LiveSet<T> {
-  return new LiveSet({
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toLiveSet;
+var _liveSet = _interopRequireDefault(require("live-set"));
+function toLiveSet(itemWithLifetimeStream) {
+  return new _liveSet.default({
     read() {
       throw new Error('should not happen; liveset was inactive');
     },
     listen(setValues, controller) {
       setValues(new Set());
-
       const sub = itemWithLifetimeStream.observe({
-        value({ el, removalStream }) {
+        value(_ref) {
+          let {
+            el,
+            removalStream
+          } = _ref;
           controller.add(el);
           removalStream.take(1).onValue(() => {
             controller.remove(el);
           });
-        },
+        }
       });
-
       return () => {
         sub.unsubscribe();
       };
-    },
+    }
   });
-}
+}

package/src/platform-implementation-js/lib/wait-for.js

@@ -0,0 +1,28 @@
+export default function waitFor(condition, timeout = 120 * 1000, steptime = 250) {
+    // make this error here so we have a sensible stack.
+    const timeoutError = new Error('waitFor timeout');
+    return new Promise(function (resolve, reject) {
+        let waited = 0;
+        function step() {
+            try {
+                const result = condition();
+                if (result) {
+                    resolve(result);
+                }
+                else {
+                    if (waited >= timeout) {
+                        reject(timeoutError);
+                    }
+                    else {
+                        waited += steptime;
+                        setTimeout(step, steptime);
+                    }
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        }
+        setTimeout(step, 1);
+    });
+}