agora-foundation 1.0.0

package/lib/upload/index.d.ts

@@ -0,0 +1,2 @@
+export type { AgoraUploadHandler, AgoraUploadObserver, AgoraUploadTask } from './type';
+export { AgoraUploadScheduler } from './scheduler';

package/lib/upload/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AgoraUploadScheduler", {
+  enumerable: true,
+  get: function get() {
+    return _scheduler.AgoraUploadScheduler;
+  }
+});
+var _scheduler = require("./scheduler");

package/lib/upload/scheduler.d.ts

@@ -0,0 +1,15 @@
+import { AgoraUploadTask, AgoraUploadHandler, AgoraUploadObserver } from "./type";
+export declare class AgoraUploadScheduler<T extends AgoraUploadTask> {
+    private _uploadHandler;
+    private _eventEmitter;
+    private _taskQueue;
+    private _isProcessing;
+    private _retryDelay;
+    constructor(_uploadHandler: AgoraUploadHandler<T>);
+    setRetryDelay(delay: number): void;
+    addUploadTask(task: T): void;
+    prependUploadTask(task: T): void;
+    addObserver(observer: AgoraUploadObserver): void;
+    removeObserver(observer: AgoraUploadObserver): void;
+    private _notifyQueueChanged;
+}

package/lib/upload/scheduler.js

@@ -0,0 +1,114 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AgoraUploadScheduler = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/es.array.unshift.js");
+require("core-js/modules/es.function.bind.js");
+require("core-js/modules/web.timers.js");
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _events = require("../utilities/events");
+var AgoraUploadScheduler = exports.AgoraUploadScheduler = /*#__PURE__*/function () {
+  function AgoraUploadScheduler(_uploadHandler) {
+    (0, _classCallCheck2["default"])(this, AgoraUploadScheduler);
+    (0, _defineProperty2["default"])(this, "_eventEmitter", new _events.AgoraEventEmitter());
+    (0, _defineProperty2["default"])(this, "_taskQueue", []);
+    (0, _defineProperty2["default"])(this, "_isProcessing", false);
+    (0, _defineProperty2["default"])(this, "_retryDelay", 1000);
+    this._uploadHandler = _uploadHandler;
+    this._notifyQueueChanged = this._notifyQueueChanged.bind(this);
+  }
+  return (0, _createClass2["default"])(AgoraUploadScheduler, [{
+    key: "setRetryDelay",
+    value: function setRetryDelay(delay) {
+      this._retryDelay = delay;
+    }
+  }, {
+    key: "addUploadTask",
+    value: function addUploadTask(task) {
+      this._taskQueue.push(task);
+      this._notifyQueueChanged();
+    }
+  }, {
+    key: "prependUploadTask",
+    value: function prependUploadTask(task) {
+      this._taskQueue.unshift(task);
+      this._notifyQueueChanged();
+    }
+  }, {
+    key: "addObserver",
+    value: function addObserver(observer) {
+      if (observer.onUploadFailure) {
+        this._eventEmitter.on("upload-failure", observer.onUploadFailure);
+      }
+      if (observer.onUploadSuccess) {
+        this._eventEmitter.on("upload-success", observer.onUploadSuccess);
+      }
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      if (observer.onUploadFailure) {
+        this._eventEmitter.off("upload-failure", observer.onUploadFailure);
+      }
+      if (observer.onUploadSuccess) {
+        this._eventEmitter.off("upload-success", observer.onUploadSuccess);
+      }
+    }
+  }, {
+    key: "_notifyQueueChanged",
+    value: function () {
+      var _notifyQueueChanged2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var task;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!this._isProcessing) {
+                _context.next = 2;
+                break;
+              }
+              return _context.abrupt("return");
+            case 2:
+              if (!(this._taskQueue.length !== 0 && (task = this._taskQueue.shift()))) {
+                _context.next = 18;
+                break;
+              }
+              _context.prev = 3;
+              this._isProcessing = true;
+              _context.next = 7;
+              return this._uploadHandler.handleUpload(task);
+            case 7:
+              this._eventEmitter.emit("upload-success", task);
+              _context.next = 14;
+              break;
+            case 10:
+              _context.prev = 10;
+              _context.t0 = _context["catch"](3);
+              this._eventEmitter.emit("upload-failure", _context.t0, task);
+              this._taskQueue.unshift(task);
+            case 14:
+              _context.prev = 14;
+              this._isProcessing = false;
+              setTimeout(this._notifyQueueChanged, this._retryDelay);
+              return _context.finish(14);
+            case 18:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[3, 10, 14, 18]]);
+      }));
+      function _notifyQueueChanged() {
+        return _notifyQueueChanged2.apply(this, arguments);
+      }
+      return _notifyQueueChanged;
+    }()
+  }]);
+}();

