agora-foundation 3.8.1 → 3.9.0-alpha

package/lib-es/logger/hijack.js

@@ -0,0 +1,61 @@
+import "core-js/modules/es.symbol.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 _defineProperty from "@babel/runtime/helpers/defineProperty";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.index-of.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.object.to-string.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";
+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; }
+var methods = ['info', 'error', 'warn', 'debug'];
+export var originConsole = window.console;
+export var setupConsoleHijack = function setupConsoleHijack(logger) {
+  var console = _objectSpread({}, originConsole);
+  //@ts-ignore
+  if (console.__hijackSetup) {
+    console.log('[logger] hijack already setup!');
+    return;
+  }
+  console.log("[logger] setup hijack..");
+  function proxy(methodName) {
+    return function () {
+      switch (methodName) {
+        case 'debug':
+          logger.debug.apply(logger, arguments);
+          break;
+        case 'info':
+          logger.info.apply(logger, arguments);
+          break;
+        case 'warn':
+          logger.warn.apply(logger, arguments);
+          break;
+        case 'error':
+          logger.error.apply(logger, arguments);
+          break;
+      }
+    };
+  }
+  Object.keys(console).filter(function (e) {
+    return methods.indexOf(e) >= 0;
+  }).forEach(function (methodName) {
+    console[methodName] = proxy(methodName);
+  });
+  //@ts-ignore
+  console.__hijackSetup = true;
+  window.console = console;
+};
+export var restoreConsoleHijack = function restoreConsoleHijack() {
+  console.log("[logger] restore hijack..");
+  window.console = originConsole;
+  //@ts-ignore
+  console.__hijackSetup = false;
+};

package/lib-es/logger/index.js

@@ -0,0 +1,52 @@
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import isBoolean from 'lodash/isBoolean';
+import { getWorkerSingleton } from '../worker';
+import { loggerLabels, loggerRegistrar } from './common';
+import { LoggerImpl } from './logger-impl';
+import { LogManagerImpl } from './manager-impl';
+import { LogLevel } from './type';
+var logLevel = LogLevel.DEBUG;
+export var getLogger = function getLogger() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var label = opts.label || 'agora-default';
+  if (!loggerRegistrar.has(label)) {
+    loggerLabels.add(label);
+    loggerRegistrar.set(label, new LoggerImpl(label, {}, {
+      console: true,
+      database: true
+    }, logLevel, getWorkerSingleton()));
+  }
+  return loggerRegistrar.get(label);
+};
+export var createLogger = function createLogger() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var label = opts.label || 'agora-default';
+  var databaseValue = isBoolean(opts.database) ? opts.database : true;
+  var consoleValue = isBoolean(opts.console) ? opts.console : true;
+  var logger = new LoggerImpl(label, opts, {
+    console: consoleValue,
+    database: databaseValue
+  }, logLevel, getWorkerSingleton());
+  loggerLabels.add(label);
+  return logger;
+};
+var logManager;
+export var getLogManager = function getLogManager() {
+  if (!logManager) {
+    logManager = new LogManagerImpl(getWorkerSingleton());
+  }
+  return logManager;
+};
+export var setLogLevel = function setLogLevel(_logLevel) {
+  logLevel = _logLevel;
+  loggerRegistrar.forEach(function (logger) {
+    logger.setLogLevel(logLevel);
+  });
+};
+export { LogLevel } from './type';
+export { restoreConsoleHijack, setupConsoleHijack } from './hijack';
+export { logLevelMap } from './constants';

package/lib-es/logger/logger-impl.js

