agora-foundation 3.8.1 → 3.9.0-alpha

package/lib-es/schedule/task.js

@@ -0,0 +1,159 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.error.cause.js";
+import "core-js/modules/es.error.to-string.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/web.timers.js";
+export var ActionWhenTaskFail = /*#__PURE__*/function (ActionWhenTaskFail) {
+  ActionWhenTaskFail[ActionWhenTaskFail["CONTINUE"] = 0] = "CONTINUE";
+  ActionWhenTaskFail[ActionWhenTaskFail["EXIT"] = 1] = "EXIT";
+  return ActionWhenTaskFail;
+}({});
+var promisify = function promisify(runnable) {
+  return new Promise(/*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(resolve, reject) {
+      var v, _t;
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            _context.next = 1;
+            return runnable();
+          case 1:
+            v = _context.sent;
+            resolve(v);
+            _context.next = 3;
+            break;
+          case 2:
+            _context.prev = 2;
+            _t = _context["catch"](0);
+            reject(_t);
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[0, 2]]);
+    }));
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+};
+export var PollingTask = /*#__PURE__*/function () {
+  function PollingTask(__arguments) {
+    _classCallCheck(this, PollingTask);
+    _defineProperty(this, "__running", false);
+    this.__arguments = __arguments;
+  }
+  return _createClass(PollingTask, [{
+    key: "start",
+    value: function start() {
+      var _this = this;
+      if (this.__running) {
+        throw new Error('Task is already running');
+      }
+      this.__running = true;
+      if (this.__arguments.immediate) {
+        promisify(this.__arguments.runnable).then(function () {
+          _this.poll();
+        });
+      } else {
+        this.poll();
+      }
+    }
+  }, {
+    key: "poll",
+    value: function poll() {
+      var _this2 = this;
+      if (!this.__running) {
+        return this.stop();
+      }
+      this.__timer = setTimeout(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        return _regeneratorRuntime.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 1;
+              return promisify(_this2.__arguments.runnable)["catch"](function (err) {
+                var action = _this2.__arguments.onFail(err);
+                if (action === ActionWhenTaskFail.EXIT) {
+                  _this2.__running = false;
+                }
+              });
+            case 1:
+              !_this2.__arguments.once && _this2.poll();
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      })), this.__arguments.interval);
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      clearTimeout(this.__timer);
+      this.__running = false;
+    }
+  }, {
+    key: "isStopped",
+    get: function get() {
+      return !this.__running;
+    }
+  }]);
+}();
+export var IntervalTask = /*#__PURE__*/function () {
+  function IntervalTask(__arguments) {
+    _classCallCheck(this, IntervalTask);
+    _defineProperty(this, "__running", false);
+    this.__arguments = __arguments;
+  }
+  return _createClass(IntervalTask, [{
+    key: "start",
+    value: function start() {
+      var _this3 = this;
+      if (this.__running) {
+        throw new Error('Task is already running');
+      }
+      this.__running = true;
+      var _this$__arguments = this.__arguments,
+        immediate = _this$__arguments.immediate,
+        interval = _this$__arguments.interval;
+      if (immediate) {
+        this.poll();
+      }
+      this.__timer = setInterval(function () {
+        _this3.poll();
+      }, interval);
+    }
+  }, {
+    key: "poll",
+    value: function poll() {
+      var _this4 = this;
+      if (!this.__running) {
+        return this.stop();
+      }
+      var runnable = this.__arguments.runnable;
+      promisify(runnable)["catch"](function (err) {
+        var action = _this4.__arguments.onFail(err);
+        if (action === ActionWhenTaskFail.EXIT) {
+          _this4.__running = false;
+        }
+      });
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      clearInterval(this.__timer);
+      this.__running = false;
+    }
+  }, {
+    key: "isStopped",
+    get: function get() {
+      return !this.__running;
+    }
+  }]);
+}();

package/lib-es/upload/index.js

@@ -0,0 +1 @@
+export { AgoraUploadScheduler } from './scheduler';

package/lib-es/upload/scheduler.js