package/lib/upload/type.d.ts

@@ -0,0 +1,11 @@
+export type AgoraUploadTask = {
+    id: number;
+    file: File;
+};
+export interface AgoraUploadObserver {
+    onUploadFailure?(error: Error, task: AgoraUploadTask): void;
+    onUploadSuccess?(task: AgoraUploadTask): void;
+}
+export interface AgoraUploadHandler<T extends AgoraUploadTask> {
+    handleUpload(task: T): Promise<void>;
+}

package/lib/upload/type.js

@@ -0,0 +1,6 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/utilities/async-retry.d.ts

@@ -0,0 +1,63 @@
+type RetryOptions = {
+    retriesMax?: number;
+    interval?: number;
+    exponential?: boolean;
+    maxBackoff?: number;
+    factor?: number;
+    jitter?: number;
+    isCb?: boolean;
+};
+type RetryAttemptArgs = {
+    error: Error;
+    currentRetry: number;
+    retriesMax: number;
+    interval: number;
+    exponential: number;
+    factor: number;
+    jitter: number;
+    maxBackoff: number;
+};
+type AnyFunction = (...args: any[]) => unknown;
+type AbortCallback = (e: Error) => Promise<void> | void;
+type AttemptFailCallback = (args: RetryAttemptArgs & {
+    timeFn: () => Promise<void>;
+}) => Promise<boolean> | boolean;
+declare class Retry {
+    private fn;
+    private args;
+    private onRetryAttemptFail?;
+    private onRetryAbort?;
+    private opts?;
+    /**
+     * @param fn target function
+     * @param args arguments the target function to be called with
+     * @param opts options
+     */
+    constructor(fn: AnyFunction, args: unknown[], opts?: RetryOptions);
+    /**
+     *
+     * Registers a callback to be called when the target function fails
+     * This callback function can be used to manage, by yourself, the retry system. It's called when an error occurred and before to retry. This method can have three behaviors:
+     * you can throw an error
+     * if it returns truthy value then normal retry system continues
+     * if it returns falsy value then the retry system stop
+     *
+     * @param fn callback function to be called
+     * @returns
+     */
+    fail(fn: AttemptFailCallback): this;
+    /**
+     * Registers a callback to be called when the target function and all retries fail
+     *
+     * @param fn callback function to be called
+     * @returns
+     */
+    abort(fn: AbortCallback): this;
+    /**
+     * Starts executes the target function
+     * retriesMax would be 3 and maxBackoff would be 10000(10 sceonds) by default
+     */
+    exec(): Promise<void>;
+}
+export declare const retryAttempt: (fn: AnyFunction, args: unknown[], opts?: RetryOptions) => Retry;
+export {};

package/lib/utilities/async-retry.js