@@ -0,0 +1,122 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.join.js";
+import "core-js/modules/es.array.unshift.js";
+import upperCase from 'lodash/upperCase';
+import dayjs from 'dayjs';
+import { logLevelMap } from './constants';
+import { LogLevel } from './type';
+import { originConsole } from './hijack';
+import padEnd from 'lodash/padEnd';
+import { isElectron } from '../utilities/env';
+export var LoggerImpl = /*#__PURE__*/function () {
+  function LoggerImpl(_label, _opts, _dest, _logLevel, _logWorkerInteractor) {
+    _classCallCheck(this, LoggerImpl);
+    this._label = _label;
+    this._opts = _opts;
+    this._dest = _dest;
+    this._logLevel = _logLevel;
+    this._logWorkerInteractor = _logWorkerInteractor;
+    if (isElectron() && _dest.database) {
+      if (window.require) {
+        var path = window.require('path');
+        var _window$require = window.require('@electron/remote'),
+          app = _window$require.app;
+        var logFolderPath = path.resolve(app.getPath('logs'), 'logs');
+        var maxFiles = _opts.maxFiles || 5;
+        _logWorkerInteractor.addFsLogger(_label, logFolderPath, maxFiles);
+      } else {
+        this.warn('window.require is not present, logWorkerInteractor.addFsLogger cannot proceed');
+      }
+    }
+  }
+  return _createClass(LoggerImpl, [{
+    key: "setLogLevel",
+    value: function setLogLevel(logLevel) {
+      this._logLevel = logLevel;
+    }
+  }, {
+    key: "debug",
+    value: function debug() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      this._log.apply(this, [LogLevel.DEBUG].concat(args));
+    }
+  }, {
+    key: "info",
+    value: function info() {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      this._log.apply(this, [LogLevel.INFO].concat(args));
+    }
+  }, {
+    key: "warn",
+    value: function warn() {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      this._log.apply(this, [LogLevel.WARN].concat(args));
+    }
+  }, {
+    key: "error",
+    value: function error() {
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+      this._log.apply(this, [LogLevel.ERROR].concat(args));
+    }
+  }, {
+    key: "_log",
+    value: function _log(logLevel) {
+      if (logLevel > this._logLevel) {
+        return;
+      }
+
+      // prepend prefix to the log message if it exists
+      for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+        args[_key5 - 1] = arguments[_key5];
+      }
+      if (this._opts.prefix) {
+        args.unshift("".concat(this._opts.prefix));
+      }
+      // prepend log level to second position of the log message
+      args.unshift(padEnd(upperCase(logLevelMap[logLevel] || 'unknown'), 5, ' '));
+      // prepend log level to first position of the log message
+      args.unshift(dayjs().format('YYYY-MM-DD HH:mm:ss.SSS'));
+      if (this._dest.database) {
+        this._pipeToDatabase(args.join(' '));
+      }
+      if (this._dest.console) {
+        this._pipeToConsole(logLevel, args);
+      }
+    }
+  }, {
+    key: "_pipeToDatabase",
+    value: function _pipeToDatabase(message) {
+      this._logWorkerInteractor.sendLog(message, this._label);
+    }
+  }, {
+    key: "_pipeToConsole",
+    value: function _pipeToConsole(logLevel, args) {
+      var console = originConsole;
+      switch (logLevel) {
+        case LogLevel.DEBUG:
+          console.debug.apply(console, _toConsumableArray(args));
+          break;
+        case LogLevel.INFO:
+          console.info.apply(console, _toConsumableArray(args));
+          break;
+        case LogLevel.WARN:
+          console.warn.apply(console, _toConsumableArray(args));
+          break;
+        case LogLevel.ERROR:
+          console.error.apply(console, _toConsumableArray(args));
+          break;
+      }
+    }
+  }]);
+}();

package/lib-es/logger/manager-impl.js

@@ -0,0 +1,63 @@
+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.from.js";
+import "core-js/modules/es.string.iterator.js";
+import { loggerLabels } from './common';
+export var LogManagerImpl = /*#__PURE__*/function () {
+  function LogManagerImpl(_logWorkerInteractor) {
+    _classCallCheck(this, LogManagerImpl);
+    _defineProperty(this, "_lastId", -1);
+    this._logWorkerInteractor = _logWorkerInteractor;
+  }
+  return _createClass(LogManagerImpl, [{
+    key: "flush",
+    value: function () {
+      var _flush = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 1;
+              return this._logWorkerInteractor.deleteLogs(Array.from(loggerLabels), this._lastId);
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function flush() {
+        return _flush.apply(this, arguments);
+      }
+      return flush;
+    }()
+  }, {
+    key: "collectLogs",
+    value: function () {
+      var _collectLogs = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var _yield$this$_logWorke, file, lastId;
+        return _regeneratorRuntime.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 1;
+              return this._logWorkerInteractor.collectLogs(Array.from(loggerLabels));
+            case 1:
+              _yield$this$_logWorke = _context2.sent;
+              file = _yield$this$_logWorke.file;
+              lastId = _yield$this$_logWorke.lastId;
+              this._lastId = lastId;
+              return _context2.abrupt("return", file);
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function collectLogs() {
+        return _collectLogs.apply(this, arguments);
+      }
+      return collectLogs;
+    }()
+  }]);
+}();

package/lib-es/logger/type.js

