@instructure/quiz-core 17.19.2-rc.4 → 17.19.3-rc.1

package/lib/common/selectors/quizzes.js

@@ -0,0 +1,146 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEditingQuizEntry = exports.getQuizEntryWithErrorsShowing = exports.isActiveQuizWorkingInstanceOneQuestionAtATime = exports.getTemporaryQuizEntry = exports.getQuizEntryById = exports.getQuizEntriesByIds = exports.getQuizEntriesByQuizId = exports.getTotalPointsPossible = exports.getQuizById = exports.getActiveQuizCaluclatorType = exports.getActiveQuizId = exports.getActiveQuiz = void 0;
+
+var _applyDecoratedDescriptor2 = _interopRequireDefault(require("@babel/runtime/helpers/applyDecoratedDescriptor"));
+
+var _immutable = require("immutable");
+
+var _quizSessions = require("./quizSessions.js");
+
+var _Quiz = _interopRequireDefault(require("../records/Quiz.js"));
+
+var _QuizEntry = _interopRequireDefault(require("../records/QuizEntry.js"));
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _withStateCache = _interopRequireDefault(require("../util/withStateCache.js"));
+
+var _reduxStore = _interopRequireDefault(require("../../reduxStore.js"));
+
+var _dec, _dec2, _obj;
+
+var path = 'quizzes';
+
+var getActiveQuiz = function getActiveQuiz(state) {
+  return getQuizById(state, getActiveQuizId(state));
+};
+
+exports.getActiveQuiz = getActiveQuiz;
+
+var getActiveQuizId = function getActiveQuizId(state) {
+  // For some reason this could be defined in one or the other of these, or neither.
+  return state.getIn([path, 'activeQuizId']) || (0, _quizSessions.getActiveQuizSession)(state) && (0, _quizSessions.getActiveQuizSession)(state).get('quiz');
+};
+
+exports.getActiveQuizId = getActiveQuizId;
+
+var getActiveQuizCaluclatorType = function getActiveQuizCaluclatorType(state) {
+  return state.getIn([path, getActiveQuizId(state), 'calculatorType']);
+};
+
+exports.getActiveQuizCaluclatorType = getActiveQuizCaluclatorType;
+
+var getQuizById = function getQuizById(state, id) {
+  return _Quiz.default.create(state.getIn([path, id]));
+};
+
+exports.getQuizById = getQuizById;
+
+var getTotalPointsPossible = function getTotalPointsPossible(state, quizId) {
+  var quizEntries = getQuizEntriesByQuizId(state, quizId);
+  return quizEntries.reduce(function (total, entry) {
+    return total + (entry.isBank ? entry.bankPointsPossible : entry.pointsPossible);
+  }, 0);
+};
+
+exports.getTotalPointsPossible = getTotalPointsPossible;
+
+var getQuizEntriesByQuizId = function getQuizEntriesByQuizId(state, quizId) {
+  var quiz = getQuizById(state, quizId);
+  return getQuizEntriesByIds(state, quiz.get('quizEntries', (0, _immutable.List)()));
+};
+
+exports.getQuizEntriesByQuizId = getQuizEntriesByQuizId;
+
+var getQuizEntriesByIds = function getQuizEntriesByIds(state) {
+  var ids = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  return ids.reduce(function (list, id) {
+    var quizEntry = getQuizEntryById(state, id);
+    return quizEntry ? list.push(quizEntry) : list;
+  }, (0, _immutable.List)());
+};
+
+exports.getQuizEntriesByIds = getQuizEntriesByIds;
+
+var getQuizEntryById = function getQuizEntryById(state, id) {
+  if (id === _quizCommon.TEMPORARY_QUIZ_ENTRY_ID) {
+    return getTemporaryQuizEntry(state);
+  }
+
+  return _QuizEntry.default.create(state.getIn(['quizEntries', id]));
+};
+
+exports.getQuizEntryById = getQuizEntryById;
+
+var getTemporaryQuizEntry = function getTemporaryQuizEntry(state) {
+  var temporaryQuizEntryData = state.getIn(['modifications', 'quizEntries', _quizCommon.TEMPORARY_QUIZ_ENTRY_ID], (0, _immutable.Map)({
+    entry: _quizCommon.TEMPORARY_ITEM_ID
+  }));
+  return _QuizEntry.default.create(temporaryQuizEntryData);
+};
+
+exports.getTemporaryQuizEntry = getTemporaryQuizEntry;
+
+var isActiveQuizWorkingInstanceOneQuestionAtATime = function isActiveQuizWorkingInstanceOneQuestionAtATime(state) {
+  return getActiveQuiz(state).getWorkingInstance().isOneQuestionAtATime();
+};
+
+exports.isActiveQuizWorkingInstanceOneQuestionAtATime = isActiveQuizWorkingInstanceOneQuestionAtATime;
+var cacheHelper = (_dec = (0, _withStateCache.default)(function () {
+  return [['quizEntries'], ['modifications', 'quizEntries'], ['modifications', 'items'], ['modifications', 'stimuli'], ['editing']];
+}), _dec2 = (0, _withStateCache.default)(function () {
+  return [['editing']];
+}), (_obj = {
+  // This is needed for withStateCache to work properly :-/
+  state: function state() {
+    return _reduxStore.default.getAppState();
+  },
+  __isShowingErrors: function __isShowingErrors(state, quizEntry) {
+    var isInvalid = !quizEntry.getEntry().getWorkingInstance().isValid();
+    var isEditing = state.getIn(['editing', "".concat(quizEntry.id, "_").concat(_quizCommon.QUIZ_ENTRY_GUID_SUFFIX)]);
+    return isInvalid && isEditing;
+  },
+  quizEntryWithErrorsShowing: function quizEntryWithErrorsShowing(state) {
+    var _this = this;
+
+    var qeWithErrors = state.get('quizEntries').find(function (qe) {
+      return _this.__isShowingErrors(state, _QuizEntry.default.create(qe));
+    });
+
+    if (qeWithErrors) {
+      return qeWithErrors;
+    }
+
+    var temp = getTemporaryQuizEntry(state);
+
+    if (this.__isShowingErrors(state, temp)) {
+      return temp;
+    }
+  },
+  editingQuizEntry: function editingQuizEntry(state) {
+    return state.get('editing', []).find(function (isEditing, key) {
+      return isEditing && key.includes(_quizCommon.QUIZ_ENTRY_GUID_SUFFIX);
+    });
+  }
+}, ((0, _applyDecoratedDescriptor2.default)(_obj, "quizEntryWithErrorsShowing", [_dec], Object.getOwnPropertyDescriptor(_obj, "quizEntryWithErrorsShowing"), _obj), (0, _applyDecoratedDescriptor2.default)(_obj, "editingQuizEntry", [_dec2], Object.getOwnPropertyDescriptor(_obj, "editingQuizEntry"), _obj)), _obj)); // This is a hack to continue using withStateCache until we implement reselect
+
+var getQuizEntryWithErrorsShowing = cacheHelper.quizEntryWithErrorsShowing.bind(cacheHelper);
+exports.getQuizEntryWithErrorsShowing = getQuizEntryWithErrorsShowing;
+var isEditingQuizEntry = cacheHelper.editingQuizEntry.bind(cacheHelper);
+exports.isEditingQuizEntry = isEditingQuizEntry;