@@ -0,0 +1,180 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/es.object.define-properties.js");
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.retryAttempt = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/web.timers.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _asyncAwaitRetry = _interopRequireDefault(require("async-await-retry"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var Retry = /*#__PURE__*/function () {
+  /**
+   * @param fn target function
+   * @param args arguments the target function to be called with
+   * @param opts options
+   */
+  function Retry(fn, args, opts) {
+    (0, _classCallCheck2["default"])(this, Retry);
+    this.fn = fn;
+    this.args = args;
+    this.opts = opts;
+  }
+
+  /**
+   *
+   * Registers a callback to be called when the target function fails
+   * This callback function can be used to manage, by yourself, the retry system. It's called when an error occurred and before to retry. This method can have three behaviors:
+   * you can throw an error
+   * if it returns truthy value then normal retry system continues
+   * if it returns falsy value then the retry system stop
+   *
+   * @param fn callback function to be called
+   * @returns
+   */
+  return (0, _createClass2["default"])(Retry, [{
+    key: "fail",
+    value: function fail(fn) {
+      this.onRetryAttemptFail = fn;
+      return this;
+    }
+
+    /**
+     * Registers a callback to be called when the target function and all retries fail
+     *
+     * @param fn callback function to be called
+     * @returns
+     */
+  }, {
+    key: "abort",
+    value: function abort(fn) {
+      this.onRetryAbort = fn;
+      return this;
+    }
+
+    /**
+     * Starts executes the target function
+     * retriesMax would be 3 and maxBackoff would be 10000(10 sceonds) by default
+     */
+  }, {
+    key: "exec",
+    value: (function () {
+      var _exec = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var _this = this;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return (0, _asyncAwaitRetry["default"])(this.fn, this.args, _objectSpread(_objectSpread({
+                retriesMax: 3,
+                maxBackoff: 10000,
+                interval: 1000
+              }, this.opts), {}, {
+                onAttemptFail: function () {
+                  var _onAttemptFail = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(data) {
+                    var timeFn;
+                    return _regenerator["default"].wrap(function _callee2$(_context2) {
+                      while (1) switch (_context2.prev = _context2.next) {
+                        case 0:
+                          timeFn = /*#__PURE__*/function () {
+                            var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+                              var interval;
+                              return _regenerator["default"].wrap(function _callee$(_context) {
+                                while (1) switch (_context.prev = _context.next) {
+                                  case 0:
+                                    interval = data.exponential ? Math.min(Math.pow(data.factor, data.currentRetry) * data.interval, data.maxBackoff) : data.interval; // if interval is set to zero, do not use setTimeout, gain 1 event loop tick
+                                    if (!interval) {
+                                      _context.next = 4;
+                                      break;
+                                    }
+                                    _context.next = 4;
+                                    return new Promise(function (r) {
+                                      return setTimeout(r, interval + data.jitter);
+                                    });
+                                  case 4:
+                                  case "end":
+                                    return _context.stop();
+                                }
+                              }, _callee);
+                            }));
+                            return function timeFn() {
+                              return _ref.apply(this, arguments);
+                            };
+                          }();
+                          _context2.t0 = _this.onRetryAttemptFail;
+                          if (!_context2.t0) {
+                            _context2.next = 6;
+                            break;
+                          }
+                          _context2.next = 5;
+                          return _this.onRetryAttemptFail(_objectSpread(_objectSpread({}, data), {}, {
+                            // fix issue of currentRetry starting from 0
+                            currentRetry: data.currentRetry + 1,
+                            timeFn: timeFn
+                          }));
+                        case 5:
+                          _context2.t0 = _context2.sent;
+                        case 6:
+                          return _context2.abrupt("return", _context2.t0);
+                        case 7:
+                        case "end":
+                          return _context2.stop();
+                      }
+                    }, _callee2);
+                  }));
+                  function onAttemptFail(_x) {
+                    return _onAttemptFail.apply(this, arguments);
+                  }
+                  return onAttemptFail;
+                }()
+              }));
+            case 3:
+              _context3.next = 12;
+              break;
+            case 5:
+              _context3.prev = 5;
+              _context3.t0 = _context3["catch"](0);
+              _context3.t1 = this.onRetryAbort;
+              if (!_context3.t1) {
+                _context3.next = 11;
+                break;
+              }
+              _context3.next = 11;
+              return this.onRetryAbort(_context3.t0);
+            case 11:
+              throw _context3.t0;
+            case 12:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[0, 5]]);
+      }));
+      function exec() {
+        return _exec.apply(this, arguments);
+      }
+      return exec;
+    }())
+  }]);
+}();
+var retryAttempt = exports.retryAttempt = function retryAttempt(fn, args, opts) {
+  return new Retry(fn, args, opts);
+};

