@inboxsdk/core 0.2.28 → 0.2.29-alpha.0

package/src/platform-implementation-js/lib/make-revocable-function.js

@@ -1,40 +1,38 @@
-/* @flow */
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = makeRevocableFunction;
+var _once = _interopRequireDefault(require("lodash/once"));
+var _noop = _interopRequireDefault(require("lodash/noop"));
 // Takes an input function, and returns {fn, revoke}.
 // Before revoke is called, calling fn is equivalent to calling the input
 // function.
 // After revoke is called, calling fn is a no-op, and fn no longer holds a
 // reference to inputFn.
 // The revoke function does not hold a reference to inputFn or revokedFn ever.
-
 // The optional second parameter revokedFn is a function to make fn call after
 // it has been revoked.
-
-import once from 'lodash/once';
-import noop from 'lodash/noop';
-
-export default function makeRevocableFunction<F: Function>(
-  inputFn: F,
-  revokedFn: Function = noop
-): { fn: F, revoke: () => void } {
+function makeRevocableFunction(inputFn) {
+  let revokedFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _noop.default;
   let key = {};
-
   return {
-    fn: (function () {
+    fn: function () {
       if (!key) {
         throw new Error('Should not happen');
       }
       const _revokedFn = revokedFn;
       const wm = new WeakMap();
       wm.set(key, inputFn);
-      inputFn = revokedFn = (null: any);
-
-      return (function () {
-        return ((key ? wm.get(key) : _revokedFn): any).apply(this, arguments);
-      }: any);
-    })(),
-    revoke: once(function () {
+      inputFn = revokedFn = null;
+      return function () {
+        return (key ? wm.get(key) : _revokedFn).apply(this, arguments);
+      };
+    }(),
+    revoke: (0, _once.default)(function () {
       key = null;
-    }),
+    })
   };
-}
+}

package/src/platform-implementation-js/lib/make-revocable-function.test.js

@@ -1,63 +1,61 @@
-/* @flow */
-
-import makeRevocableFunction from './make-revocable-function';
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _makeRevocableFunction = _interopRequireDefault(require("./make-revocable-function"));
 it('works', () => {
   const adder = {
     value: 0,
-    add: (x, y = 0) => {
+    add: function (x) {
+      let y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       adder.value += x + y;
       return adder.value;
-    },
+    }
   };
-
-  const { fn, revoke } = makeRevocableFunction(adder.add);
+  const {
+    fn,
+    revoke
+  } = (0, _makeRevocableFunction.default)(adder.add);
   adder.add = fn;
-
   expect(adder.add(5)).toBe(5);
   expect(adder.add(2, 1)).toBe(8);
   expect(adder.add(3)).toBe(11);
   expect(adder.value).toBe(11);
-
   revoke();
-
   expect(adder.add(3)).toBe(undefined);
   expect(adder.value).toBe(11);
-
   revoke(); // should be no-op
 
   expect(adder.add(3)).toBe(undefined);
   expect(adder.value).toBe(11);
 });
-
 it('revokedFn parameter works', () => {
   const adder = {
     value: 0,
-    add: (x, y = 0) => {
+    add: function (x) {
+      let y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       adder.value += x + y;
       return adder.value;
     },
-    subtract: (x, y = 0) => {
+    subtract: function (x) {
+      let y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       adder.value -= x + y;
       return adder.value;
-    },
+    }
   };
-
-  const { fn, revoke } = makeRevocableFunction(adder.add, adder.subtract);
+  const {
+    fn,
+    revoke
+  } = (0, _makeRevocableFunction.default)(adder.add, adder.subtract);
   adder.add = fn;
-
   expect(adder.add(5)).toBe(5);
   expect(adder.add(2, 1)).toBe(8);
   expect(adder.add(3)).toBe(11);
   expect(adder.value).toBe(11);
-
   revoke();
-
   expect(adder.add(3)).toBe(8);
   expect(adder.value).toBe(8);
-
   revoke(); // should be no-op
 
   expect(adder.add(3)).toBe(5);
   expect(adder.value).toBe(5);
-});
+});

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

