@instructure/quiz-core 20.17.3-rc.6 → 20.17.3-rc.8

package/es/common/selectors/interactionTypes.js

@@ -1,12 +1,14 @@
 import _applyDecoratedDescriptor from "@babel/runtime/helpers/esm/applyDecoratedDescriptor";
+
 var _dec, _obj;
+
 // TODO: Use more reselect! Create a getInteractionTypes selector that can be used for reselecting interaction types by
 // id(s)
 import { Map } from 'immutable';
-import interactionTypeRecordForItem from '../util/interactionTypeRecordForItem';
-import withStateCache from '../util/withStateCache';
-import reduxStore from '../../reduxStore';
-import { featureOn } from '../util/featureCheck';
+import interactionTypeRecordForItem from "../util/interactionTypeRecordForItem.js";
+import withStateCache from "../util/withStateCache.js";
+import reduxStore from "../../reduxStore.js";
+import { featureOn } from "../util/featureCheck.js";
 export var getInteractionType = function getInteractionType(state, id) {
   var interactionTypeData = state.getIn(['interactionTypes', id]) || Map();
   var slug = interactionTypeData.get('slug');
@@ -15,7 +17,7 @@ export var getInteractionType = function getInteractionType(state, id) {
 };
 var cacheHelper = (_dec = withStateCache(function () {
   return [['interactionTypes']];
-}), _obj = {
+}), (_obj = {
   // This is needed for withStateCache to work properly :-/
   state: function state() {
     return reduxStore.getAppState();
@@ -27,7 +29,6 @@ var cacheHelper = (_dec = withStateCache(function () {
       return getInteractionType(state, intTypeData.get('id'));
     }).valueSeq().toList();
   }
-}, _applyDecoratedDescriptor(_obj, "interactionTypes", [_dec], Object.getOwnPropertyDescriptor(_obj, "interactionTypes"), _obj), _obj);
+}, (_applyDecoratedDescriptor(_obj, "interactionTypes", [_dec], Object.getOwnPropertyDescriptor(_obj, "interactionTypes"), _obj)), _obj)); // This is a hack to continue using withStateCache until we implement reselect
 
-// This is a hack to continue using withStateCache until we implement reselect
 export var getInteractionTypes = cacheHelper.interactionTypes.bind(cacheHelper);

package/es/common/selectors/items.js

@@ -1,10 +1,11 @@
 import { Map } from 'immutable';
 import { TEMPORARY_ITEM_ID } from '@instructure/quiz-common';
-import Item from '../records/Item';
+import Item from "../records/Item.js";
 export function getItemById(state, id) {
   if (id === TEMPORARY_ITEM_ID) {
     return getTemporaryItem(state);
   }
+
   return Item.create(state.getIn(['items', id]));
 }
 export function getTemporaryItem(state) {

package/es/common/selectors/qtiImports.js

@@ -1,17 +1,20 @@
-import QtiImport from '../records/QtiImport';
+import QtiImport from "../records/QtiImport.js";
 import { Map } from 'immutable';
+
 var getQtiImports = function getQtiImports(state) {
   return state.get('qtiImports', Map());
 };
+
 var getQtiImportById = function getQtiImportById(state, id) {
   return QtiImport.create(state.getIn(['qtiImports', id]));
 };
+
 export var getLatestQtiImportForParentWithType = function getLatestQtiImportForParentWithType(state, parentId, parentType) {
   var allImports = getQtiImports(state);
   var importsForType = allImports.valueSeq().filter(function (qtiImport) {
     return qtiImport.get('parentId') === parentId && qtiImport.get('parentType') === parentType;
-  });
-  // ids are strings, so we need to parse them below for maxBy to work properly
+  }); // ids are strings, so we need to parse them below for maxBy to work properly
+
   var latestImport = importsForType.maxBy(function (i) {
     return parseInt(i.get('id'));
   });

package/es/common/selectors/quizSessionResults.js

@@ -1,5 +1,5 @@
 import { List } from 'immutable';
