@instructure/quiz-core 17.19.2-rc.5 → 17.19.3-rc.2

package/lib/common/util/ThunkQueue.js

@@ -0,0 +1,163 @@
+"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 _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+/*
+ * A queue for redux thunks (see https://github.com/reduxjs/redux-thunk).
+ *
+ * Use this if you need to ensure that asynchronous actions happen in series.
+ * This can be useful to avoid race conditions.
+ *
+ * Example:
+ *
+ *     const queue = new ThunkQueue()
+ *     const action = queue.wrapActionCreator((...args) => {
+ *       return (dispatch, getState) => {
+ *         ...
+ *       }
+ *     })
+ *
+ * If a thunk fails, all pending thunks will be cancelled and will not run.
+ * You can pass an error handler to the constructor:
+ *
+ *     const queue = new ThunkQueue((error, dispatch, getState) => { ... })
+ *
+ * This error handler will be called for every thunk that fails. This can be
+ * useful if, for example, you are using a queue to ensure that API calls are
+ * processed in sequence with optimistic UI updates, and want to reset the UI
+ * to match backend state if a request fails.
+ */
+var ThunkQueue = /*#__PURE__*/function () {
+  function ThunkQueue() {
+    var errorHandler = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
+    (0, _classCallCheck2.default)(this, ThunkQueue);
+    this.errorHandler = errorHandler;
+    this.queue = [];
+  }
+
+  (0, _createClass2.default)(ThunkQueue, [{
+    key: "wrapActionCreator",
+    value: function wrapActionCreator(fn) {
+      var _this = this;
+
+      return function () {
+        return _this.wrapThunk(fn.apply(void 0, arguments));
+      };
+    }
+  }, {
+    key: "wrapThunk",
+    value: function wrapThunk(action) {
+      var _this2 = this;
+
+      if (typeof action !== 'function') {
+        return action;
+      }
+
+      return function (dispatch, getState) {
+        var promise = _this2._run(action, dispatch, getState); // Attach a reference to the thunk on the promise so we can cancel it if
+        // an earlier promise fails
+
+
+        promise.thunk = action;
+
+        _this2.queue.push(promise);
+
+        return promise;
+      };
+    }
+  }, {
+    key: "_run",
+    value: function () {
+      var _run2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(thunk, dispatch, getState) {
+        var _iterator, _step, promise;
+
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return Promise.all(this.queue);
+
+              case 2:
+                _context.prev = 2;
+
+                if (!thunk.cancelled) {
+                  _context.next = 5;
+                  break;
+                }
+
+                return _context.abrupt("return");
+
+              case 5:
+                _context.next = 7;
+                return thunk(dispatch, getState);
+
+              case 7:
+                return _context.abrupt("return", _context.sent);
+
+              case 10:
+                _context.prev = 10;
+                _context.t0 = _context["catch"](2);
+                // If this thunk fails, cancel all pending thunks
+                _iterator = (0, _createForOfIteratorHelper2.default)(this.queue);
+
+                try {
+                  for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                    promise = _step.value;
+                    promise.thunk.cancelled = true;
+                  }
+                } catch (err) {
+                  _iterator.e(err);
+                } finally {
+                  _iterator.f();
+                }
+
+                if (!this.errorHandler) {
+                  _context.next = 18;
+                  break;
+                }
+
+                return _context.abrupt("return", this.errorHandler(_context.t0, dispatch, getState));
+
+              case 18:
+                throw _context.t0;
+
+              case 19:
+                _context.prev = 19;
+                this.queue.shift();
+                return _context.finish(19);
+
+              case 22:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[2, 10, 19, 22]]);
+      }));
+
+      function _run(_x, _x2, _x3) {
+        return _run2.apply(this, arguments);
+      }
+
+      return _run;
+    }()
+  }]);
+  return ThunkQueue;
+}();
+
+exports.default = ThunkQueue;

