@studyportals/sp-hs-misc/bin-browser/src/utils/throttleable.class.js

Miscellaneous code used in HouseStark's projects

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
    function adopt(value) {
        return value instanceof P ? value : new P(function (resolve) {
            resolve(value);
        });
    }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) {
            try {
                step(generator.next(value));
            } catch (e) {
                reject(e);
            }
        }
        function rejected(value) {
            try {
                step(generator["throw"](value));
            } catch (e) {
                reject(e);
            }
        }
        function step(result) {
            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
/**
 * Aggregates an action whose execution can be deffered and offers the
 * necessary functionality to notify observers when the action had been
 * executed, providing the outcome.
 */

//# sourceMappingURL=throttleable.class.js.map
var Throttleable = function () {
    _createClass(Throttleable, [{
        key: "actionFn",
        get: function get() {
            return this._actionFn;
        }
    }, {
        key: "observers",
        get: function get() {
            return this._observers;
        }
    }, {
        key: "result",
        get: function get() {
            return this._result;
        }
    }, {
        key: "error",
        get: function get() {
            return this._error;
        }
    }, {
        key: "executed",
        get: function get() {
            return this._executed;
        }
    }]);

    function Throttleable(actionFn) {
        _classCallCheck(this, Throttleable);

        this._observers = [];
        this._actionFn = actionFn;
        this._result = null;
        this._error = null;
        this._executed = false;
    }

    _createClass(Throttleable, [{
        key: "execute",
        value: function execute() {
            return __awaiter(this, void 0, void 0, /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
                return regeneratorRuntime.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                _context.next = 2;
                                return this.executeActionAndSetOutcome();

                            case 2:
                                this.setExecutedFlag();
                                this.notifyObservers();

                            case 4:
                            case "end":
                                return _context.stop();
                        }
                    }
                }, _callee, this);
            }));
        }
    }, {
        key: "observe",
        value: function observe(observerFn) {
            if (this.executed) {
                this.notifyObserver(observerFn);
            } else {
                this.addObserver(observerFn);
            }
        }
    }, {
        key: "createObservingPromise",
        value: function createObservingPromise() {
            var _this = this;

            return new Promise(function (resolve, reject) {
                _this.observe(function (err, res) {
                    return err ? reject(err) : resolve(res);
                });
            });
        }
    }, {
        key: "notifyObservers",
        value: function notifyObservers() {
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = this.observers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var observer = _step.value;

                    this.notifyObserver(observer);
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
        }
    }, {
        key: "notifyObserver",
        value: function notifyObserver(observer) {
            observer(this.error, this.result);
        }
    }, {
        key: "addObserver",
        value: function addObserver(observer) {
            this.observers.push(observer);
        }
    }, {
        key: "executeActionAndSetOutcome",
        value: function executeActionAndSetOutcome() {
            return __awaiter(this, void 0, void 0, /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
                return regeneratorRuntime.wrap(function _callee2$(_context2) {
                    while (1) {
                        switch (_context2.prev = _context2.next) {
                            case 0:
                                _context2.prev = 0;
                                _context2.next = 3;
                                return this.actionFn();

                            case 3:
                                this._result = _context2.sent;
                                _context2.next = 9;
                                break;

                            case 6:
                                _context2.prev = 6;
                                _context2.t0 = _context2["catch"](0);

                                this._error = _context2.t0;

                            case 9:
                            case "end":
                                return _context2.stop();
                        }
                    }
                }, _callee2, this, [[0, 6]]);
            }));
        }
    }, {
        key: "setExecutedFlag",
        value: function setExecutedFlag() {
            this._executed = true;
        }
    }]);

    return Throttleable;
}();