@@ -0,0 +1,7 @@
+export var LogLevel = /*#__PURE__*/function (LogLevel) {
+  LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+  LogLevel[LogLevel["WARN"] = 2] = "WARN";
+  LogLevel[LogLevel["INFO"] = 3] = "INFO";
+  LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
+  return LogLevel;
+}({});

package/lib-es/restful-scheduler/scheduler.js

@@ -0,0 +1,224 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, 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 o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import "core-js/modules/es.array.find-index.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.error.cause.js";
+import "core-js/modules/es.error.to-string.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.array.is-array.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.array.splice.js";
+import "core-js/modules/es.date.now.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.date.to-string.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.regexp.constructor.js";
+import "core-js/modules/es.regexp.dot-all.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.regexp.sticky.js";
+import "core-js/modules/es.regexp.test.js";
+import "core-js/modules/es.regexp.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.map.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.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+export var DEFAULT_MAX_CONCURRENT = 10;
+var AgoraRequestWeightManager = /*#__PURE__*/function () {
+  function AgoraRequestWeightManager() {
+    _classCallCheck(this, AgoraRequestWeightManager);
+    _defineProperty(this, "_rules", new Map());
+  }
+  return _createClass(AgoraRequestWeightManager, [{
+    key: "getWeight",
+    value: function getWeight(url) {
+      var _iterator = _createForOfIteratorHelper(this._rules),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _slicedToArray(_step.value, 2),
+            pattern = _step$value[0],
+            weight = _step$value[1];
+          if (pattern.test(url)) {
+            return weight;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return 0;
+    }
+  }, {
+    key: "addRule",
+    value: function addRule(pattern, weight) {
+      if (typeof pattern === 'string') {
+        this._rules.set(new RegExp(pattern), weight);
+      } else {
+        this._rules.set(pattern, weight);
+      }
+    }
+  }]);
+}();
+var AgoraPriorityQueue = /*#__PURE__*/function () {
+  function AgoraPriorityQueue() {
+    _classCallCheck(this, AgoraPriorityQueue);
+    _defineProperty(this, "_items", []);
+  }
+  return _createClass(AgoraPriorityQueue, [{
+    key: "enqueue",
+    value: function enqueue(item) {
+      this._items.push(item);
+    }
+  }, {
+    key: "dequeue",
+    value: function dequeue(timeoutThreshold) {
+      var _this = this;
+      var now = Date.now();
+      var taskIndex = this._items.findIndex(function (item) {
+        return now - (item === null || item === void 0 ? void 0 : item.addedAt) > timeoutThreshold;
+      });
+      if (taskIndex !== -1) {
+        return this._items.splice(taskIndex, 1)[0];
+      }
+      taskIndex = this._items.findIndex(function (item) {
+        return (item === null || item === void 0 ? void 0 : item.weight) === Math.max.apply(Math, _toConsumableArray(_this._items.map(function (item) {
+          return item === null || item === void 0 ? void 0 : item.weight;
+        })));
+      });
+      if (taskIndex !== -1) {
+        return this._items.splice(taskIndex, 1)[0];
+      }
+      return undefined;
+    }
+  }]);
+}();
+export var AgoraRequestScheduler = /*#__PURE__*/function () {
+  // in ms
+
+  function AgoraRequestScheduler(configs) {
+    var _rules$size,
+      _this2 = this;
+    _classCallCheck(this, AgoraRequestScheduler);
+    _defineProperty(this, "_maxConcurrent", DEFAULT_MAX_CONCURRENT);
+    _defineProperty(this, "_runningCount", 0);
+    _defineProperty(this, "_queueControl", new AgoraPriorityQueue());
+    _defineProperty(this, "_weightManager", new AgoraRequestWeightManager());
+    _defineProperty(this, "_timeoutThreshold", 5000);
+    var _ref = configs !== null && configs !== void 0 ? configs : {},
+      rules = _ref.rules,
+      maxConcurrent = _ref.maxConcurrent;
+    if (maxConcurrent && typeof maxConcurrent === 'number') {
+      this._maxConcurrent = maxConcurrent;
+    }
+    if (((_rules$size = rules === null || rules === void 0 ? void 0 : rules.size) !== null && _rules$size !== void 0 ? _rules$size : 0) > 0) {
+      rules === null || rules === void 0 || rules.forEach(function (v, k) {
+        if ((k instanceof RegExp || typeof k === 'string') && typeof v === 'number') {
+          _this2._weightManager.addRule(k, v);
+        }
+      });
+    }
+  }
+  return _createClass(AgoraRequestScheduler, [{
+    key: "addTask",
+    value: function addTask(url, executor) {
+      var task = {
+        url: url,
+        weight: this._weightManager.getWeight(url),
+        addedAt: Date.now(),
+        executor: executor
+      };
+      this._queueControl.enqueue(task);
+      this._executeTask();
+    }
+  }, {
+    key: "_isIdle",
+    value: function _isIdle() {
+      if (this._runningCount < this._maxConcurrent) {
+        return true;
+      }
+      return false;
+    }
+  }, {
+    key: "_executeTask",
+    value: function () {
+      var _executeTask2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var task, _t;
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (this._isIdle()) {
+                _context.next = 1;
+                break;
+              }
+              return _context.abrupt("return");
+            case 1:
+              task = this._queueControl.dequeue(this._timeoutThreshold);
+              if (!task) {
+                _context.next = 6;
+                break;
+              }
+              this._runningCount++;
+              _context.prev = 2;
+              _context.next = 3;
+              return task.executor();
+            case 3:
+              _context.next = 5;
+              break;
+            case 4:
+              _context.prev = 4;
+              _t = _context["catch"](2);
+            case 5:
+              _context.prev = 5;
+              this._onTaskComplete();
+              return _context.finish(5);
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[2, 4, 5, 6]]);
+      }));
+      function _executeTask() {
+        return _executeTask2.apply(this, arguments);
+      }
+      return _executeTask;
+    }()
+  }, {
+    key: "_onTaskComplete",
+    value: function _onTaskComplete() {
+      this._runningCount--;
+      this._executeTask();
+    }
+  }]);
+}();