package/lib/common/util/TimeRecordingService.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.TimeRecordingService = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var TimeRecordingService = /*#__PURE__*/function () {
+  function TimeRecordingService(recordQuizTime, updateTimerInfo) {
+    var _this = this;
+
+    (0, _classCallCheck2.default)(this, TimeRecordingService);
+
+    this.__performApiCall = function () {
+      _this._recordQuizTime(function () {
+        var data = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+
+        if (_this._stopped) {
+          return;
+        }
+
+        _this._updateTimerInfo({
+          timeRecording: data.timeRecording
+        });
+      });
+    };
+
+    this._recordQuizTime = recordQuizTime;
+    this._updateTimerInfo = updateTimerInfo;
+    this._stopped = false;
+    this._apiInterval = null;
+    this._apiTimeIncrement = 4000;
+  }
+
+  (0, _createClass2.default)(TimeRecordingService, [{
+    key: "start",
+    value: function start() {
+      this.__performApiCall();
+
+      this.__startApiInterval();
+
+      return this;
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      this._stopped = true;
+
+      this.__stopApiInterval();
+
+      return this;
+    }
+  }, {
+    key: "__ensureNotStopped",
+    value: function __ensureNotStopped() {
+      if (this._stopped) {
+        throw new Error('An attempt was made to restart a stopped timer. This is disallowed ' + 'to prevent tricky race conditions. Create a new TimeRecordingService object instead.');
+      }
+    }
+  }, {
+    key: "__startApiInterval",
+    value: function __startApiInterval() {
+      this.__ensureNotStopped();
+
+      this._apiInterval = setInterval(this.__performApiCall, this._apiTimeIncrement);
+    }
+  }, {
+    key: "__stopApiInterval",
+    value: function __stopApiInterval() {
+      clearInterval(this._apiInterval);
+      this._apiInterval = null;
+    }
+  }]);
+  return TimeRecordingService;
+}();
+
+exports.TimeRecordingService = TimeRecordingService;
+var _default = TimeRecordingService;
+exports.default = _default;

package/lib/common/util/TimerService.js