package/lib/common/selectors/reporting.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getItemAnalysesByIds = void 0;
+
+var _immutable = require("immutable");
+
+var _ItemAnalysis = _interopRequireDefault(require("../records/ItemAnalysis.js"));
+
+var getItemAnalysisById = function getItemAnalysisById(state, id) {
+  return new _ItemAnalysis.default(state.getIn(['reporting', 'item_analysis', id]));
+};
+
+var getItemAnalysesByIds = function getItemAnalysesByIds(state) {
+  var ids = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  return ids.reduce(function (list, id) {
+    var itemAnalysis = getItemAnalysisById(state, id);
+    return itemAnalysis ? list.push(itemAnalysis) : list;
+  }, (0, _immutable.List)());
+};
+
+exports.getItemAnalysesByIds = getItemAnalysesByIds;

package/lib/common/selectors/sessionItemResults.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSessionItemResultsByIds = getSessionItemResultsByIds;
+exports.getSessionItemResultById = getSessionItemResultById;
+exports.getGradingSessionItemResults = void 0;
+
+var _applyDecoratedDescriptor2 = _interopRequireDefault(require("@babel/runtime/helpers/applyDecoratedDescriptor"));
+
+var _immutable = require("immutable");
+
+var _SessionItemResult = _interopRequireDefault(require("../records/SessionItemResult.js"));
+
+var _withCachedArguments = _interopRequireDefault(require("../util/withCachedArguments.js"));
+
+var _obj;
+
+function getSessionItemResultsByIds(state) {
+  var ids = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  return ids.reduce(function (list, id) {
+    var sessionItem = getSessionItemResultById(state, id);
+    return sessionItem ? list.push(sessionItem) : list;
+  }, (0, _immutable.List)());
+}
+
+function getSessionItemResultById(state, id) {
+  return _SessionItemResult.default.create(state.getIn(['sessionItemResults', "".concat(id)]));
+}
+
+var cacheHelper = (_obj = {
+  gradingSessionItemResults: function gradingSessionItemResults(sessionItemResults, scope) {
+    return sessionItemResults.toList().filter(scope);
+  }
+}, ((0, _applyDecoratedDescriptor2.default)(_obj, "gradingSessionItemResults", [_withCachedArguments.default], Object.getOwnPropertyDescriptor(_obj, "gradingSessionItemResults"), _obj)), _obj); // This is a hack to continue using withCachedArguments until we implement reselect
+
+var getGradingSessionItemResults = cacheHelper.gradingSessionItemResults.bind(cacheHelper);
+exports.getGradingSessionItemResults = getGradingSessionItemResults;