-import QuizSessionResult from '../records/QuizSessionResult';
+import QuizSessionResult from "../records/QuizSessionResult.js";
 export function getQuizSessionResultsByIds(state) {
   var ids = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
   return ids.reduce(function (list, id) {

package/es/common/selectors/quizSessions.js

@@ -1,6 +1,6 @@
 // TODO: Use more reselect! Create a getQuizSessions selector that can be used for reselecting quiz sessions by id
 import { createSelector } from 'reselect';
-import QuizSession from '../records/QuizSession';
+import QuizSession from "../records/QuizSession.js";
 import { List } from 'immutable';
 var path = 'quizSessions';
 export var getActiveQuizSession = function getActiveQuizSession(state) {
@@ -18,9 +18,8 @@ export var getQuizSessionsByIds = function getQuizSessionsByIds(state) {
     var quizSession = getQuizSessionById(state, id);
     return quizSession ? list.push(quizSession) : list;
   }, List());
-};
+}; // Reselect Selectors
 
-// Reselect Selectors
 export var getBacktrackingIsAllowed = createSelector(getActiveQuizSession, function (activeSession) {
   return activeSession && activeSession.get('allowBacktracking');
 });

package/es/common/selectors/quizzes.js

@@ -1,13 +1,15 @@
 import _applyDecoratedDescriptor from "@babel/runtime/helpers/esm/applyDecoratedDescriptor";
+
 var _dec, _dec2, _obj;
+
 // TODO: Use reselect! Create a getQuizzes selector that can be used for reselecting quizzes by id
 import { Map, List } from 'immutable';
-import { getActiveQuizSession } from './quizSessions';
-import Quiz from '../records/Quiz';
-import QuizEntry from '../records/QuizEntry';
+import { getActiveQuizSession } from "./quizSessions.js";
+import Quiz from "../records/Quiz.js";
+import QuizEntry from "../records/QuizEntry.js";
 import { QUIZ_ENTRY_GUID_SUFFIX, TEMPORARY_ITEM_ID, TEMPORARY_QUIZ_ENTRY_ID } from '@instructure/quiz-common';
-import withStateCache from '../util/withStateCache';
-import reduxStore from '../../reduxStore';
+import withStateCache from "../util/withStateCache.js";
+import reduxStore from "../../reduxStore.js";
 var path = 'quizzes';
 export var getActiveQuiz = function getActiveQuiz(state) {
   return getQuizById(state, getActiveQuizId(state));
@@ -43,6 +45,7 @@ export var getQuizEntryById = function getQuizEntryById(state, id) {
   if (id === TEMPORARY_QUIZ_ENTRY_ID) {
     return getTemporaryQuizEntry(state);
   }
+
   return QuizEntry.create(state.getIn(['quizEntries', id]));
 };
 export var getTemporaryQuizEntry = function getTemporaryQuizEntry(state) {
@@ -58,7 +61,7 @@ var cacheHelper = (_dec = withStateCache(function () {
   return [['quizEntries'], ['modifications', 'quizEntries'], ['modifications', 'items'], ['modifications', 'stimuli'], ['editing']];
 }), _dec2 = withStateCache(function () {
   return [['editing']];
-}), _obj = {
+}), (_obj = {
   // This is needed for withStateCache to work properly :-/
   state: function state() {
     return reduxStore.getAppState();
@@ -70,13 +73,17 @@ var cacheHelper = (_dec = withStateCache(function () {
   },
   quizEntryWithErrorsShowing: function quizEntryWithErrorsShowing(state) {
     var _this = this;
+
     var qeWithErrors = state.get('quizEntries').find(function (qe) {
       return _this.__isShowingErrors(state, QuizEntry.create(qe));
     });
+
     if (qeWithErrors) {
       return qeWithErrors;
     }
+
     var temp = getTemporaryQuizEntry(state);
+
     if (this.__isShowingErrors(state, temp)) {
       return temp;
     }
@@ -86,8 +93,7 @@ var cacheHelper = (_dec = withStateCache(function () {
       return isEditing && key.includes(QUIZ_ENTRY_GUID_SUFFIX);
     });
   }
-}, _applyDecoratedDescriptor(_obj, "quizEntryWithErrorsShowing", [_dec], Object.getOwnPropertyDescriptor(_obj, "quizEntryWithErrorsShowing"), _obj), _applyDecoratedDescriptor(_obj, "editingQuizEntry", [_dec2], Object.getOwnPropertyDescriptor(_obj, "editingQuizEntry"), _obj), _obj);
+}, (_applyDecoratedDescriptor(_obj, "quizEntryWithErrorsShowing", [_dec], Object.getOwnPropertyDescriptor(_obj, "quizEntryWithErrorsShowing"), _obj), _applyDecoratedDescriptor(_obj, "editingQuizEntry", [_dec2], Object.getOwnPropertyDescriptor(_obj, "editingQuizEntry"), _obj)), _obj)); // This is a hack to continue using withStateCache until we implement reselect
 
-// This is a hack to continue using withStateCache until we implement reselect
 export var getQuizEntryWithErrorsShowing = cacheHelper.quizEntryWithErrorsShowing.bind(cacheHelper);
 export var isEditingQuizEntry = cacheHelper.editingQuizEntry.bind(cacheHelper);

package/es/common/selectors/reporting.js

@@ -1,8 +1,10 @@
 import { List } from 'immutable';
-import ItemAnalysis from '../records/ItemAnalysis';
+import ItemAnalysis from "../records/ItemAnalysis.js";
+
 var getItemAnalysisById = function getItemAnalysisById(state, id) {
   return new ItemAnalysis(state.getIn(['reporting', 'item_analysis', id]));
 };
+
 export var getItemAnalysesByIds = function getItemAnalysesByIds(state) {
   var ids = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
   return ids.reduce(function (list, id) {

package/es/common/selectors/sessionItemResults.js

@@ -1,8 +1,10 @@
 import _applyDecoratedDescriptor from "@babel/runtime/helpers/esm/applyDecoratedDescriptor";
+
 var _obj;
+
 import { List } from 'immutable';
-import SessionItemResult from '../records/SessionItemResult';
-import withCachedArguments from '../util/withCachedArguments';
+import SessionItemResult from "../records/SessionItemResult.js";
+import withCachedArguments from "../util/withCachedArguments.js";
 export function getSessionItemResultsByIds(state) {
   var ids = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
   return ids.reduce(function (list, id) {
@@ -17,7 +19,6 @@ var cacheHelper = (_obj = {
   gradingSessionItemResults: function gradingSessionItemResults(sessionItemResults, scope) {
     return sessionItemResults.toList().filter(scope);
   }
-}, _applyDecoratedDescriptor(_obj, "gradingSessionItemResults", [withCachedArguments], Object.getOwnPropertyDescriptor(_obj, "gradingSessionItemResults"), _obj), _obj);
+}, (_applyDecoratedDescriptor(_obj, "gradingSessionItemResults", [withCachedArguments], Object.getOwnPropertyDescriptor(_obj, "gradingSessionItemResults"), _obj)), _obj); // This is a hack to continue using withCachedArguments until we implement reselect
 
-// This is a hack to continue using withCachedArguments until we implement reselect
 export var getGradingSessionItemResults = cacheHelper.gradingSessionItemResults.bind(cacheHelper);

package/es/common/selectors/sessionItems.js

@@ -1,8 +1,10 @@
 import _applyDecoratedDescriptor from "@babel/runtime/helpers/esm/applyDecoratedDescriptor";
+
 var _obj;
-import SessionItem from '../records/SessionItem';
+
+import SessionItem from "../records/SessionItem.js";
 import { List } from 'immutable';
-import withCachedArguments from '../util/withCachedArguments';
+import withCachedArguments from "../util/withCachedArguments.js";
 export function getItemByPosition(state, position) {
   var activeSessionId = state.getIn(['quizSessions', 'activeQuizSessionId']);
   return state.get('sessionItems').find(function (item) {
@@ -27,7 +29,6 @@ var cacheHelper = (_obj = {
       return si.position;
     }).toList();
   }
-}, _applyDecoratedDescriptor(_obj, "gradingSessionItems", [withCachedArguments], Object.getOwnPropertyDescriptor(_obj, "gradingSessionItems"), _obj), _obj);
+}, (_applyDecoratedDescriptor(_obj, "gradingSessionItems", [withCachedArguments], Object.getOwnPropertyDescriptor(_obj, "gradingSessionItems"), _obj)), _obj); // This is a hack to continue using withCachedArguments until we implement reselect
 
-// This is a hack to continue using withCachedArguments until we implement reselect
 export var getGradingSessionItems = cacheHelper.gradingSessionItems.bind(cacheHelper);

package/es/common/selectors/taking.js

@@ -1,5 +1,5 @@
 import { List, Map } from 'immutable';
-import Response from '../records/Response';
+import Response from "../records/Response.js";
 var path = 'taking';
 export var getCurrentSessionItemPosition = function getCurrentSessionItemPosition(state) {
   return state.getIn([path, 'currentSessionItemPosition'], 1);

package/es/common/util/CustomPropTypes.js

@@ -8,49 +8,61 @@ var attemptHistory = PropTypes.arrayOf(PropTypes.shape({
   score: PropTypes.number,
   quizSessionId: PropTypes.string
 }));
+
 function numberInRange(start, end) {
   return function (props, propName, componentName, location) {
     var error = 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"));
   }
 }
+
 export 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.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."));
   }
 }
+
 export var CustomPropTypes = {
   attemptHistory: attemptHistory,
   higherOrderFunction: higherOrderFunction,

package/es/common/util/ExhaustivePaginatedFetcher.js

@@ -1,30 +1,36 @@
-import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _callSuper from "@babel/runtime/helpers/esm/callSuper";
-import _superPropGet from "@babel/runtime/helpers/esm/superPropGet";
+import _get from "@babel/runtime/helpers/esm/get";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-var _excluded = ["SuperClass"];
-import Fetcher from './Fetcher';
-
-// Always call this with `new` to make the abstraction over the inner class
+import Fetcher from "./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] : {},
-    _ref$SuperClass = _ref.SuperClass,
-    SuperClass = _ref$SuperClass === void 0 ? Fetcher : _ref$SuperClass,
-    args = _objectWithoutProperties(_ref, _excluded);
+  var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+
+  var _ref$SuperClass = _ref.SuperClass,
+      SuperClass = _ref$SuperClass === void 0 ? Fetcher : _ref$SuperClass,
+      args = _objectWithoutProperties(_ref, ["SuperClass"]);
+
   var ExhaustivePaginatedFetcher = /*#__PURE__*/function (_SuperClass) {
+    _inherits(ExhaustivePaginatedFetcher, _SuperClass);
+
+    var _super = _createSuper(ExhaustivePaginatedFetcher);
+
     function ExhaustivePaginatedFetcher() {
       _classCallCheck(this, ExhaustivePaginatedFetcher);
-      return _callSuper(this, ExhaustivePaginatedFetcher, arguments);
+
+      return _super.apply(this, arguments);
     }
-    _inherits(ExhaustivePaginatedFetcher, _SuperClass);
-    return _createClass(ExhaustivePaginatedFetcher, [{
+
+    _createClass(ExhaustivePaginatedFetcher, [{
       key: "combinePages",
       value: function combinePages(pages) {
         return pages.reduce(function (accumulator, page) {
@@ -34,58 +40,70 @@ var ExhaustivePaginatedFetcher = function ExhaustivePaginatedFetcher() {
     }, {
       key: "get",
       value: function () {
-        var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(url) {
+        var _get2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(url) {
           var _this = this;
+
           var additionalParams,
-            params,
-            totalItems,
-            itemsPerPage,
-            _args = arguments;
-          return _regeneratorRuntime().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: _superPropGet(ExhaustivePaginatedFetcher, "callHeaders", this, 3)([])
-                };
-                return _context.abrupt("return", _superPropGet(ExhaustivePaginatedFetcher, "fetch", this, 3)([_superPropGet(ExhaustivePaginatedFetcher, "appendQueryParams", this, 3)([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 = _toConsumableArray(Array(pageCount).keys()).map(function (p) {
-                      return _superPropGet(ExhaustivePaginatedFetcher, "get", _this, 3)([url, _objectSpread(_objectSpread({}, additionalParams), {}, {
-                        page: p + 2,
-                        per_page: itemsPerPage
-                      })]);
-                    });
-                    return Promise.all(pages).then(function (pageResponses) {
-                      return [].concat(_toConsumableArray(initial), _toConsumableArray(_this.combinePages(pageResponses)));
-                    });
-                  } else {
-                    return initial;
-                  }
-                }));
-              case 3:
-              case "end":
-                return _context.stop();
+              params,
+              totalItems,
+              itemsPerPage,
+              _args = arguments;
+          return _regeneratorRuntime.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: _get(_getPrototypeOf(ExhaustivePaginatedFetcher.prototype), "callHeaders", this).call(this)
+                  };
+                  return _context.abrupt("return", _get(_getPrototypeOf(ExhaustivePaginatedFetcher.prototype), "fetch", this).call(this, _get(_getPrototypeOf(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 = _toConsumableArray(Array(pageCount).keys()).map(function (p) {
+                        return _get(_getPrototypeOf(ExhaustivePaginatedFetcher.prototype), "get", _this).call(_this, url, _objectSpread(_objectSpread({}, additionalParams), {}, {
+                          page: p + 2,
+                          per_page: itemsPerPage
+                        }));
+                      });
+
+                      return Promise.all(pages).then(function (pageResponses) {
+                        return [].concat(_toConsumableArray(initial), _toConsumableArray(_this.combinePages(pageResponses)));
+                      });
+                    } else {
+                      return initial;
+                    }
+                  }));
+
+                case 3:
+                case "end":
+                  return _context.stop();
+              }
             }
           }, _callee, this);
         }));
+
         function get(_x) {
-          return _get.apply(this, arguments);
+          return _get2.apply(this, arguments);
         }
+
         return get;
       }()
     }]);
+
+    return ExhaustivePaginatedFetcher;
   }(SuperClass);
+
   return new ExhaustivePaginatedFetcher(args);
 };
+
 export default ExhaustivePaginatedFetcher;