agora-foundation 1.0.0

package/lib/logger/index.js

@@ -0,0 +1,70 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "LogLevel", {
+  enumerable: true,
+  get: function get() {
+    return _type.LogLevel;
+  }
+});
+exports.getLogger = exports.getLogManager = void 0;
+Object.defineProperty(exports, "logLevelMap", {
+  enumerable: true,
+  get: function get() {
+    return _constants.logLevelMap;
+  }
+});
+Object.defineProperty(exports, "restoreConsoleHijack", {
+  enumerable: true,
+  get: function get() {
+    return _hijack.restoreConsoleHijack;
+  }
+});
+exports.setLogLevel = void 0;
+Object.defineProperty(exports, "setupConsoleHijack", {
+  enumerable: true,
+  get: function get() {
+    return _hijack.setupConsoleHijack;
+  }
+});
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.iterator.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.for-each.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _worker = require("../worker");
+var _loggerImpl = require("./logger-impl");
+var _managerImpl = require("./manager-impl");
+var _type = require("./type");
+var _hijack = require("./hijack");
+var _constants = require("./constants");
+var loggerRegistrar = new Map();
+var logLevel = _type.LogLevel.DEBUG;
+var getLogger = exports.getLogger = function getLogger() {
+  var label = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "default";
+  if (!loggerRegistrar.has(label)) {
+    loggerRegistrar.set(label, new _loggerImpl.LoggerImpl(label, {
+      console: true,
+      database: true
+    }, logLevel, (0, _worker.getWorkerSingleton)()));
+  }
+  return loggerRegistrar.get(label);
+};
+var logManager;
+var getLogManager = exports.getLogManager = function getLogManager() {
+  if (!logManager) {
+    logManager = new _managerImpl.LogManagerImpl((0, _worker.getWorkerSingleton)());
+  }
+  return logManager;
+};
+var setLogLevel = exports.setLogLevel = function setLogLevel(_logLevel) {
+  logLevel = _logLevel;
+  loggerRegistrar.forEach(function (logger) {
+    logger.setLogLevel(logLevel);
+  });
+};

package/lib/logger/logger-impl.d.ts

@@ -0,0 +1,19 @@
+import { LogLevel, Logger, LogWorkerInteractor } from './type';
+export declare class LoggerImpl implements Logger {
+    private _label;
+    private _dest;
+    private _logLevel;
+    private _logWorkerInteractor;
+    constructor(_label: string, _dest: {
+        console: boolean;
+        database: boolean;
+    }, _logLevel: LogLevel, _logWorkerInteractor: LogWorkerInteractor);
+    setLogLevel(logLevel: LogLevel): void;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    private _log;
+    private _pipeToDatabase;
+    private _pipeToConsole;
+}

package/lib/logger/logger-impl.js

@@ -0,0 +1,111 @@
+"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.LoggerImpl = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.join.js");
+require("core-js/modules/es.array.unshift.js");
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _upperCase = _interopRequireDefault(require("lodash/upperCase"));
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _constants = require("./constants");
+var _type = require("./type");
+var _hijack = require("./hijack");
+var _padEnd = _interopRequireDefault(require("lodash/padEnd"));
+var LoggerImpl = exports.LoggerImpl = /*#__PURE__*/function () {
+  function LoggerImpl(_label, _dest, _logLevel, _logWorkerInteractor) {
+    (0, _classCallCheck2["default"])(this, LoggerImpl);
+    this._label = _label;
+    this._dest = _dest;
+    this._logLevel = _logLevel;
+    this._logWorkerInteractor = _logWorkerInteractor;
+  }
+  return (0, _createClass2["default"])(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, [_type.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, [_type.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, [_type.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, [_type.LogLevel.ERROR].concat(args));
+    }
+  }, {
+    key: "_log",
+    value: function _log(logLevel) {
+      if (logLevel > this._logLevel) {
+        return;
+      }
+      // prepend log level to second position of the log message
+      for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+        args[_key5 - 1] = arguments[_key5];
+      }
+      args.unshift((0, _padEnd["default"])((0, _upperCase["default"])(_constants.logLevelMap[logLevel] || 'unknown'), 5, ' '));
+      // prepend log level to first position of the log message
+      args.unshift((0, _dayjs["default"])().format('YYYY-MM-DD HH:mm:ss'));
+      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 = _hijack.originConsole;
+      switch (logLevel) {
+        case _type.LogLevel.DEBUG:
+          console.debug.apply(console, (0, _toConsumableArray2["default"])(args));
+          break;
+        case _type.LogLevel.INFO:
+          console.info.apply(console, (0, _toConsumableArray2["default"])(args));
+          break;
+        case _type.LogLevel.WARN:
+          console.warn.apply(console, (0, _toConsumableArray2["default"])(args));
+          break;
+        case _type.LogLevel.ERROR:
+          console.error.apply(console, (0, _toConsumableArray2["default"])(args));
+          break;
+      }
+    }
+  }]);
+}();

