@inboxsdk/core 0.2.28-alpha.6 → 0.2.28

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

@@ -1,61 +1,63 @@
-"use strict";
+/* @flow */
+
+import makeRevocableFunction from './make-revocable-function';
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _makeRevocableFunction = _interopRequireDefault(require("./make-revocable-function"));
 it('works', () => {
   const adder = {
     value: 0,
-    add: function (x) {
-      let y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    add: (x, y = 0) => {
       adder.value += x + y;
       return adder.value;
-    }
+    },
   };
-  const {
-    fn,
-    revoke
-  } = (0, _makeRevocableFunction.default)(adder.add);
+
+  const { fn, revoke } = makeRevocableFunction(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: function (x) {
-      let y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    add: (x, y = 0) => {
       adder.value += x + y;
       return adder.value;
     },
-    subtract: function (x) {
-      let y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    subtract: (x, y = 0) => {
       adder.value -= x + y;
       return adder.value;
-    }
+    },
   };
-  const {
-    fn,
-    revoke
-  } = (0, _makeRevocableFunction.default)(adder.add, adder.subtract);
+
+  const { fn, revoke } = makeRevocableFunction(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,18 +1,20 @@
-"use strict";
+/* @flow */
 
-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, ' '));
+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, ' ')
+        );
+      }
     }
-  });
+  );
   return Object.freeze(params);
-}
+}

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

@@ -1,19 +1,28 @@
-"use strict";
+/* @flow */
+
+import parseParamsFromRouteID from './parseParamsFromRouteID';
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _parseParamsFromRouteID = _interopRequireDefault(require("./parseParamsFromRouteID"));
 test('empty', () => {
-  expect((0, _parseParamsFromRouteID.default)('test', 'test')).toEqual({});
+  expect(parseParamsFromRouteID('test', 'test')).toEqual({});
 });