package/lib/utilities/env.d.ts

@@ -0,0 +1,12 @@
+export declare const isElectron: () => boolean;
+export declare enum FcrApplicationPlatform {
+    DESKTOP_WEB = 0,
+    MACOS = 1,
+    WINDOWS = 2,
+    IOS = 3,
+    ANDROID = 4,
+    MOBILE_WEB = 5,
+    SIP_H322 = 6,
+    PSTN = 7
+}
+export declare const getPlatform: () => FcrApplicationPlatform;

package/lib/utilities/env.js

@@ -0,0 +1,56 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isElectron = exports.getPlatform = exports.FcrApplicationPlatform = void 0;
+require("core-js/modules/es.array.find.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.string.includes.js");
+var isElectron = exports.isElectron = function isElectron() {
+  var userAgent = navigator.userAgent.toLowerCase();
+  if (userAgent.indexOf(" electron/") > -1) {
+    return true;
+  }
+  return false;
+};
+var FcrApplicationPlatform = exports.FcrApplicationPlatform = /*#__PURE__*/function (FcrApplicationPlatform) {
+  FcrApplicationPlatform[FcrApplicationPlatform["DESKTOP_WEB"] = 0] = "DESKTOP_WEB";
+  FcrApplicationPlatform[FcrApplicationPlatform["MACOS"] = 1] = "MACOS";
+  FcrApplicationPlatform[FcrApplicationPlatform["WINDOWS"] = 2] = "WINDOWS";
+  FcrApplicationPlatform[FcrApplicationPlatform["IOS"] = 3] = "IOS";
+  FcrApplicationPlatform[FcrApplicationPlatform["ANDROID"] = 4] = "ANDROID";
+  FcrApplicationPlatform[FcrApplicationPlatform["MOBILE_WEB"] = 5] = "MOBILE_WEB";
+  FcrApplicationPlatform[FcrApplicationPlatform["SIP_H322"] = 6] = "SIP_H322";
+  FcrApplicationPlatform[FcrApplicationPlatform["PSTN"] = 7] = "PSTN";
+  return FcrApplicationPlatform;
+}({});
+var getPlatform = exports.getPlatform = function getPlatform() {
+  var userAgent = navigator.userAgent.toLowerCase();
+  var platforms = [{
+    key: 'windows',
+    value: FcrApplicationPlatform.WINDOWS
+  }, {
+    key: 'mac',
+    value: FcrApplicationPlatform.MACOS
+  }, {
+    key: 'android',
+    value: FcrApplicationPlatform.MOBILE_WEB
+  }, {
+    key: 'iphone',
+    value: FcrApplicationPlatform.MOBILE_WEB
+  }, {
+    key: 'ipad',
+    value: FcrApplicationPlatform.MOBILE_WEB
+  }];
+  var platform = platforms.find(function (p) {
+    return userAgent.includes(p.key);
+  });
+  if (isElectron()) {
+    return platform ? platform.value : FcrApplicationPlatform.MACOS;
+  }
+  return platform ? platform.value : FcrApplicationPlatform.DESKTOP_WEB;
+};

package/lib/utilities/events.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 事件发射器
+ */
+/**@en
+ * Event emitter
+ */
+export declare class AgoraEventEmitter {
+    once(evt: string, cb: CallableFunction): this;
+    on(evt: string, cb: CallableFunction): this;
+    off(evt: string, cb: CallableFunction): this;
+    removeAllEventListeners(): void;
+    emit(evt: string, ...args: any[]): this;
+}

package/lib/utilities/events.js