package/lib/logger/manager-impl.d.ts

@@ -0,0 +1,8 @@
+import { LogManager, LogWorkerInteractor } from './type';
+export declare class LogManagerImpl implements LogManager {
+    private _logWorkerInteractor;
+    private _lastId;
+    constructor(_logWorkerInteractor: LogWorkerInteractor);
+    flush(): Promise<void>;
+    collectLogs(): Promise<File>;
+}

package/lib/logger/manager-impl.js

@@ -0,0 +1,67 @@
+"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.LogManagerImpl = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+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 LogManagerImpl = exports.LogManagerImpl = /*#__PURE__*/function () {
+  function LogManagerImpl(_logWorkerInteractor) {
+    (0, _classCallCheck2["default"])(this, LogManagerImpl);
+    (0, _defineProperty2["default"])(this, "_lastId", -1);
+    this._logWorkerInteractor = _logWorkerInteractor;
+  }
+  return (0, _createClass2["default"])(LogManagerImpl, [{
+    key: "flush",
+    value: function () {
+      var _flush = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              this._logWorkerInteractor.deleteLogs(['default'], 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 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var _yield$this$_logWorke, file, lastId;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this._logWorkerInteractor.collectLogs(['default']);
+            case 2:
+              _yield$this$_logWorke = _context2.sent;
+              file = _yield$this$_logWorke.file;
+              lastId = _yield$this$_logWorke.lastId;
+              this._lastId = lastId;
+              return _context2.abrupt("return", file);
+            case 7:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function collectLogs() {
+        return _collectLogs.apply(this, arguments);
+      }
+      return collectLogs;
+    }()
+  }]);
+}();

package/lib/logger/type.d.ts

@@ -0,0 +1,25 @@
+export declare enum LogLevel {
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    DEBUG = 4
+}
+export interface Logger {
+    debug: typeof console.debug;
+    info: typeof console.info;
+    warn: typeof console.warn;
+    error: typeof console.error;
+}
+export interface LogManager {
+    collectLogs(): Promise<File>;
+    flush(): Promise<void>;
+}
+export interface LogWorkerInteractor {
+    setMaxRecords(maxRecords: number): Promise<void>;
+    sendLog(message: string, label: string): void;
+    collectLogs(labels: string[]): Promise<{
+        file: File;
+        lastId: number;
+    }>;
+    deleteLogs(labels: string[], lastId: number): Promise<void>;
+}

package/lib/logger/type.js

@@ -0,0 +1,14 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LogLevel = void 0;
+var LogLevel = exports.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/schedule/index.d.ts

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

package/lib/schedule/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+require("core-js/modules/es.array.iterator.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.to-string.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/es.weak-map.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ActionWhenTaskFail", {
+  enumerable: true,
+  get: function get() {
+    return _task.ActionWhenTaskFail;
+  }
+});
+exports.AgoraScheduler = void 0;
+var _AgoraScheduler = _interopRequireWildcard(require("./scheduler"));
+exports.AgoraScheduler = _AgoraScheduler;
+var _task = require("./task");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }

package/lib/schedule/scheduler.d.ts

@@ -0,0 +1,21 @@
+import { ActionWhenTaskFail } from '.';
+export type Task = {
+    start: () => void;
+    stop: () => void;
+    isStopped: boolean;
+};
+export declare abstract class Duration {
+    private static _factors;
+    static second(amount: number): number;
+    static minute(amount: number): number;
+    static hour(amount: number): number;
+}
+declare class Scheduler {
+    private _tasks;
+    addPollingTask(runnable: () => void, intervalInMs: number, immediate?: boolean, onFail?: () => ActionWhenTaskFail): Task;
+    addDelayTask(runnable: () => void, delayInMs: number): Task;
+    addIntervalTask(runnable: () => void, intervalInMs: number, immediate?: boolean, onFail?: () => ActionWhenTaskFail): Task;
+}
+export declare const createScheduler: () => Scheduler;
+export declare const shared: Scheduler;
+export {};