@@ -1,20 +1,18 @@
-/* @flow */
+"use strict";
 
-import zip from 'lodash/zip';
-
-export default function parseParamsFromRouteID(
-  routeID: string,
-  hash: string
-): { [ix: string]: string } {
-  const params: { [ix: string]: string } = (Object.create(null): any);
-  zip(routeID.split('/'), hash.split('/')).forEach(
-    ([routePart, hashPart], i) => {
-      if (routePart[0] === ':') {
-        params[routePart.slice(1)] = decodeURIComponent(
-          hashPart.replace(/\+/g, ' ')
-        );
-      }
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseParamsFromRouteID;
+var _zip = _interopRequireDefault(require("lodash/zip"));
+function parseParamsFromRouteID(routeID, hash) {
+  const params = Object.create(null);
+  (0, _zip.default)(routeID.split('/'), hash.split('/')).forEach((_ref, i) => {
+    let [routePart, hashPart] = _ref;
+    if (routePart[0] === ':') {
+      params[routePart.slice(1)] = decodeURIComponent(hashPart.replace(/\+/g, ' '));
     }
-  );
+  });
   return Object.freeze(params);
-}
+}

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

@@ -1,28 +1,19 @@
-/* @flow */
-
-import parseParamsFromRouteID from './parseParamsFromRouteID';
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _parseParamsFromRouteID = _interopRequireDefault(require("./parseParamsFromRouteID"));
 test('empty', () => {
-  expect(parseParamsFromRouteID('test', 'test')).toEqual({});
+  expect((0, _parseParamsFromRouteID.default)('test', 'test')).toEqual({});
 });
-
 test('works', () => {
-  expect(
-    parseParamsFromRouteID('test/:id/blah/:foo', 'test/123/blah/456')
-  ).toEqual({
+  expect((0, _parseParamsFromRouteID.default)('test/:id/blah/:foo', 'test/123/blah/456')).toEqual({
     id: '123',
-    foo: '456',
+    foo: '456'
   });
 });
-
 test('decodes URI component', () => {
-  expect(
-    parseParamsFromRouteID(
-      'test/:id/blah/:foo',
-      "test/123/blah/test+%3C%3E%2B%22'%26%20_"
-    )
-  ).toEqual({
+  expect((0, _parseParamsFromRouteID.default)('test/:id/blah/:foo', "test/123/blah/test+%3C%3E%2B%22'%26%20_")).toEqual({
     id: '123',
-    foo: 'test <>+"\'& _',
+    foo: 'test <>+"\'& _'
   });
-});
+});

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

@@ -11,3 +11,4 @@ export default class PersistentQueue<T> {
     peekAll(): T[];
     clear(): void;
 }
+//# sourceMappingURL=persistent-queue.d.ts.map

package/src/platform-implementation-js/lib/persistent-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistent-queue.d.ts","sourceRoot":"","sources":["../../../../../src/platform-implementation-js/lib/persistent-queue.ts"],"names":[],"mappings":"AAKA,MAAM,CAAC,OAAO,OAAO,eAAe,CAAC,CAAC;IACpC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,IAAI,CAAS;gBAEF,EAAE,EAAE,MAAM;IAI7B,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,gBAAgB;IAIjB,GAAG,CAAC,GAAG,EAAE,CAAC;IAiBV,MAAM,IAAI,CAAC,GAAG,SAAS;IAoBvB,SAAS,IAAI,CAAC,EAAE;IAmBhB,OAAO,IAAI,CAAC,EAAE;IAgBd,KAAK;CAUb"}

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.d.ts

@@ -3,3 +3,4 @@ import EventEmitter from 'events';
 export default class SafeEventEmitter extends EventEmitter {
     emit(event: string, ...args: Array<any>): boolean;
 }
+//# sourceMappingURL=safe-event-emitter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"safe-event-emitter.d.ts","sourceRoot":"","sources":["../../../../../src/platform-implementation-js/lib/safe-event-emitter.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAQlC,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,YAAY;IACjD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,OAAO;CAQzD"}

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;
+        }
+    }
+}