@@ -0,0 +1,145 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.array.unshift.js";
+import "core-js/modules/es.function.bind.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/esnext.map.delete-all.js";
+import "core-js/modules/esnext.map.emplace.js";
+import "core-js/modules/esnext.map.every.js";
+import "core-js/modules/esnext.map.filter.js";
+import "core-js/modules/esnext.map.find.js";
+import "core-js/modules/esnext.map.find-key.js";
+import "core-js/modules/esnext.map.includes.js";
+import "core-js/modules/esnext.map.key-of.js";
+import "core-js/modules/esnext.map.map-keys.js";
+import "core-js/modules/esnext.map.map-values.js";
+import "core-js/modules/esnext.map.merge.js";
+import "core-js/modules/esnext.map.reduce.js";
+import "core-js/modules/esnext.map.some.js";
+import "core-js/modules/esnext.map.update.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/web.timers.js";
+import { AgoraEventEmitter } from '../utilities/events';
+export var AgoraUploadScheduler = /*#__PURE__*/function () {
+  function AgoraUploadScheduler(_uploadHandler) {
+    _classCallCheck(this, AgoraUploadScheduler);
+    _defineProperty(this, "_maxRetries", 2);
+    _defineProperty(this, "_taskRetries", new Map());
+    _defineProperty(this, "_eventEmitter", new AgoraEventEmitter());
+    _defineProperty(this, "_taskQueue", []);
+    _defineProperty(this, "_isProcessing", false);
+    _defineProperty(this, "_retryDelay", 1000);
+    _defineProperty(this, "_stopped", false);
+    this._uploadHandler = _uploadHandler;
+    this._notifyQueueChanged = this._notifyQueueChanged.bind(this);
+  }
+  return _createClass(AgoraUploadScheduler, [{
+    key: "release",
+    value: function release() {
+      this._stopped = true;
+      this._taskQueue = [];
+    }
+  }, {
+    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 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var task, retries, _t;
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!this._stopped) {
+                _context.next = 1;
+                break;
+              }
+              return _context.abrupt("return");
+            case 1:
+              if (!this._isProcessing) {
+                _context.next = 2;
+                break;
+              }
+              return _context.abrupt("return");
+            case 2:
+              if (!(this._taskQueue.length !== 0 && (task = this._taskQueue.shift()))) {
+                _context.next = 7;
+                break;
+              }
+              _context.prev = 3;
+              this._isProcessing = true;
+              _context.next = 4;
+              return this._uploadHandler.handleUpload(task);
+            case 4:
+              this._eventEmitter.emit('upload-success', task);
+              _context.next = 6;
+              break;
+            case 5:
+              _context.prev = 5;
+              _t = _context["catch"](3);
+              retries = this._taskRetries.get(task) || 0;
+              if (retries < this._maxRetries) {
+                this._taskRetries.set(task, retries + 1);
+                this._taskQueue.unshift(task);
+              } else {
+                this._eventEmitter.emit('upload-failure', _t, task);
+              }
+            case 6:
+              _context.prev = 6;
+              this._isProcessing = false;
+              setTimeout(this._notifyQueueChanged, this._retryDelay);
+              return _context.finish(6);
+            case 7:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[3, 5, 6, 7]]);
+      }));
+      function _notifyQueueChanged() {
+        return _notifyQueueChanged2.apply(this, arguments);
+      }
+      return _notifyQueueChanged;
+    }()
+  }]);
+}();

package/lib-es/upload/type.js

@@ -0,0 +1 @@
+export {};

package/lib-es/utilities/async-retry.js

@@ -0,0 +1,177 @@
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.object.define-properties.js";
+import "core-js/modules/es.object.define-property.js";
+import "core-js/modules/es.object.get-own-property-descriptor.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/web.timers.js";
+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) { _defineProperty(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; }
+import { default as externalRetry } from "async-await-retry";
+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) {
+    _classCallCheck(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 _createClass(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 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        var _this = this;
+        var _t2, _t3;
+        return _regeneratorRuntime.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 1;
+              return externalRetry(this.fn, this.args, _objectSpread(_objectSpread({
+                retriesMax: 3,
+                maxBackoff: 10000,
+                interval: 1000
+              }, this.opts), {}, {
+                onAttemptFail: function () {
+                  var _onAttemptFail = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(data) {
+                    var timeFn, _t;
+                    return _regeneratorRuntime.wrap(function (_context2) {
+                      while (1) switch (_context2.prev = _context2.next) {
+                        case 0:
+                          timeFn = /*#__PURE__*/function () {
+                            var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+                              var interval;
+                              return _regeneratorRuntime.wrap(function (_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 = 1;
+                                      break;
+                                    }
+                                    _context.next = 1;
+                                    return new Promise(function (r) {
+                                      return setTimeout(r, interval + data.jitter);
+                                    });
+                                  case 1:
+                                  case "end":
+                                    return _context.stop();
+                                }
+                              }, _callee);
+                            }));
+                            return function timeFn() {
+                              return _ref.apply(this, arguments);
+                            };
+                          }();
+                          _t = _this.onRetryAttemptFail;
+                          if (!_t) {
+                            _context2.next = 2;
+                            break;
+                          }
+                          _context2.next = 1;
+                          return _this.onRetryAttemptFail(_objectSpread(_objectSpread({}, data), {}, {
+                            // fix issue of currentRetry starting from 0
+                            currentRetry: data.currentRetry + 1,
+                            timeFn: timeFn
+                          }));
+                        case 1:
+                          _t = _context2.sent;
+                        case 2:
+                          return _context2.abrupt("return", _t);
+                        case 3:
+                        case "end":
+                          return _context2.stop();
+                      }
+                    }, _callee2);
+                  }));
+                  function onAttemptFail(_x) {
+                    return _onAttemptFail.apply(this, arguments);
+                  }
+                  return onAttemptFail;
+                }()
+              }));
+            case 1:
+              _context3.next = 4;
+              break;
+            case 2:
+              _context3.prev = 2;
+              _t2 = _context3["catch"](0);
+              _t3 = this.onRetryAbort;
+              if (!_t3) {
+                _context3.next = 3;
+                break;
+              }
+              _context3.next = 3;
+              return this.onRetryAbort(_t2);
+            case 3:
+              throw _t2;
+            case 4:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[0, 2]]);
+      }));
+      function exec() {
+        return _exec.apply(this, arguments);
+      }
+      return exec;
+    }())
+  }]);
+}();
+export var retryAttempt = function retryAttempt(fn, args, opts) {
+  return new Retry(fn, args, opts);
+};

