@rango-dev/queue-manager-core 0.1.15-next.4 → 0.1.15-next.6

package/dist/queue-manager-core.esm.js

@@ -1,1494 +0,0 @@
-import { openDB } from 'idb';
-import { v4 } from 'uuid';
-
-function _regeneratorRuntime() {
-  _regeneratorRuntime = function () {
-    return exports;
-  };
-  var exports = {},
-    Op = Object.prototype,
-    hasOwn = Op.hasOwnProperty,
-    defineProperty = Object.defineProperty || function (obj, key, desc) {
-      obj[key] = desc.value;
-    },
-    $Symbol = "function" == typeof Symbol ? Symbol : {},
-    iteratorSymbol = $Symbol.iterator || "@@iterator",
-    asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
-    toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-  function define(obj, key, value) {
-    return Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: !0,
-      configurable: !0,
-      writable: !0
-    }), obj[key];
-  }
-  try {
-    define({}, "");
-  } catch (err) {
-    define = function (obj, key, value) {
-      return obj[key] = value;
-    };
-  }
-  function wrap(innerFn, outerFn, self, tryLocsList) {
-    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
-      generator = Object.create(protoGenerator.prototype),
-      context = new Context(tryLocsList || []);
-    return defineProperty(generator, "_invoke", {
-      value: makeInvokeMethod(innerFn, self, context)
-    }), generator;
-  }
-  function tryCatch(fn, obj, arg) {
-    try {
-      return {
-        type: "normal",
-        arg: fn.call(obj, arg)
-      };
-    } catch (err) {
-      return {
-        type: "throw",
-        arg: err
-      };
-    }
-  }
-  exports.wrap = wrap;
-  var ContinueSentinel = {};
-  function Generator() {}
-  function GeneratorFunction() {}
-  function GeneratorFunctionPrototype() {}
-  var IteratorPrototype = {};
-  define(IteratorPrototype, iteratorSymbol, function () {
-    return this;
-  });
-  var getProto = Object.getPrototypeOf,
-    NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
-  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
-  function defineIteratorMethods(prototype) {
-    ["next", "throw", "return"].forEach(function (method) {
-      define(prototype, method, function (arg) {
-        return this._invoke(method, arg);
-      });
-    });
-  }
-  function AsyncIterator(generator, PromiseImpl) {
-    function invoke(method, arg, resolve, reject) {
-      var record = tryCatch(generator[method], generator, arg);
-      if ("throw" !== record.type) {
-        var result = record.arg,
-          value = result.value;
-        return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
-          invoke("next", value, resolve, reject);
-        }, function (err) {
-          invoke("throw", err, resolve, reject);
-        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
-          result.value = unwrapped, resolve(result);
-        }, function (error) {
-          return invoke("throw", error, resolve, reject);
-        });
-      }
-      reject(record.arg);
-    }
-    var previousPromise;
-    defineProperty(this, "_invoke", {
-      value: function (method, arg) {
-        function callInvokeWithMethodAndArg() {
-          return new PromiseImpl(function (resolve, reject) {
-            invoke(method, arg, resolve, reject);
-          });
-        }
-        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-      }
-    });
-  }
-  function makeInvokeMethod(innerFn, self, context) {
-    var state = "suspendedStart";
-    return function (method, arg) {
-      if ("executing" === state) throw new Error("Generator is already running");
-      if ("completed" === state) {
-        if ("throw" === method) throw arg;
-        return doneResult();
-      }
-      for (context.method = method, context.arg = arg;;) {
-        var delegate = context.delegate;
-        if (delegate) {
-          var delegateResult = maybeInvokeDelegate(delegate, context);
-          if (delegateResult) {
-            if (delegateResult === ContinueSentinel) continue;
-            return delegateResult;
-          }
-        }
-        if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
-          if ("suspendedStart" === state) throw state = "completed", context.arg;
-          context.dispatchException(context.arg);
-        } else "return" === context.method && context.abrupt("return", context.arg);
-        state = "executing";
-        var record = tryCatch(innerFn, self, context);
-        if ("normal" === record.type) {
-          if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
-          return {
-            value: record.arg,
-            done: context.done
-          };
-        }
-        "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
-      }
-    };
-  }
-  function maybeInvokeDelegate(delegate, context) {
-    var methodName = context.method,
-      method = delegate.iterator[methodName];
-    if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
-    var record = tryCatch(method, delegate.iterator, context.arg);
-    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
-    var info = record.arg;
-    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
-  }
-  function pushTryEntry(locs) {
-    var entry = {
-      tryLoc: locs[0]
-    };
-    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
-  }
-  function resetTryEntry(entry) {
-    var record = entry.completion || {};
-    record.type = "normal", delete record.arg, entry.completion = record;
-  }
-  function Context(tryLocsList) {
-    this.tryEntries = [{
-      tryLoc: "root"
-    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
-  }
-  function values(iterable) {
-    if (iterable) {
-      var iteratorMethod = iterable[iteratorSymbol];
-      if (iteratorMethod) return iteratorMethod.call(iterable);
-      if ("function" == typeof iterable.next) return iterable;
-      if (!isNaN(iterable.length)) {
-        var i = -1,
-          next = function next() {
-            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
-            return next.value = undefined, next.done = !0, next;
-          };
-        return next.next = next;
-      }
-    }
-    return {
-      next: doneResult
-    };
-  }
-  function doneResult() {
-    return {
-      value: undefined,
-      done: !0
-    };
-  }
-  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
-    value: GeneratorFunctionPrototype,
-    configurable: !0
-  }), defineProperty(GeneratorFunctionPrototype, "constructor", {
-    value: GeneratorFunction,
-    configurable: !0
-  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
-    var ctor = "function" == typeof genFun && genFun.constructor;
-    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
-  }, exports.mark = function (genFun) {
-    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
-  }, exports.awrap = function (arg) {
-    return {
-      __await: arg
-    };
-  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
-    return this;
-  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-    void 0 === PromiseImpl && (PromiseImpl = Promise);
-    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
-    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
-      return result.done ? result.value : iter.next();
-    });
-  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
-    return this;
-  }), define(Gp, "toString", function () {
-    return "[object Generator]";
-  }), exports.keys = function (val) {
-    var object = Object(val),
-      keys = [];
-    for (var key in object) keys.push(key);
-    return keys.reverse(), function next() {
-      for (; keys.length;) {
-        var key = keys.pop();
-        if (key in object) return next.value = key, next.done = !1, next;
-      }
-      return next.done = !0, next;
-    };
-  }, exports.values = values, Context.prototype = {
-    constructor: Context,
-    reset: function (skipTempReset) {
-      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
-    },
-    stop: function () {
-      this.done = !0;
-      var rootRecord = this.tryEntries[0].completion;
-      if ("throw" === rootRecord.type) throw rootRecord.arg;
-      return this.rval;
-    },
-    dispatchException: function (exception) {
-      if (this.done) throw exception;
-      var context = this;
-      function handle(loc, caught) {
-        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
-      }
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i],
-          record = entry.completion;
-        if ("root" === entry.tryLoc) return handle("end");
-        if (entry.tryLoc <= this.prev) {
-          var hasCatch = hasOwn.call(entry, "catchLoc"),
-            hasFinally = hasOwn.call(entry, "finallyLoc");
-          if (hasCatch && hasFinally) {
-            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
-            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
-          } else if (hasCatch) {
-            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
-          } else {
-            if (!hasFinally) throw new Error("try statement without catch or finally");
-            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
-          }
-        }
-      }
-    },
-    abrupt: function (type, arg) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
-          var finallyEntry = entry;
-          break;
-        }
-      }
-      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
-      var record = finallyEntry ? finallyEntry.completion : {};
-      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
-    },
-    complete: function (record, afterLoc) {
-      if ("throw" === record.type) throw record.arg;
-      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
-    },
-    finish: function (finallyLoc) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
-      }
-    },
-    catch: function (tryLoc) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.tryLoc === tryLoc) {
-          var record = entry.completion;
-          if ("throw" === record.type) {
-            var thrown = record.arg;
-            resetTryEntry(entry);
-          }
-          return thrown;
-        }
-      }
-      throw new Error("illegal catch attempt");
-    },
-    delegateYield: function (iterable, resultName, nextLoc) {
-      return this.delegate = {
-        iterator: values(iterable),
-        resultName: resultName,
-        nextLoc: nextLoc
-      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
-    }
-  }, exports;
-}
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
-  }
-}
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-      args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-      _next(undefined);
-    });
-  };
-}
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-    return target;
-  };
-  return _extends.apply(this, arguments);
-}
-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;
-}
-function _createForOfIteratorHelperLoose(o, allowArrayLike) {
-  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-  if (it) return (it = it.call(o)).next.bind(it);
-  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-    if (it) o = it;
-    var i = 0;
-    return function () {
-      if (i >= o.length) return {
-        done: true
-      };
-      return {
-        done: false,
-        value: o[i++]
-      };
-    };
-  }
-  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 DB_NAME = 'queues-manager';
-var OBJECT_STORE_NAME = 'queues';
-var VERSION = 1;
-var Persistor = /*#__PURE__*/function () {
-  function Persistor() {
-    this.db = openDB(DB_NAME, VERSION, {
-      upgrade: function upgrade(db) {
-        db.createObjectStore(OBJECT_STORE_NAME, {
-          keyPath: 'id'
-        });
-      }
-    });
-  }
-  var _proto = Persistor.prototype;
-  _proto.insertQueue = /*#__PURE__*/function () {
-    var _insertQueue = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(queue) {
-      var db, queueRecord;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            _context.next = 2;
-            return this.db;
-          case 2:
-            db = _context.sent;
-            _context.next = 5;
-            return db.get(OBJECT_STORE_NAME, queue.id);
-          case 5:
-            queueRecord = _context.sent;
-            if (!queueRecord) {
-              _context.next = 9;
-              break;
-            }
-            _context.next = 11;
-            break;
-          case 9:
-            _context.next = 11;
-            return db.add(OBJECT_STORE_NAME, queue);
-          case 11:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee, this);
-    }));
-    function insertQueue(_x) {
-      return _insertQueue.apply(this, arguments);
-    }
-    return insertQueue;
-  }();
-  _proto.updateQueue = /*#__PURE__*/function () {
-    var _updateQueue = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(id, queue) {
-      var db, currentRecord, updatedRecord;
-      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
-          case 0:
-            _context2.next = 2;
-            return this.db;
-          case 2:
-            db = _context2.sent;
-            _context2.next = 5;
-            return db.get(OBJECT_STORE_NAME, id);
-          case 5:
-            currentRecord = _context2.sent;
-            if (currentRecord) {
-              _context2.next = 8;
-              break;
-            }
-            return _context2.abrupt("return");
-          case 8:
-            updatedRecord = _extends({}, currentRecord, queue);
-            _context2.next = 11;
-            return db.put(OBJECT_STORE_NAME, updatedRecord);
-          case 11:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2, this);
-    }));
-    function updateQueue(_x2, _x3) {
-      return _updateQueue.apply(this, arguments);
-    }
-    return updateQueue;
-  }();
-  _proto.getAll = /*#__PURE__*/function () {
-    var _getAll = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
-      var db, results;
-      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-        while (1) switch (_context3.prev = _context3.next) {
-          case 0:
-            _context3.next = 2;
-            return this.db;
-          case 2:
-            db = _context3.sent;
-            _context3.next = 5;
-            return db.getAll(OBJECT_STORE_NAME);
-          case 5:
-            results = _context3.sent;
-            return _context3.abrupt("return", results);
-          case 7:
-          case "end":
-            return _context3.stop();
-        }
-      }, _callee3, this);
-    }));
-    function getAll() {
-      return _getAll.apply(this, arguments);
-    }
-    return getAll;
-  }();
-  return Persistor;
-}();
-
-var Status;
-(function (Status) {
-  Status["PENDING"] = "PENDING";
-  Status["RUNNING"] = "RUNNING";
-  Status["FAILED"] = "FAILED";
-  Status["SUCCESS"] = "SUCCESS";
-  Status["CANCELED"] = "CANCELED";
-  Status["BLOCKED"] = "BLOCKED";
-})(Status || (Status = {}));
-var SYNC_POLLING_INTERVAL = 5000;
-
-/**
- *
- * Notes on statuses:
- *  - Success: last task has success status
- *  - Failed: any of task has been failed
- *  - Running: first task is not on pending
- *  - Pending: default state. not started
- *
- */
-var Queue = /*#__PURE__*/function () {
-  function Queue(options) {
-    this.state = {
-      status: Status.PENDING,
-      activeTaskIndex: 0,
-      tasks: {}
-    };
-    this.tasks = [];
-    this.storage = {};
-    this.id = options.id;
-    this.events = options.events;
-    this.actions = options.actions;
-  }
-  /**
-   * Update queue status and trigger an event
-   *
-   */
-  var _proto = Queue.prototype;
-  _proto.updateQueueStatus = function updateQueueStatus(status) {
-    this.state.status = status;
-    this.events.onUpdateListStatus(status);
-  };
-  _proto.updateActiveTaskIndex = function updateActiveTaskIndex(index) {
-    this.state.activeTaskIndex = index;
-  }
-  /**
-   *
-   * Update task state (`status`, `blockedFor`) and trigger an event.
-   * @param id
-   * @param nextState
-   */;
-  _proto.updateTaskState = function updateTaskState(id, nextState) {
-    if (nextState.status) {
-      this.state.tasks[id].status = nextState.status;
-    }
-    if (nextState.blockedFor) {
-      this.state.tasks[id].blockedFor = nextState.blockedFor;
-    }
-    var updatedTaskEvent = {
-      id: id,
-      task: this.get(id),
-      action: this.tasks.find(function (task) {
-        return task.id === id;
-      }).action
-    };
-    this.events.onUpdate(updatedTaskEvent);
-  }
-  /**
-   * Create a task by providing an `action` name.
-   *
-   * this method creating the task, push it to the queue's tasks and trigger an event.
-   * @param action
-   */;
-  _proto.createTask = function createTask(action) {
-    var id = v4();
-    this.tasks.push({
-      action: action,
-      id: id
-    });
-    this.state.tasks[id] = {
-      status: Status.PENDING,
-      blockedFor: null
-    };
-    var createdTask = this.get(id);
-    this.events.onCreate({
-      id: id,
-      task: createdTask,
-      action: action
-    });
-  }
-  /**
-   * Initilize a queue with some tasks, instead of an empty queue.
-   *
-   * Using it for recover the queue state from persistor.
-   *
-   */;
-  _proto.initTasks = function initTasks(info) {
-    var _this = this;
-    this.state = info.state;
-    this.storage = info.storage;
-    info.tasks.forEach(function (task) {
-      _this.tasks.push(task);
-      var action = _this.tasks.find(function (t) {
-        return t.id === task.id;
-      }).action;
-      _this.events.onCreate({
-        id: task.id,
-        task: _this.get(task.id),
-        action: action
-      });
-    });
-  };
-  _proto.checkBlock = function checkBlock() {
-    var currentActiveTask = this.getActiveTask();
-    if (!currentActiveTask) {
-      return;
-    }
-    var task = currentActiveTask.task,
-      state = currentActiveTask.state;
-    if (state.status === Status.BLOCKED) {
-      this.events.onBlock({
-        action: task.action,
-        id: task.id,
-        reason: state.blockedFor
-      });
-    }
-  }
-  /**
-   * Getting task state by ID
-   */;
-  _proto.get = function get(id) {
-    var task = this.state.tasks[id];
-    if (!task) return null;
-    return task;
-  }
-  /**
-   *
-   * Checking if status of the last is `SUCCESS` or not
-   *
-   */;
-  _proto.lastTaskIsSuccessful = function lastTaskIsSuccessful() {
-    var lastTask = this.tasks[this.tasks.length - 1];
-    // checking for empty lists.
-    if (lastTask) {
-      var lastTaskState = this.state.tasks[lastTask.id];
-      // Maybe we didn't create the state yet. It should has success status as well.
-      if (!!lastTaskState && lastTaskState.status === Status.SUCCESS) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * If the first task started (it's not PENDING),
-   * it means the queue has been ran.
-   *
-   * @returns
-   */;
-  _proto.firstTaskIsStarted = function firstTaskIsStarted() {
-    var firstTask = this.tasks[0];
-    // checking for empty lists.
-    if (firstTask) {
-      var firstTaskState = this.state.tasks[firstTask.id];
-      // Maybe we didn't create the state yet.
-      if (!!firstTaskState) {
-        if (firstTaskState.status !== Status.PENDING) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  /**
-   * Getting active task index from state and
-   * returns the task and its state.
-   *
-   */;
-  _proto.getActiveTask = function getActiveTask() {
-    // First try to get task with `activeTask`
-    var index = this.state.activeTaskIndex;
-    var task = this.tasks[index];
-    // Consider all the tasks has been executed.
-    if (!task) {
-      return null;
-    }
-    var state = this.state.tasks[task.id];
-    return {
-      task: task,
-      state: state,
-      index: index
-    };
-  }
-  /**
-   * Update and find the queue status by checking state of each tasks in the queue.
-   */;
-  _proto.check = function check() {
-    var currentListStatus = this.state.status;
-    var nextListStatus = this.firstTaskIsStarted() ? Status.RUNNING : Status.PENDING;
-    if (this.lastTaskIsSuccessful()) {
-      nextListStatus = Status.SUCCESS;
-    } else {
-      // Is there any failed task?
-      for (var _iterator = _createForOfIteratorHelperLoose(this.tasks), _step; !(_step = _iterator()).done;) {
-        var task = _step.value;
-        var state = this.state.tasks[task.id];
-        // If one item fails, we stop to work on the list.
-        if (state.status === Status.FAILED) {
-          nextListStatus = Status.FAILED;
-          break;
-        }
-      }
-    }
-    // We only update and trigger an event when there is a new value
-    if (nextListStatus !== currentListStatus) {
-      this.updateQueueStatus(nextListStatus);
-    }
-  }
-  /**
-   * Execute active task.
-   * Based on the state of active task, the behaviour is different. If status is:
-   *  - Success -> we need to go to next task by updating the active index and try `next` on more time.
-   *  - Failed, Running, or no active task -> doesn't do anything.
-   *  - Pending or Blocked -> update the task and queue status to running, and execute the provided `action` for the task.
-   *
-   * The queue is a linked list somehow, active task means the pointer to where we are in the queue right now.
-   *
-   */;
-  _proto.next = function next(params) {
-    var _this2 = this;
-    this.check();
-    var currentActiveTask = this.getActiveTask();
-    if (!currentActiveTask) {
-      return;
-    }
-    var activeTaskIndex = currentActiveTask.index,
-      activeTask = currentActiveTask.task,
-      activeTaskState = currentActiveTask.state;
-    // if `activeTask` is already done, we will go for next one.
-    if (activeTaskState.status === Status.SUCCESS) {
-      this.updateActiveTaskIndex(activeTaskIndex + 1);
-      this.next(params);
-      return;
-    }
-    if ([Status.FAILED, Status.CANCELED, Status.RUNNING].includes(activeTaskState.status)) {
-      return;
-    }
-    if (activeTaskState.status === Status.PENDING || activeTaskState.status === Status.BLOCKED) {
-      // Update task status to `running`
-      this.updateTaskState(activeTask.id, {
-        status: Status.RUNNING
-      });
-      this.updateQueueStatus(Status.RUNNING);
-      // Try to execute task.
-      var execute = this.actions[activeTask.action];
-      execute({
-        context: this.getContext(params),
-        next: function next() {
-          _this2.markCurrentTaskAsFinished(params);
-        },
-        retry: function retry() {
-          _this2.resume(params);
-        },
-        failed: function failed() {
-          _this2.updateTaskState(activeTask.id, {
-            status: Status.FAILED
-          });
-          _this2.check();
-        },
-        schedule: function schedule(action) {
-          _this2.createTask(action);
-          _this2.check();
-        },
-        getStorage: this.getStorage.bind(this),
-        setStorage: this.setStorage.bind(this),
-        block: function block(reason) {
-          _this2.block({
-            reason: reason
-          });
-        },
-        unblock: function unblock() {
-          _this2.unblock();
-        }
-      });
-    }
-  }
-  /**
-   * Change the `status` of active task and queue to BLOCKED, then trigger an event.
-   */;
-  _proto.block = function block(_ref) {
-    var reason = _ref.reason,
-      _ref$silent = _ref.silent,
-      silent = _ref$silent === void 0 ? false : _ref$silent;
-    var currentActiveTask = this.getActiveTask();
-    if (!currentActiveTask) {
-      throw new Error("Task isn't exist.");
-    }
-    this.updateTaskState(currentActiveTask.task.id, {
-      status: Status.BLOCKED,
-      blockedFor: reason
-    });
-    this.updateQueueStatus(Status.BLOCKED);
-    if (!silent) {
-      this.events.onBlock({
-        action: currentActiveTask.task.action,
-        id: currentActiveTask.task.id,
-        reason: reason
-      });
-    }
-  }
-  /**
-   * If the active task is `BLOCKED`, update the task status to `PENDING`, queue status to `RUNNING`
-   * then trigger an event.
-   */;
-  _proto.unblock = function unblock() {
-    var currentActiveTask = this.getActiveTask();
-    if (!currentActiveTask || currentActiveTask.state.status !== Status.BLOCKED) {
-      throw new Error('Task is not blocked.');
-    }
-    this.updateTaskState(currentActiveTask.task.id, {
-      status: Status.PENDING
-    });
-    this.updateQueueStatus(Status.RUNNING);
-    this.events.onUnblock({
-      id: currentActiveTask.task.id
-    });
-  }
-  /**
-   * If the active task is `BLOCKED` then execute the `action` for the task.
-   *
-   * It is useful for when we need to run a blocked task without changing the status of task at the first place.
-   * For scenarios like we have some conditions in `action` and needs to run the `action` again
-   * to check the conditions are met or not, if yes, so we can proceed the `action`.
-   *
-   */;
-  _proto.forceRun = function forceRun(params) {
-    var _this3 = this;
-    var currentTask = this.getActiveTask();
-    if (!currentTask || currentTask.state.status !== Status.BLOCKED) {
-      throw new Error('Task is not blocked.');
-    }
-    // Try to execute task.
-    var execute = this.actions[currentTask.task.action];
-    execute({
-      context: this.getContext(params),
-      next: function next() {
-        /*
-          NOTE:
-            When running `forceRun`, the status of task can be `BLOCKED`
-            So we need to change to `Running` first.
-        */
-        // Update task status to `running`
-        _this3.updateTaskState(currentTask.task.id, {
-          status: Status.RUNNING
-        });
-        _this3.updateQueueStatus(Status.RUNNING);
-        _this3.markCurrentTaskAsFinished(params);
-      },
-      retry: function retry() {
-        _this3.resume(params);
-      },
-      failed: function failed() {
-        _this3.updateTaskState(currentTask.task.id, {
-          status: Status.FAILED
-        });
-        _this3.check();
-      },
-      schedule: function schedule(action) {
-        _this3.createTask(action);
-        _this3.check();
-      },
-      getStorage: this.getStorage.bind(this),
-      setStorage: this.setStorage.bind(this),
-      block: function block(reason) {
-        _this3.block({
-          reason: reason
-        });
-      },
-      unblock: function unblock() {
-        _this3.unblock();
-      }
-    });
-  };
-  _proto.markCurrentTaskAsFinished = function markCurrentTaskAsFinished(params) {
-    this.check();
-    var activeTaskIndex = this.state.activeTaskIndex;
-    var activeTask = this.tasks[activeTaskIndex];
-    if (!activeTask) return;
-    var activeTaskState = this.state.tasks[activeTask.id];
-    if (activeTaskState.status === Status.RUNNING) {
-      this.updateTaskState(activeTask.id, {
-        status: Status.SUCCESS
-      });
-      this.updateActiveTaskIndex(activeTaskIndex + 1);
-      var updatedTaskEvent = {
-        id: activeTask.id,
-        task: this.get(activeTask.id),
-        action: this.tasks.find(function (task) {
-          return task.id === activeTask.id;
-        }).action
-      };
-      this.events.onUpdate(updatedTaskEvent);
-      this.next(params);
-    }
-  }
-  /**
-   * If the active task is `RUNNING`, change it to `PENING` the try to run the task by calling `next`.
-   * If it's other than `RUNNING` we reset the queue state and run the queue from the beggining.
-   *
-   * @param params
-   * @returns
-   */;
-  _proto.resume = function resume(params) {
-    var activeTaskIndex = this.state.activeTaskIndex;
-    var activeTask = this.tasks[activeTaskIndex];
-    if (!activeTask) return;
-    var activeTaskState = this.state.tasks[activeTask.id];
-    if (activeTaskState.status === Status.RUNNING) {
-      this.updateTaskState(activeTask.id, {
-        status: Status.PENDING
-      });
-      this.next(params);
-    } else {
-      this.resetState();
-      this.next(params);
-    }
-  }
-  /**
-   *
-   * Cancel the queue by changing active task and queue status to `CANCELED`.
-   *
-   */;
-  _proto.cancel = function cancel() {
-    var currentActiveTask = this.getActiveTask();
-    if (!currentActiveTask || [Status.FAILED, Status.CANCELED, Status.SUCCESS].includes(currentActiveTask.state.status)) {
-      return;
-    }
-    var task = currentActiveTask.task;
-    // Update task status to `canceled`
-    this.updateTaskState(task.id, {
-      status: Status.CANCELED
-    });
-    var updatedTaskEvent = {
-      id: task.id,
-      task: this.get(task.id),
-      action: this.tasks.find(function (t) {
-        return t.id === task.id;
-      }).action
-    };
-    this.events.onUpdate(updatedTaskEvent);
-    // Update queue status to `canceled`
-    this.updateQueueStatus(Status.CANCELED);
-  }
-  /**
-   * Update queue status, and all the tasks inside queue to `PENDING`.
-   */;
-  _proto.resetState = function resetState() {
-    var _this4 = this;
-    this.state.activeTaskIndex = 0;
-    this.state.status = Status.PENDING;
-    Object.keys(this.state.tasks).forEach(function (id) {
-      _this4.state.tasks[id].status = Status.PENDING;
-    });
-  };
-  _proto.getStorage = function getStorage() {
-    return this.storage;
-  };
-  _proto.setStorage = function setStorage(data) {
-    this.storage = data;
-    this.events.onStorageUpdate(data);
-    return this.storage;
-  };
-  _proto.getContext = function getContext(params) {
-    return _extends({}, params.context, {
-      _queue: {
-        id: this.id
-      }
-    });
-  };
-  return Queue;
-}();
-
-var Manager = /*#__PURE__*/function () {
-  /**
-   *
-   * Making an instance, initilize events, setup a persistor and try to recover the last state of the manager.
-   *
-   * */
-  function Manager(options) {
-    var _this = this;
-    this.queuesDefs = new Map();
-    this.queues = new Map();
-    this.isPaused = false;
-    // The client won't get any update on pause, We are using a polling mode to fix this issue for now.
-    this.syncInterval = null;
-    var defaultEventHandlers = {
-      onCreateQueue: function onCreateQueue() {
-        // ...
-      },
-      onCreateTask: function onCreateTask() {
-        // ...
-      },
-      onUpdateQueue: function onUpdateQueue() {
-        // ...
-      },
-      onUpdateTask: function onUpdateTask() {
-        // ...
-      },
-      onStorageUpdate: function onStorageUpdate() {
-        // ...
-      },
-      onTaskBlock: function onTaskBlock() {
-        // ...
-      },
-      onPersistedDataLoaded: function onPersistedDataLoaded() {
-        // ..
-      }
-    };
-    if (options.events) {
-      this.events = _extends({}, defaultEventHandlers, options.events);
-    } else {
-      this.events = defaultEventHandlers;
-    }
-    options.queuesDefs.map(function (qDef) {
-      _this.queuesDefs.set(qDef.name, qDef);
-    });
-    this.context = options.context || {};
-    this.persistor = new Persistor();
-    this.sync();
-    if (options.isPaused) {
-      this.pause();
-    }
-  }
-  /**
-   *
-   * Reading persisted data from storage then brings into memory.
-   *
-   * Notes:
-   *  - Reset the memory, so we can call this method whenever we want and not only on the initialize process.
-   *  - All the events will be tirggered (like onCreateQueue, onCreateTask, onBlock, ....)
-   *  - Try to `resume` if the status is `running`.
-   *  - Trigger `onPersistedDataLoaded` event when queues recovered from storage.
-   *
-   */
-  var _proto = Manager.prototype;
-  _proto.sync =
-  /*#__PURE__*/
-  function () {
-    var _sync = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-      var _this2 = this;
-      var queues;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            _context.prev = 0;
-            _context.next = 3;
-            return this.persistor.getAll();
-          case 3:
-            queues = _context.sent;
-            // Reset queues, if anything is exist in memory.
-            this.queues = new Map();
-            // Brings them into memory
-            queues.forEach(function (q) {
-              var list = _this2.createQueue({
-                queue_id: q.id,
-                queue_name: q.name
-              });
-              _this2.add(q.id, {
-                list: list,
-                createdAt: q.createdAt,
-                name: q.name,
-                status: q.status,
-                actions: {
-                  run: function run() {
-                    list.next({
-                      context: _this2.getContext()
-                    });
-                  },
-                  cancel: function cancel() {
-                    list.cancel();
-                  },
-                  setStorage: function setStorage() {
-                    list.setStorage.apply(list, arguments);
-                  },
-                  getStorage: function getStorage() {
-                    return list.getStorage();
-                  }
-                }
-              });
-              list.initTasks({
-                state: q.state,
-                tasks: q.tasks,
-                storage: q.storage || {}
-              });
-              if (q.status === Status.RUNNING && _this2.shouldExecute()) {
-                list.resume({
-                  context: _this2.getContext()
-                });
-              }
-            });
-            _context.next = 11;
-            break;
-          case 8:
-            _context.prev = 8;
-            _context.t0 = _context["catch"](0);
-            console.log("IndexDB Error: " + _context.t0);
-          case 11:
-            // Trigger an event to let the subscribers we are done here.
-            this.events.onPersistedDataLoaded(this);
-          case 12:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee, this, [[0, 8]]);
-    }));
-    function sync() {
-      return _sync.apply(this, arguments);
-    }
-    return sync;
-  }()
-  /**
-   *
-   * Making a new instance from `Queue` and adds Manager's event handlers to it.
-   *
-   * @returns An instance of `Queue` with wrapped event handlers from Manager.
-   *
-   */
-  ;
-  _proto.createQueue = function createQueue(_ref) {
-    var _this3 = this;
-    var queue_id = _ref.queue_id,
-      queue_name = _ref.queue_name;
-    var manager = this;
-    var def = this.queuesDefs.get(queue_name);
-    var list = new Queue({
-      id: queue_id,
-      events: {
-        onCreate: function onCreate(task) {
-          var _def$events;
-          _this3.events.onCreateTask(queue_id, task);
-          _this3.handleUpdate(queue_id);
-          if ((_def$events = def.events) != null && _def$events.onCreate) def.events.onCreate(task);
-        },
-        onUpdate: function onUpdate(task) {
-          var _def$events2;
-          _this3.events.onUpdateTask(queue_id, task);
-          _this3.handleUpdate(queue_id);
-          if ((_def$events2 = def.events) != null && _def$events2.onUpdate) def.events.onUpdate(task);
-        },
-        onUpdateListStatus: function onUpdateListStatus(status) {
-          var _def$events3;
-          _this3.queues.set(queue_id, _extends({}, _this3.get(queue_id), {
-            status: status
-          }));
-          _this3.events.onUpdateQueue(queue_id, _this3.get(queue_id));
-          _this3.handleUpdate(queue_id);
-          // After finishing a queue, try to run other queues.
-          _this3.execute();
-          if ((_def$events3 = def.events) != null && _def$events3.onUpdateListStatus) def.events.onUpdateListStatus(status);
-        },
-        onStorageUpdate: function onStorageUpdate(data) {
-          var _def$events4;
-          _this3.events.onStorageUpdate(queue_id, data);
-          if ((_def$events4 = def.events) != null && _def$events4.onStorageUpdate) def.events.onStorageUpdate(data);
-          _this3.handleUpdate(queue_id);
-        },
-        onBlock: function onBlock(event) {
-          // Update queue status
-          _this3.queues.set(queue_id, _extends({}, _this3.get(queue_id), {
-            status: Status.BLOCKED
-          }));
-          // Trigger event
-          _this3.events.onTaskBlock(queue_id);
-          if (def.whenTaskBlocked) {
-            def.whenTaskBlocked(event, {
-              queue_id: queue_id,
-              queue: list,
-              context: _this3.getContext(),
-              getBlockedTasks: _this3.getBlockedTasks.bind(_this3),
-              forceExecute: _this3.forceExecute.bind(_this3),
-              retry: _this3.retry.bind(_this3),
-              manager: manager
-            });
-          }
-          // Sync
-          _this3.handleUpdate(queue_id);
-        },
-        onUnblock: function onUnblock() {
-          // Update queue status
-          _this3.queues.set(queue_id, _extends({}, _this3.get(queue_id), {
-            status: Status.PENDING
-          }));
-          // Sync
-          _this3.handleUpdate(queue_id);
-          _this3.execute();
-        }
-      },
-      actions: def.actions
-    });
-    return list;
-  }
-  /**
-   * Go through all tasks (from all queues) and return a list of blocked tasks
-   *
-   * @returns a list of blocked tasks including enough information to get the queue and mutate the storage.
-   *
-   */;
-  _proto.getBlockedTasks = function getBlockedTasks() {
-    var queues = this.getAll();
-    var blockedTasks = [];
-    queues.forEach(function (q, queue_id) {
-      q.list.tasks.forEach(function (task) {
-        var state = q.list.state.tasks[task.id];
-        if (state.status === Status.BLOCKED) {
-          blockedTasks.push({
-            task_id: task.id,
-            queue_id: queue_id,
-            action: task.action,
-            reason: state.blockedFor,
-            storage: {
-              get: function get() {
-                return q.list.getStorage();
-              },
-              set: function set(data) {
-                return q.list.setStorage(data);
-              }
-            }
-          });
-        }
-      });
-    });
-    return blockedTasks;
-  }
-  /**
-   *
-   * Add a queue to the manager to keep track of the queue and its state.
-   *
-   * @param id
-   * @param queue
-   * @returns
-   */;
-  _proto.add = function add(id, queue) {
-    this.queues.set(id, queue);
-    var createdQueue = this.get(id);
-    this.events.onCreateQueue(_extends({}, createdQueue, {
-      id: id
-    }));
-    return createdQueue;
-  }
-  // Create a new queue
-  /**
-   *
-   * Create a new queue by client.
-   *
-   * It will do the internal things to make a queue from definitions, and running using Manager.
-   *
-   * Notes:
-   *  - After creating the queue, it will be run automatically.
-   *
-   * @returns an ID for queue so it can be used to get the created queue later by client.
-   *
-   */;
-  _proto.create =
-  /*#__PURE__*/
-  function () {
-    var _create = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(name, storage, options) {
-      var _this4 = this;
-      var def, queue_id, createdAt, list, createdQueue;
-      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
-          case 0:
-            if (this.queuesDefs.has(name)) {
-              _context2.next = 2;
-              break;
-            }
-            throw new Error('You need to add a queue definition first.');
-          case 2:
-            _context2.prev = 2;
-            def = this.queuesDefs.get(name);
-            queue_id = (options == null ? void 0 : options.id) || v4();
-            createdAt = Date.now();
-            list = this.createQueue({
-              queue_id: queue_id,
-              queue_name: name
-            });
-            list.setStorage(storage);
-            createdQueue = this.add(queue_id, {
-              list: list,
-              createdAt: createdAt,
-              name: name,
-              status: Status.PENDING,
-              actions: {
-                run: function run() {
-                  list.next({
-                    context: _this4.getContext()
-                  });
-                },
-                cancel: function cancel() {
-                  list.cancel();
-                },
-                setStorage: function setStorage() {
-                  list.setStorage.apply(list, arguments);
-                },
-                getStorage: function getStorage() {
-                  return list.getStorage();
-                }
-              }
-            }); // Persist initial queue
-            // Note: we need to first insert the queue, and then it can be updated by internal events.
-            _context2.next = 11;
-            return this.persistor.insertQueue({
-              id: queue_id,
-              createdAt: createdAt,
-              name: createdQueue.name,
-              status: createdQueue.status,
-              tasks: list.tasks,
-              state: list.state,
-              storage: list.getStorage()
-            });
-          case 11:
-            // adding initial tasks
-            def.run.forEach(function (action) {
-              list.createTask(action);
-            });
-            // After creating a new queue, try to run.
-            this.execute();
-            return _context2.abrupt("return", queue_id);
-          case 16:
-            _context2.prev = 16;
-            _context2.t0 = _context2["catch"](2);
-            throw new Error(_context2.t0 == null ? void 0 : _context2.t0.message);
-          case 19:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2, this, [[2, 16]]);
-    }));
-    function create(_x, _x2, _x3) {
-      return _create.apply(this, arguments);
-    }
-    return create;
-  }()
-  /**
-   * Get a queue by its ID.
-   *
-   * @returns An object includes queue and its state in `Manager`.
-   */
-  ;
-  _proto.get = function get(queue_id) {
-    return this.queues.get(queue_id);
-  }
-  /**
-   * Get all queues from `Manager`
-   *
-   * @returns a list of queues includes all the queues and their states.
-   */;
-  _proto.getAll = function getAll() {
-    return this.queues;
-  }
-  /**
-   *
-   * Ask from manager to run pending queues.
-   *
-   * It only try to run queues with `PENDING` status and ignore all the other statuses.
-   *
-   */;
-  _proto.execute = function execute() {
-    if (!this.shouldExecute()) return;
-    for (var _i = 0, _Array$from = Array.from(this.queues); _i < _Array$from.length; _i++) {
-      var _Array$from$_i = _Array$from[_i],
-        q = _Array$from$_i[1];
-      if (q.status === Status.PENDING) {
-        q.actions.run();
-      }
-    }
-  }
-  /**
-   *
-   * Try to find queues with `RUNNING` status to run them again.
-   *
-   * It's useful for recovering the queue at some certain points
-   * like running a currepted task (reloaded when it was running) or needs manual trigger from UI.
-   *
-   * @returns
-   */;
-  _proto.resume = function resume() {
-    if (!this.shouldExecute()) return;
-    for (var _i2 = 0, _Array$from2 = Array.from(this.queues); _i2 < _Array$from2.length; _i2++) {
-      var _Array$from2$_i = _Array$from2[_i2],
-        q = _Array$from2$_i[1];
-      if (q.status === Status.RUNNING) {
-        q.list.resume({
-          context: this.getContext()
-        });
-        return;
-      }
-    }
-    // If there is no running queue, try to run a new queue.
-    this.execute();
-  }
-  /**
-   *
-   * Run all `BLOCKED` queues once again.
-   *
-   * If a queue has `BLOCKED` status and the last task is `BLOCKED` as well,
-   * The task will be run one more time.
-   *
-   * Useful for scenarios like we are blocking the queue under some conditions in task,
-   * We can use this method to ask the queue to run the blocked task one more time and
-   * maybe this time condtions are met and the queue can be proceed.
-   *
-   * @returns
-   */;
-  _proto.retry = function retry() {
-    if (!this.shouldExecute()) return;
-    for (var _i3 = 0, _Array$from3 = Array.from(this.queues); _i3 < _Array$from3.length; _i3++) {
-      var _Array$from3$_i = _Array$from3[_i3],
-        q = _Array$from3$_i[1];
-      if (q.status === Status.BLOCKED) {
-        q.list.checkBlock();
-      }
-    }
-    // If there is no running queue, try to run a new queue.
-    this.execute();
-  }
-  /**
-   *
-   * Run a blocked task on a specific queue with the ability to pass more data.
-   *
-   * Useful when we have a custom logic for running queue and needs to pass some specific data
-   * to the task and try to run it manually with the provided data.
-   *
-   */;
-  _proto.forceExecute = function forceExecute(queue_id, data) {
-    var queue = this.get(queue_id);
-    var context = this.getContext();
-    if (data) {
-      context = _extends({}, context, data);
-    }
-    queue == null ? void 0 : queue.list.forceRun({
-      context: context
-    });
-  }
-  /**
-   *
-   * Sync in-memory state (of `Manager`) with storage (persist).
-   *
-   * Usually we call this method after a change detected in the state of manager.
-   *
-   */;
-  _proto.handleUpdate = function handleUpdate(queue_id) {
-    var queue = this.get(queue_id);
-    if (queue) {
-      var status = queue.status;
-      var state = queue.list.state;
-      var tasks = queue.list.tasks;
-      this.persistor.updateQueue(queue_id, {
-        status: status,
-        state: state,
-        tasks: tasks,
-        storage: queue.list.getStorage()
-      });
-    }
-  }
-  /**
-   * Active readonly mode for manager, it means it doesn't run anythin,
-   * And only can be used to read the data.
-   */;
-  _proto.pause = function pause() {
-    var _this5 = this;
-    if (this.isPaused) return;
-    this.isPaused = true;
-    this.syncInterval = setInterval(function () {
-      _this5.sync();
-    }, SYNC_POLLING_INTERVAL);
-  }
-  /**
-   * Activate normal mode which means it will be able to run the queuese as well.
-   */;
-  _proto.run = function run() {
-    // If call this method multiple times, it should be run for once.
-    if (this.isPaused) {
-      this.isPaused = false;
-      if (!!this.syncInterval) {
-        clearInterval(this.syncInterval);
-        this.syncInterval = null;
-      }
-      this.sync();
-    }
-  };
-  _proto.getContext = function getContext() {
-    var _this$context;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    //@ts-ignore
-    return ((_this$context = this.context) == null ? void 0 : _this$context.current) || {};
-  };
-  _proto.shouldExecute = function shouldExecute() {
-    return !this.isPaused;
-  };
-  return Manager;
-}();
-
-export { DB_NAME, Manager, Persistor, SYNC_POLLING_INTERVAL, Status };
-//# sourceMappingURL=queue-manager-core.esm.js.map