@@ -0,0 +1,114 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.error.to-string.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.is-array.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.date.to-string.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.test.js");
+require("core-js/modules/es.regexp.to-string.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AgoraEventEmitter = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _logger = require("../logger");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /**
+ * 事件发射器
+ */
+/**@en
+ * Event emitter
+ */
+var AgoraEventEmitter = exports.AgoraEventEmitter = /*#__PURE__*/function () {
+  function AgoraEventEmitter() {
+    (0, _classCallCheck2["default"])(this, AgoraEventEmitter);
+    //@internal
+    (0, _defineProperty2["default"])(this, "_eventMap", new Map());
+  }
+  return (0, _createClass2["default"])(AgoraEventEmitter, [{
+    key: "once",
+    value: function once(evt, cb) {
+      var _this = this;
+      var wrapper = function wrapper() {
+        _this.off(evt, wrapper);
+        cb.apply(void 0, arguments);
+      };
+      this.on(evt, wrapper);
+      return this;
+    }
+  }, {
+    key: "on",
+    value: function on(evt, cb) {
+      var _this$_eventMap$get;
+      var cbs = (_this$_eventMap$get = this._eventMap.get(evt)) !== null && _this$_eventMap$get !== void 0 ? _this$_eventMap$get : [];
+      cbs.push(cb);
+      this._eventMap.set(evt, cbs);
+      return this;
+    }
+  }, {
+    key: "off",
+    value: function off(evt, cb) {
+      var cbs = this._eventMap.get(evt);
+      if (cbs) {
+        this._eventMap.set(evt, cbs.filter(function (it) {
+          return it !== cb;
+        }));
+      }
+      return this;
+    }
+  }, {
+    key: "removeAllEventListeners",
+    value: function removeAllEventListeners() {
+      this._eventMap.clear();
+    }
+  }, {
+    key: "emit",
+    value: function emit(evt) {
+      var _this$_eventMap$get2;
+      var cbs = (_this$_eventMap$get2 = this._eventMap.get(evt)) !== null && _this$_eventMap$get2 !== void 0 ? _this$_eventMap$get2 : [];
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      var _iterator = _createForOfIteratorHelper(cbs),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var cb = _step.value;
+          try {
+            cb && cb.apply(void 0, args);
+          } catch (e) {
+            //cb exception should not affect other callbacks
+            var error = e;
+            var details = error.stack || error.message;
+            (0, _logger.getLogger)().error("[event] handling event ".concat(evt, " fail: ").concat(details));
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return this;
+    }
+  }]);
+}();

package/lib/utilities/file-reader.d.ts

@@ -0,0 +1 @@
+export declare const readAsArrayBuffer: (blob: Blob) => Promise<ArrayBuffer | null | undefined>;

package/lib/utilities/file-reader.js

@@ -0,0 +1,22 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readAsArrayBuffer = void 0;
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+var readAsArrayBuffer = exports.readAsArrayBuffer = function readAsArrayBuffer(blob) {
+  return new Promise(function (resolve, reject) {
+    var reader = new FileReader();
+    reader.onload = function (event) {
+      var _event$target;
+      resolve((_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.result);
+    };
+    reader.onerror = function (event) {
+      reject(event);
+    };
+    reader.readAsArrayBuffer(blob);
+  });
+};

package/lib/utilities/interceptor.d.ts

@@ -0,0 +1,6 @@
+export type Interceptor<T = unknown> = (evt: T) => Result;
+export declare enum Result {
+    BREAK = 0,
+    CONTINUE = 1
+}
+export declare const chain: <T>(...interceptors: Interceptor<T>[]) => Interceptor<T>;

package/lib/utilities/interceptor.js

@@ -0,0 +1,28 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.chain = exports.Result = void 0;
+var Result = exports.Result = /*#__PURE__*/function (Result) {
+  Result[Result["BREAK"] = 0] = "BREAK";
+  Result[Result["CONTINUE"] = 1] = "CONTINUE";
+  return Result;
+}({}); // simple interceptor chain that allows you to make flow control with functional programming style
+var chain = exports.chain = function chain() {
+  for (var _len = arguments.length, interceptors = new Array(_len), _key = 0; _key < _len; _key++) {
+    interceptors[_key] = arguments[_key];
+  }
+  return function (evt) {
+    var r = Result.CONTINUE;
+    for (var i in interceptors) {
+      var interceptor = interceptors[i];
+      r = interceptor(evt);
+      if (r === Result.BREAK) {
+        break;
+      }
+    }
+    return r;
+  };
+};