package/lib/common/selectors/sessionItems.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getItemByPosition = getItemByPosition;
+exports.getSessionItemsByIds = getSessionItemsByIds;
+exports.getSessionItemById = getSessionItemById;
+exports.getGradingSessionItems = void 0;
+
+var _applyDecoratedDescriptor2 = _interopRequireDefault(require("@babel/runtime/helpers/applyDecoratedDescriptor"));
+
+var _SessionItem = _interopRequireDefault(require("../records/SessionItem.js"));
+
+var _immutable = require("immutable");
+
+var _withCachedArguments = _interopRequireDefault(require("../util/withCachedArguments.js"));
+
+var _obj;
+
+function getItemByPosition(state, position) {
+  var activeSessionId = state.getIn(['quizSessions', 'activeQuizSessionId']);
+  return state.get('sessionItems').find(function (item) {
+    return item.get('quizSessionId') === activeSessionId && item.get('position') === position;
+  }) || null;
+}
+
+function getSessionItemsByIds(state) {
+  var ids = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  return ids.reduce(function (list, id) {
+    var sessionItem = getSessionItemById(state, id);
+    return sessionItem ? list.push(sessionItem) : list;
+  }, (0, _immutable.List)());
+}
+
+function getSessionItemById(state, id) {
+  return _SessionItem.default.create(state.getIn(['sessionItems', id]));
+}
+
+var cacheHelper = (_obj = {
+  gradingSessionItems: function gradingSessionItems(sessionItems, scope) {
+    return sessionItems.filter(scope).map(function (si) {
+      return _SessionItem.default.create(si);
+    }).sortBy(function (si) {
+      return si.position;
+    }).toList();
+  }
+}, ((0, _applyDecoratedDescriptor2.default)(_obj, "gradingSessionItems", [_withCachedArguments.default], Object.getOwnPropertyDescriptor(_obj, "gradingSessionItems"), _obj)), _obj); // This is a hack to continue using withCachedArguments until we implement reselect
+
+var getGradingSessionItems = cacheHelper.gradingSessionItems.bind(cacheHelper);
+exports.getGradingSessionItems = getGradingSessionItems;

package/lib/common/selectors/taking.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isTimeUp = isTimeUp;
+exports.getResponsesByIds = getResponsesByIds;
+exports.getResponseById = getResponseById;
+exports.getResponseDataByPosition = getResponseDataByPosition;
+exports.getIsTaking = exports.getTimerData = exports.getBrowserSessionId = exports.getCurrentSessionItemPosition = void 0;
+
+var _immutable = require("immutable");
+
+var _Response = _interopRequireDefault(require("../records/Response.js"));
+
+var path = 'taking';
+
+var getCurrentSessionItemPosition = function getCurrentSessionItemPosition(state) {
+  return state.getIn([path, 'currentSessionItemPosition'], 1);
+};
+
+exports.getCurrentSessionItemPosition = getCurrentSessionItemPosition;
+
+var getBrowserSessionId = function getBrowserSessionId(state) {
+  return state.getIn([path, 'browserSessionId']);
+};
+
+exports.getBrowserSessionId = getBrowserSessionId;
+
+var getTimerData = function getTimerData(state) {
+  return state.getIn([path, 'timerData'], (0, _immutable.Map)());
+};
+
+exports.getTimerData = getTimerData;
+
+var getIsTaking = function getIsTaking(state) {
+  return state.getIn([path, 'isTaking']);
+};
+
+exports.getIsTaking = getIsTaking;
+
+function isTimeUp(state) {
+  var timerRunning = state.getIn([path, 'timerData', 'timerRunning']);
+  var noTimeLeft = state.getIn([path, 'timerData', 'timeLeftInSeconds']) <= 0;
+  return noTimeLeft && timerRunning;
+}
+
+function getResponsesByIds(state) {
+  var ids = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  return ids.reduce(function (list, id) {
+    var response = getResponseById(state, id);
+    return response ? list.push(response) : list;
+  }, (0, _immutable.List)());
+}
+
+function getResponseById(state, id) {
+  return _Response.default.create(state.getIn([path, 'responses', id]));
+}
+
+function getResponseDataByPosition(state, position) {
+  return state.getIn([path, 'responses', position]);
+}