package/lib/schedule/scheduler.js

@@ -0,0 +1,108 @@
+"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.shared = exports.createScheduler = exports.Duration = void 0;
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/es.weak-set.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 _ = require(".");
+var _task = require("./task");
+var Duration = exports.Duration = /*#__PURE__*/function () {
+  function Duration() {
+    (0, _classCallCheck2["default"])(this, Duration);
+  }
+  return (0, _createClass2["default"])(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;
+    }
+  }]);
+}();
+(0, _defineProperty2["default"])(Duration, "_factors", {
+  hour: 1000 * 60 * 60,
+  minute: 1000 * 60,
+  second: 1000
+});
+var Scheduler = /*#__PURE__*/function () {
+  function Scheduler() {
+    (0, _classCallCheck2["default"])(this, Scheduler);
+    (0, _defineProperty2["default"])(this, "_tasks", new WeakSet());
+  }
+  return (0, _createClass2["default"])(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 _task.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 _task.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 _task.IntervalTask({
+        runnable: runnable,
+        interval: intervalInMs,
+        immediate: immediate,
+        onFail: onFail
+      });
+      task.start();
+      this._tasks.add(task);
+      return task;
+    }
+  }]);
+}();
+var createScheduler = exports.createScheduler = function createScheduler() {
+  return new Scheduler();
+};
+var shared = exports.shared = createScheduler();

package/lib/schedule/task.d.ts

@@ -0,0 +1,36 @@
+export declare enum ActionWhenTaskFail {
+    CONTINUE = 0,
+    EXIT = 1
+}
+type AnyFunction = () => void;
+type IntervalArguments = {
+    runnable: AnyFunction;
+    interval: number;
+    immediate?: boolean;
+    onFail: (err: any) => ActionWhenTaskFail;
+    onComplete?: () => void;
+};
+type PollingArguments = IntervalArguments & {
+    once?: boolean;
+};
+export declare class PollingTask {
+    private __arguments;
+    private __timer?;
+    private __running;
+    constructor(__arguments: PollingArguments);
+    start(): void;
+    private poll;
+    stop(): void;
+    get isStopped(): boolean;
+}
+export declare class IntervalTask {
+    private __arguments;
+    private __timer?;
+    private __running;
+    constructor(__arguments: IntervalArguments);
+    start(): void;
+    private poll;
+    stop(): void;
+    get isStopped(): boolean;
+}
+export {};

package/lib/schedule/task.js

@@ -0,0 +1,167 @@
+"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.PollingTask = exports.IntervalTask = exports.ActionWhenTaskFail = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+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 _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.error.to-string.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/web.timers.js");
+var ActionWhenTaskFail = exports.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 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(resolve, reject) {
+      var v;
+      return _regenerator["default"].wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            _context.next = 3;
+            return runnable();
+          case 3:
+            v = _context.sent;
+            resolve(v);
+            _context.next = 10;
+            break;
+          case 7:
+            _context.prev = 7;
+            _context.t0 = _context["catch"](0);
+            reject(_context.t0);
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[0, 7]]);
+    }));
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+};
+var PollingTask = exports.PollingTask = /*#__PURE__*/function () {
+  function PollingTask(__arguments) {
+    (0, _classCallCheck2["default"])(this, PollingTask);
+    (0, _defineProperty2["default"])(this, "__running", false);
+    this.__arguments = __arguments;
+  }
+  return (0, _createClass2["default"])(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__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return promisify(_this2.__arguments.runnable)["catch"](function (err) {
+                var action = _this2.__arguments.onFail(err);
+                if (action === ActionWhenTaskFail.EXIT) {
+                  _this2.__running = false;
+                }
+              });
+            case 2:
+              !_this2.__arguments.once && _this2.poll();
+            case 3:
+            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;
+    }
+  }]);
+}();
+var IntervalTask = exports.IntervalTask = /*#__PURE__*/function () {
+  function IntervalTask(__arguments) {
+    (0, _classCallCheck2["default"])(this, IntervalTask);
+    (0, _defineProperty2["default"])(this, "__running", false);
+    this.__arguments = __arguments;
+  }
+  return (0, _createClass2["default"])(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;
+    }
+  }]);
+}();