@@ -0,0 +1,210 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.TimerService = exports.MAX_SETTIMEOUT_IN_MILLISECONDS = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _formatMessage = _interopRequireDefault(require("@instructure/quiz-i18n/es/format-message"));
+
+var _reduxStore = _interopRequireDefault(require("../../reduxStore.js"));
+
+var MAX_SETTIMEOUT_IN_MILLISECONDS = 20 * 24 * 3600 * 1000; // ms of 20 days
+
+exports.MAX_SETTIMEOUT_IN_MILLISECONDS = MAX_SETTIMEOUT_IN_MILLISECONDS;
+
+var TimerService = /*#__PURE__*/function () {
+  function TimerService(getTimeRemaining, updateTimeRemaining, getTimerData, submitQuiz, alert) {
+    var _this = this;
+
+    (0, _classCallCheck2.default)(this, TimerService);
+
+    this.__performApiCall = function () {
+      _this._getTimeRemaining(function () {
+        var data = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+
+        if (_this._stopped) {
+          return;
+        }
+
+        _this.__resetClockInterval(data.timerRunning && data.timeLeftInSeconds >= 0);
+
+        _this.__onTimerChange(data);
+
+        _this.__setApiCallIntervalTime(data.timeLeftInSeconds);
+      });
+    };
+
+    this._getTimeRemaining = getTimeRemaining;
+    this._updateTimeRemaining = updateTimeRemaining;
+    this._getTimerData = getTimerData;
+    this._submitQuiz = submitQuiz;
+    this._alert = alert;
+    this._stopped = false;
+    this._apiInterval = null;
+    this._clockInterval = null;
+    this._apiTimeIncrement = 10000;
+    this._clockTimeIncrement = 1000;
+  }
+
+  (0, _createClass2.default)(TimerService, [{
+    key: "start",
+    value: function start() {
+      this.__performApiCall();
+
+      this.__startApiInterval();
+
+      return this;
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      this._stopped = true;
+
+      this.__stopApiInterval();
+
+      this.__stopClockInterval();
+
+      return this;
+    }
+  }, {
+    key: "__ensureNotStopped",
+    value: function __ensureNotStopped() {
+      if (this._stopped) {
+        throw new Error('An attempt was made to restart a stopped timer. This is disallowed ' + 'to prevent tricky race conditions. Create a new TimerService object instead.');
+      }
+    }
+  }, {
+    key: "__startApiInterval",
+    value: function __startApiInterval() {
+      this.__ensureNotStopped();
+
+      this._apiInterval = setInterval(this.__performApiCall, this._apiTimeIncrement);
+    }
+  }, {
+    key: "__stopApiInterval",
+    value: function __stopApiInterval() {
+      clearInterval(this._apiInterval);
+      this._apiInterval = null;
+    }
+  }, {
+    key: "__resetApiCallInterval",
+    value: function __resetApiCallInterval() {
+      this.__stopApiInterval();
+
+      this.__startApiInterval();
+    }
+  }, {
+    key: "__setApiCallIntervalTime",
+    value: function __setApiCallIntervalTime(timeLeftInSeconds) {
+      var startIncrement = this._apiTimeIncrement;
+
+      var newIncrement = this.__nextIncrement(timeLeftInSeconds);
+
+      if (startIncrement !== newIncrement) {
+        this._apiTimeIncrement = newIncrement;
+
+        this.__resetApiCallInterval();
+      }
+    }
+  }, {
+    key: "__nextIncrement",
+    value: function __nextIncrement(timeLeftInSeconds) {
+      if (Number.isNaN(timeLeftInSeconds - 0)) {
+        return 30000;
+      }
+
+      if (timeLeftInSeconds < 180) {
+        return 15000;
+      } else if (timeLeftInSeconds < 7200) {
+        return 150000;
+      }
+
+      var interval = Math.max(15000, Math.floor(timeLeftInSeconds * 500)); // timeLeft/2
+
+      return Math.min(interval, MAX_SETTIMEOUT_IN_MILLISECONDS);
+    }
+  }, {
+    key: "__startClockInterval",
+    value: function __startClockInterval() {
+      var _this2 = this;
+
+      this.__ensureNotStopped();
+
+      var action = function action() {
+        var state = _reduxStore.default.getAppState();
+
+        var _this2$_getTimerData$ = _this2._getTimerData(state).toJS(),
+            timerRunning = _this2$_getTimerData$.timerRunning,
+            timeLeftInSeconds = _this2$_getTimerData$.timeLeftInSeconds;
+
+        if (!timerRunning || timeLeftInSeconds !== 0 && !timeLeftInSeconds) {
+          return;
+        }
+
+        var delta = Math.round(_this2._clockTimeIncrement / 1000);
+        var newTimeLeftInSeconds = timeLeftInSeconds - delta;
+
+        _this2.__onTimerChange({
+          timerRunning: timerRunning,
+          timeLeftInSeconds: newTimeLeftInSeconds
+        });
+      };
+
+      this._clockInterval = setInterval(action, this._clockTimeIncrement);
+    }
+  }, {
+    key: "__stopClockInterval",
+    value: function __stopClockInterval() {
+      clearInterval(this._clockInterval);
+      this._clockInterval = null;
+    }
+  }, {
+    key: "__resetClockInterval",
+    value: function __resetClockInterval() {
+      var startClock = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+
+      this.__stopClockInterval();
+
+      if (startClock) {
+        this.__startClockInterval();
+      }
+    }
+  }, {
+    key: "__onTimerChange",
+    value: function __onTimerChange(_ref) {
+      var timerRunning = _ref.timerRunning,
+          timeLeftInSeconds = _ref.timeLeftInSeconds;
+
+      var state = _reduxStore.default.getAppState();
+
+      var prevTimerData = this._getTimerData(state);
+
+      this._updateTimeRemaining({
+        timerRunning: timerRunning,
+        timeLeftInSeconds: timeLeftInSeconds
+      });
+
+      if (prevTimerData.get('timeLeftInSeconds') > 30 && timeLeftInSeconds <= 30) {
+        this._alert((0, _formatMessage.default)('You have less than 30 seconds remaining.'));
+      }
+
+      if (timeLeftInSeconds !== null && timeLeftInSeconds <= 0) {
+        this.stop();
+
+        this._submitQuiz();
+      }
+    }
+  }]);
+  return TimerService;
+}();
+
+exports.TimerService = TimerService;
+var _default = TimerService;
+exports.default = _default;

package/lib/common/util/cachePreviousArgs.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+var _this = void 0;
+
+var _default = function _default(fn) {
+  var prevArgs = null;
+  var cachedValue;
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    if ((0, _isEqual.default)(args, prevArgs)) {
+      return cachedValue;
+    }
+
+    prevArgs = args;
+    cachedValue = fn.apply(_this, args);
+    return cachedValue;
+  };
+};
+
+exports.default = _default;