package/lib/common/selectors/ui.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getActiveCalculatorId = void 0;
+
+var getActiveCalculatorId = function getActiveCalculatorId(state) {
+  return state.getIn(['ui', 'activeCalculatorId'], null);
+};
+
+exports.getActiveCalculatorId = getActiveCalculatorId;

package/lib/common/util/CustomPropTypes.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requireable = requireable;
+exports.default = exports.CustomPropTypes = void 0;
+
+var _propTypes = require("prop-types");
+
+var selectors = _propTypes.PropTypes.oneOfType([_propTypes.PropTypes.string, _propTypes.PropTypes.arrayOf(_propTypes.PropTypes.string)]);
+
+var attemptHistory = _propTypes.PropTypes.arrayOf(_propTypes.PropTypes.shape({
+  authoritative: _propTypes.PropTypes.bool.isRequired,
+  displayName: _propTypes.PropTypes.string,
+  percentage: _propTypes.PropTypes.number,
+  pointsPossible: _propTypes.PropTypes.number,
+  score: _propTypes.PropTypes.number,
+  quizSessionId: _propTypes.PropTypes.string
+}));
+
+function numberInRange(start, end) {
+  return function (props, propName, componentName, location) {
+    var error = _propTypes.PropTypes.number.apply(null, arguments);
+
+    if (error) return error;
+    var value = props[propName];
+
+    if (value != null && value < start || value > end) {
+      return new Error("Invalid ".concat(location, " `").concat(propName, "` supplied to `").concat(componentName, "`, ") + "must be between ".concat(start, " and ").concat(end));
+    }
+  };
+}
+
+function higherOrderFunctionValidator(props, propName, componentName, location) {
+  var propValue = props[propName];
+  var propValueType = typeof propValue;
+
+  if (propValueType !== 'function') {
+    return new Error("Invalid ".concat(location, " `").concat(propName, "` of type `").concat(propValueType, "` ") + "supplied to `".concat(componentName, "`, expected a higher order function"));
+  }
+
+  var returnValue = propValue();
+  var returnValueType = typeof returnValue;
+
+  if (returnValueType !== 'function') {
+    return new Error("Invalid ".concat(location, " `").concat(propName, "` supplied to `").concat(componentName, "`, ") + "the prop function returned a type of ".concat(returnValueType, ", expected a function"));
+  }
+}
+
+function requireable(func) {
+  function required(isRequired, props, propName, componentName, location) {
+    if (props[propName] != null) {
+      return func(props, propName, componentName, location);
+    }
+
+    if (isRequired) {
+      return new Error("Required ".concat(location, " `").concat(propName, "` was not supplied to ").concat(componentName));
+    }
+  }
+
+  var requireableFunc = required.bind(null, false);
+  requireableFunc.isRequired = required.bind(null, true);
+  return requireableFunc;
+}
+
+var higherOrderFunction = requireable(higherOrderFunctionValidator);
+
+function recordId(props, propName, componentName, location) {
+  var error = _propTypes.PropTypes.string.apply(null, arguments);
+
+  if (error) return error;
+
+  if (!/^[1-9]\d*$/.test(props[propName])) {
+    return new Error("Invalid ".concat(location, " `").concat(propName, "` supplied to `").concat(componentName, "`, must be a positive integer."));
+  }
+}
+
+var CustomPropTypes = {
+  attemptHistory: attemptHistory,
+  higherOrderFunction: higherOrderFunction,
+  numberInRange: numberInRange,
+  recordId: recordId,
+  selectors: selectors
+};
+exports.CustomPropTypes = CustomPropTypes;
+var _default = CustomPropTypes;
+exports.default = _default;