+
 test('works', () => {
-  expect((0, _parseParamsFromRouteID.default)('test/:id/blah/:foo', 'test/123/blah/456')).toEqual({
+  expect(
+    parseParamsFromRouteID('test/:id/blah/:foo', 'test/123/blah/456')
+  ).toEqual({
     id: '123',
-    foo: '456'
+    foo: '456',
   });
 });
+
 test('decodes URI component', () => {
-  expect((0, _parseParamsFromRouteID.default)('test/:id/blah/:foo', "test/123/blah/test+%3C%3E%2B%22'%26%20_")).toEqual({
+  expect(
+    parseParamsFromRouteID(
+      '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,4 +11,3 @@ export default class PersistentQueue<T> {
     peekAll(): T[];
     clear(): void;
 }
-//# sourceMappingURL=persistent-queue.d.ts.map

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

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

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

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

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

@@ -1,23 +1,21 @@
-"use strict";
+/* @flow */
 
-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;
-    });
-  }
+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;
+  };
   componentDidMount() {
     this._content.appendChild(this.props.el);
   }
-  componentDidUpdate(prevProps) {
+  componentDidUpdate(prevProps: Props) {
     if (prevProps.el !== this.props.el) {
       while (this._content.lastElementChild) {
         this._content.lastElementChild.remove();
@@ -25,14 +23,13 @@ class ElementContainer extends _react.default.Component {
       this._content.appendChild(this.props.el);
     }
   }
-  shouldComponentUpdate(nextProps) {
-    return this.props.className !== nextProps.className || this.props.el !== nextProps.el;
+  shouldComponentUpdate(nextProps: Props) {
+    return (
+      this.props.className !== nextProps.className ||
+      this.props.el !== nextProps.el
+    );
   }
   render() {
-    return /*#__PURE__*/_react.default.createElement("div", {
-      className: this.props.className,
-      ref: this._contentRefCb
-    });
+    return <div className={this.props.className} ref={this._contentRefCb} />;
   }
 }
-exports.default = ElementContainer;

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

@@ -1,11 +1,10 @@
-"use strict";
+/* @flow */
 
-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)}`);
-}
+import idMap from './idMap';
+
+export default function rewriteCssWithIdMap(cssSource: string): string {
+  return cssSource.replace(
+    /\.IDMAP_([-a-zA-Z0-9_]+)/g,
+    (match, classname) => `.${idMap(classname)}`
+  );
+}

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

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

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

@@ -1,15 +1,20 @@
-"use strict";
+/* @flow */
 
-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) {
+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 {
   const routeIDs = Array.isArray(routeID) ? routeID : [routeID];
-  return (0, _find.default)(routeIDs, routeID => hash.match(routeIDtoRegExp(routeID)));
-}
+  return find(routeIDs, (routeID) => hash.match(routeIDtoRegExp(routeID)));
+}

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

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

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

@@ -3,4 +3,3 @@ 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/shared-style.js

@@ -1,23 +1,22 @@
-"use strict";
+/* @flow */
 
-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"));
+import type Kefir from 'kefir';
+import udKefir from 'ud-kefir';
+import rewriteCssWithIdMap from './rewriteCssWithIdMap';
 var fs = require('fs');
-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;
+var cssContent: Kefir.Observable<string> = udKefir(
+  module,
+  fs.readFileSync(__dirname + '/../style/shared.css', 'utf8')
+);
+
+export default function sharedStyle(root: Document = document) {
   if (!root.getElementById('inboxsdk__shared_style')) {
     const style = root.createElement('style');
     style.id = 'inboxsdk__shared_style';
-    cssContent.onValue(css => {
-      style.textContent = (0, _rewriteCssWithIdMap.default)(css);
+    cssContent.onValue((css) => {
+      style.textContent = rewriteCssWithIdMap(css);
     });
     if (!root.head) throw new Error('missing head');
     root.head.appendChild(style);
   }
-}
+}

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

@@ -8,4 +8,3 @@ export default class StopperPool<V, E> {
     add(newStreams: Kefir.Observable<V, E> | Kefir.Observable<V, E>[]): void;
     getSize(): number;
 }
-//# sourceMappingURL=stopper-pool.d.ts.map

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

@@ -7,4 +7,3 @@ import * as Kefir from 'kefir';
  * get tripped.
  */
 export default function streamWaitFor<T>(condition: () => T | null | undefined, timeout?: number, steptime?: number): Kefir.Observable<T, Error>;
-//# sourceMappingURL=stream-wait-for.d.ts.map

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

@@ -1,19 +1,18 @@
-"use strict";
+/* @flow */
 
-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
-    };
-  }));
-}
+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 };
+    })
+  );
+}

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

@@ -1,33 +1,31 @@
-"use strict";
+/* @flow */
 
-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({
+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({
     read() {
       throw new Error('should not happen; liveset was inactive');
     },
     listen(setValues, controller) {
       setValues(new Set());
+
       const sub = itemWithLifetimeStream.observe({
-        value(_ref) {
-          let {
-            el,
-            removalStream
-          } = _ref;
+        value({ el, removalStream }) {
           controller.add(el);
           removalStream.take(1).onValue(() => {
             controller.remove(el);
           });
-        }
+        },
       });
+
       return () => {
         sub.unsubscribe();
       };
-    }
+    },
   });
-}
+}

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

@@ -1,2 +1 @@
-export default function waitFor<T>(condition: () => T | null | undefined, timeout?: number, steptime?: number): Promise<NonNullable<T>>;
-//# sourceMappingURL=wait-for.d.ts.map
+export default function waitFor<T>(condition: () => T | null | undefined, timeout?: number, steptime?: number): Promise<T>;

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

@@ -1,2 +1 @@
 export default function waitForAsync<T>(condition: () => Promise<T | null | undefined>, timeout?: number, steptime?: number): Promise<T>;
-//# sourceMappingURL=waitForAsync.d.ts.map

package/src/platform-implementation-js/main-INTEGRATED-PAGEWORLD.js

@@ -1,9 +1,8 @@
-"use strict";
-
 /* eslint-disable flowtype/require-valid-file-annotation, no-undef */
 
-const {
+const { injectScriptEmbedded } = require('./lib/inject-script-EMBEDDED');
+require('./lib/inject-script').setInjectScriptImplementation(
   injectScriptEmbedded
-} = require('./lib/inject-script-EMBEDDED');
-require('./lib/inject-script').setInjectScriptImplementation(injectScriptEmbedded);
-module.exports = require('./main');
+);
+
+module.exports = require('./main');