package/lib-es/utilities/browser.js

@@ -0,0 +1,20 @@
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.match.js";
+export function checkBrowserDevice() {
+  var sUserAgent = navigator.userAgent.toLowerCase();
+  // const bIsIpad = sUserAgent.match(/ipad/i);
+  var bIsIphoneOs = sUserAgent.match(/iphone os/i);
+  var bIsMidp = sUserAgent.match(/midp/i);
+  var bIsUc7 = sUserAgent.match(/rv:1.2.3.4/i);
+  var bIsUc = sUserAgent.match(/ucweb/i);
+  var bIsAndroid = sUserAgent.match(/android/i);
+  var bIsCE = sUserAgent.match(/windows ce/i);
+  var bIsWM = sUserAgent.match(/windows mobile/i);
+  if (bIsIphoneOs || bIsMidp || bIsUc7 || bIsUc || bIsAndroid || bIsCE || bIsWM) {
+    return 'MobileWeb';
+  }
+  return 'DesktopWeb';
+}
+export function isMobileWebBrowser() {
+  return 'MobileWeb' === checkBrowserDevice();
+}

package/lib-es/utilities/desc-type.js

@@ -0,0 +1,3 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { FcrApplicationPlatform } from './env';
+export var FcrApplicationPlatformDescType = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, FcrApplicationPlatform.WEB_DESKTOP, 'webDesktop'), FcrApplicationPlatform.MACOS, 'macOS'), FcrApplicationPlatform.WINDOWS, 'windows'), FcrApplicationPlatform.WEB_MOBILE, 'webMobile'), FcrApplicationPlatform.HARMONY, 'harmony');

package/lib-es/utilities/env.js

@@ -0,0 +1,55 @@
+import "core-js/modules/es.array.find.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.array.index-of.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.string.match.js";
+import { isMobileWebBrowser } from './browser';
+export var isElectron = function isElectron() {
+  var userAgent = navigator.userAgent.toLowerCase();
+  if (userAgent.indexOf(' electron/') > -1) {
+    return true;
+  }
+  return false;
+};
+export var FcrApplicationPlatform = /*#__PURE__*/function (FcrApplicationPlatform) {
+  FcrApplicationPlatform[FcrApplicationPlatform["WEB_DESKTOP"] = 1] = "WEB_DESKTOP";
+  FcrApplicationPlatform[FcrApplicationPlatform["MACOS"] = 2] = "MACOS";
+  FcrApplicationPlatform[FcrApplicationPlatform["WINDOWS"] = 3] = "WINDOWS";
+  FcrApplicationPlatform[FcrApplicationPlatform["WEB_MOBILE"] = 6] = "WEB_MOBILE";
+  FcrApplicationPlatform[FcrApplicationPlatform["HARMONY"] = 7] = "HARMONY";
+  return FcrApplicationPlatform;
+}({});
+export var getPlatform = function getPlatform() {
+  var userAgent = navigator.userAgent.toLowerCase();
+  if (isElectron()) {
+    var platforms = [{
+      key: 'windows',
+      value: FcrApplicationPlatform.WINDOWS
+    }, {
+      key: 'mac',
+      value: FcrApplicationPlatform.MACOS
+    }];
+    var platform = platforms.find(function (p) {
+      return userAgent.includes(p.key);
+    });
+    return platform ? platform.value : FcrApplicationPlatform.MACOS;
+  } else {
+    return isMobileWebBrowser() ? FcrApplicationPlatform.WEB_MOBILE : FcrApplicationPlatform.WEB_DESKTOP;
+  }
+};
+export var isWindows = function isWindows() {
+  return getPlatform() === FcrApplicationPlatform.WINDOWS;
+};
+export var windowsVersion = function windowsVersion() {
+  if (!isWindows()) {
+    return null;
+  }
+  var userAgent = navigator.userAgent.toLowerCase();
+  var version = userAgent.match(/windows nt (\d+\.\d+)/);
+  return version ? version[1] : null; // return like 10.0
+};
+export var isMac = function isMac() {
+  return getPlatform() === FcrApplicationPlatform.MACOS;
+};