package/lib/common/util/ElementsForSelectors.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.elementsForSelectors = elementsForSelectors;
+exports.default = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+function elementsForSelectors(appContainer) {
+  var selectors = Array.isArray(appContainer) ? appContainer : [appContainer];
+  var elements = selectors.reduce(function (acc, selector) {
+    return [].concat((0, _toConsumableArray2.default)(acc), (0, _toConsumableArray2.default)(document.querySelectorAll(selector)));
+  }, []);
+  return elements;
+}
+
+var _default = elementsForSelectors;
+exports.default = _default;

package/lib/common/util/ExhaustivePaginatedFetcher.js

@@ -0,0 +1,127 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+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 _get3 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _Fetcher = _interopRequireDefault(require("./Fetcher.js"));
+
+// Always call this with `new` to make the abstraction over the inner class
+// transparent to module consumers
+var ExhaustivePaginatedFetcher = function ExhaustivePaginatedFetcher() {
+  var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+
+  var _ref$SuperClass = _ref.SuperClass,
+      SuperClass = _ref$SuperClass === void 0 ? _Fetcher.default : _ref$SuperClass,
+      args = (0, _objectWithoutProperties2.default)(_ref, ["SuperClass"]);
+
+  var ExhaustivePaginatedFetcher = /*#__PURE__*/function (_SuperClass) {
+    (0, _inherits2.default)(ExhaustivePaginatedFetcher, _SuperClass);
+
+    var _super = (0, _createSuper2.default)(ExhaustivePaginatedFetcher);
+
+    function ExhaustivePaginatedFetcher() {
+      (0, _classCallCheck2.default)(this, ExhaustivePaginatedFetcher);
+      return _super.apply(this, arguments);
+    }
+
+    (0, _createClass2.default)(ExhaustivePaginatedFetcher, [{
+      key: "combinePages",
+      value: function combinePages(pages) {
+        return pages.reduce(function (accumulator, page) {
+          return [].concat((0, _toConsumableArray2.default)(accumulator), (0, _toConsumableArray2.default)(page));
+        }, []);
+      }
+    }, {
+      key: "get",
+      value: function () {
+        var _get2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(url) {
+          var _this = this;
+
+          var additionalParams,
+              params,
+              totalItems,
+              itemsPerPage,
+              _args = arguments;
+          return _regenerator.default.wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  additionalParams = _args.length > 1 && _args[1] !== void 0 ? _args[1] : {};
+                  params = {
+                    method: 'GET',
+                    headers: (0, _get3.default)((0, _getPrototypeOf2.default)(ExhaustivePaginatedFetcher.prototype), "callHeaders", this).call(this)
+                  };
+                  return _context.abrupt("return", (0, _get3.default)((0, _getPrototypeOf2.default)(ExhaustivePaginatedFetcher.prototype), "fetch", this).call(this, (0, _get3.default)((0, _getPrototypeOf2.default)(ExhaustivePaginatedFetcher.prototype), "appendQueryParams", this).call(this, url, additionalParams), params).then(function (response) {
+                    // analyze properties of the first page response
+                    // before getting its json body
+                    totalItems = parseInt(response.headers.get('total'), 10);
+                    itemsPerPage = parseInt(response.headers.get('per-page'), 10);
+                    return response.json();
+                  }).then(function (initial) {
+                    if (totalItems > itemsPerPage) {
+                      // create an array of page numbers, and use it to generate an array of
+                      // get calls to the same url, but with different page numbers
+                      var pageCount = Math.ceil(totalItems / itemsPerPage) - 1;
+                      var pages = (0, _toConsumableArray2.default)(Array(pageCount).keys()).map(function (p) {
+                        return (0, _get3.default)((0, _getPrototypeOf2.default)(ExhaustivePaginatedFetcher.prototype), "get", _this).call(_this, url, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, additionalParams), {}, {
+                          page: p + 2,
+                          per_page: itemsPerPage
+                        }));
+                      });
+                      return Promise.all(pages).then(function (pageResponses) {
+                        return [].concat((0, _toConsumableArray2.default)(initial), (0, _toConsumableArray2.default)(_this.combinePages(pageResponses)));
+                      });
+                    } else {
+                      return initial;
+                    }
+                  }));
+
+                case 3:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee, this);
+        }));
+
+        function get(_x) {
+          return _get2.apply(this, arguments);
+        }
+
+        return get;
+      }()
+    }]);
+    return ExhaustivePaginatedFetcher;
+  }(SuperClass);
+
+  return new ExhaustivePaginatedFetcher(args);
+};
+
+var _default = ExhaustivePaginatedFetcher;
+exports.default = _default;