package/lib-es/schedule/index.js

@@ -0,0 +1,3 @@
+import * as _AgoraScheduler from "./scheduler";
+export { _AgoraScheduler as AgoraScheduler };
+export { ActionWhenTaskFail } from "./task";

package/lib-es/schedule/scheduler.js

@@ -0,0 +1,102 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/es.weak-set.js";
+import "core-js/modules/esnext.weak-set.add-all.js";
+import "core-js/modules/esnext.weak-set.delete-all.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { ActionWhenTaskFail } from './task';
+import { IntervalTask, PollingTask } from './task';
+export var Duration = /*#__PURE__*/function () {
+  function Duration() {
+    _classCallCheck(this, Duration);
+  }
+  return _createClass(Duration, null, [{
+    key: "second",
+    value: function second(amount) {
+      return this._factors.second * amount;
+    }
+  }, {
+    key: "minute",
+    value: function minute(amount) {
+      return this._factors.minute * amount;
+    }
+  }, {
+    key: "hour",
+    value: function hour(amount) {
+      return this._factors.hour * amount;
+    }
+  }]);
+}();
+_defineProperty(Duration, "_factors", {
+  hour: 1000 * 60 * 60,
+  minute: 1000 * 60,
+  second: 1000
+});
+var Scheduler = /*#__PURE__*/function () {
+  function Scheduler() {
+    _classCallCheck(this, Scheduler);
+    _defineProperty(this, "_tasks", new WeakSet());
+  }
+  return _createClass(Scheduler, [{
+    key: "addPollingTask",
+    value: function addPollingTask(runnable, intervalInMs) {
+      var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      var onFail = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {
+        return ActionWhenTaskFail.CONTINUE;
+      };
+      var task = new PollingTask({
+        runnable: runnable,
+        interval: intervalInMs,
+        immediate: immediate,
+        onFail: onFail
+      });
+      task.start();
+      this._tasks.add(task);
+      return task;
+    }
+  }, {
+    key: "addDelayTask",
+    value: function addDelayTask(runnable, delayInMs) {
+      var _this = this;
+      var task = new PollingTask({
+        runnable: runnable,
+        interval: delayInMs,
+        once: true,
+        onFail: function onFail() {
+          return ActionWhenTaskFail.EXIT;
+        },
+        onComplete: function onComplete() {
+          _this._tasks["delete"](task);
+        }
+      });
+      task.start();
+      this._tasks.add(task);
+      return task;
+    }
+  }, {
+    key: "addIntervalTask",
+    value: function addIntervalTask(runnable, intervalInMs) {
+      var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      var onFail = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {
+        return ActionWhenTaskFail.CONTINUE;
+      };
+      var task = new IntervalTask({
+        runnable: runnable,
+        interval: intervalInMs,
+        immediate: immediate,
+        onFail: onFail
+      });
+      task.start();
+      this._tasks.add(task);
+      return task;
+    }
+  }]);
+}();
+export var createScheduler = function createScheduler() {
+  return new Scheduler();
+};
+export var shared = createScheduler();