package/lib/common/util/callHelpers.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.callbacksCompleteForCall = exports.errorCallFor = exports.successCallFor = exports.startCallFor = void 0;
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var callAction = function callAction(callStatus, type) {
+  return {
+    type: _quizCommon.CALL_STATUS,
+    payload: {
+      call: type,
+      status: callStatus
+    }
+  };
+};
+
+var startCallFor = function startCallFor(type) {
+  return callAction('calling', type);
+};
+
+exports.startCallFor = startCallFor;
+
+var successCallFor = function successCallFor(type) {
+  return callAction('success', type);
+};
+
+exports.successCallFor = successCallFor;
+
+var errorCallFor = function errorCallFor(type) {
+  return callAction('error', type);
+};
+
+exports.errorCallFor = errorCallFor;
+
+var callbacksCompleteForCall = function callbacksCompleteForCall(type) {
+  return {
+    type: _quizCommon.SET_CALLBACKS_STATUS,
+    payload: {
+      call: type,
+      status: 'complete'
+    }
+  };
+};
+
+exports.callbacksCompleteForCall = callbacksCompleteForCall;

package/lib/common/util/componentForItem.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.componentForItem = void 0;
+
+var interactions = _interopRequireWildcard(require("@instructure/quiz-interactions"));
+
+var _require = require('humps'),
+    pascalize = _require.pascalize;
+
+var slugToNameMap = {
+  'multi-answer': 'MultipleAnswer',
+  'choice': 'MultipleChoice'
+};
+
+var componentForItem = function componentForItem(intTypeSlug, usage) {
+  var componentKey = slugToNameMap[intTypeSlug];
+
+  if (!componentKey) {
+    componentKey = pascalize(intTypeSlug);
+  }
+
+  var normalizedUsage = pascalize(usage.toLowerCase());
+  var componentName = componentKey + normalizedUsage;
+  var component = interactions[componentName];
+
+  if (!component) {
+    throw new Error("Unable to find component: ".concat(componentName));
+  }
+
+  return component;
+};
+
+exports.componentForItem = componentForItem;
+var _default = componentForItem;
+exports.default = _default;

package/lib/common/util/crossDomainMessaging.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.postToParent = postToParent;
+
+function postToParent(messageData) {
+  var windowObject = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : window;
+
+  if (windowObject.parent) {
+    windowObject.parent.postMessage(messageData, '*');
+  }
+}

package/lib/common/util/debounceLatestPromise.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _debounce = _interopRequireDefault(require("lodash/debounce"));
+
+var _default = function _default(f, ms) {
+  var waiting = null;
+
+  var ready = function ready() {
+    var old = waiting;
+    f.apply(void 0, arguments).then(function (r) {
+      return old.resolve(r);
+    }).catch(function (e) {
+      return old.reject(e);
+    });
+    waiting = null;
+  };
+
+  var debouncedThunk = (0, _debounce.default)(ready, ms);
+  return function () {
+    var promise = new Promise(function (resolve, reject) {
+      return waiting = {
+        resolve: resolve,
+        reject: reject
+      };
+    });
+    debouncedThunk.apply(void 0, arguments);
+    return promise;
+  };
+};
+
+exports.default = _default;

package/lib/common/util/featureCheck.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.featureOn = featureOn;
+exports.ifFeature = ifFeature;
+exports.setFeatures = setFeatures;
+exports.unsetFeatures = unsetFeatures;
+exports.withTestFeatures = withTestFeatures;
+
+var _immutable = require("immutable");
+
+var _reduxStore = _interopRequireDefault(require("../../reduxStore.js"));
+
+var _features = require("../actions/features.js");
+
+// Put these in an object so we can stub them in tests
+var stubbableFunctions = {
+  featureOn: function featureOn(featureName) {
+    var features = _reduxStore.default.getAppState().get('features', (0, _immutable.List)());
+
+    return features.includes(featureName);
+  }
+};
+
+function featureOn(featureName) {
+  return stubbableFunctions.featureOn(featureName);
+}
+
+function ifFeature(featureName, valueWith, valueWithout) {
+  return featureOn(featureName) ? valueWith : valueWithout;
+}
+
+function setFeatures(featuresList) {
+  _reduxStore.default.dispatch((0, _features.addFeatures)(featuresList));
+}
+
+function unsetFeatures(featuresList) {
+  _reduxStore.default.dispatch((0, _features.removeFeatures)(featuresList));
+} // Usage: withTestFeatures(['feature'])
+// 2nd argument lets your override the use of global sinon
+// eslint-disable-next-line no-undef
+
+
+function withTestFeatures(featuresList) {
+  var sinonToUse = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : sinon;
+  beforeEach(function () {
+    sinonToUse.stub(stubbableFunctions, 'featureOn').callsFake(function (feature) {
+      return featuresList.includes(feature);
+    }); // eslint-disable-line no-undef
+  });
+  afterEach(function () {
+    stubbableFunctions.featureOn.restore();
+  });
+}