@instructure/quiz-core 17.19.2 → 17.20.0

package/lib/common/middleware/persistedStorageMiddleware.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _store = _interopRequireDefault(require("store"));
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _sessionStore = require("../util/sessionStore.js");
+
+/**
+ * Some of our redux store values are stored in browser client-side storage
+ * for easy recall in the event of a page refresh, etc. This provides a single
+ * place to save all of those values so we can know how our data is organized
+ * in client-side storage.
+ *
+ * See also src/common/util/persistedState.js for how these values are loaded.
+ */
+var persistTakingInfo = function persistTakingInfo(store, persistedLocalStore) {
+  var position = store.getState().getIn(['taking', 'currentSessionItemPosition']);
+  var sessionId = store.getState().getIn(['quizSessions', 'activeQuizSessionId']);
+  persistedLocalStore.set(_quizCommon.ACTIVE_QUESTION, position);
+  persistedLocalStore.set(_quizCommon.CACHED_SESSION_ID, sessionId);
+};
+
+var persistPrintFontSizePreference = function persistPrintFontSizePreference(store, persistedLocalStore) {
+  var fontSize = store.getState().getIn(['printing', 'fontSizePreference']);
+  persistedLocalStore.set(_quizCommon.QUIZ_PRINT_FONT_SIZE_PREFERENCE, fontSize);
+};
+
+var persistedStorageMiddleware = function persistedStorageMiddleware() {
+  var persistedSessionStore = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : _sessionStore.sessionStore;
+  var persistedLocalStore = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _store.default;
+  return function (store) {
+    return function (next) {
+      return function (action) {
+        var nextState = next(action);
+
+        if (persistedLocalStore.enabled) {
+          switch (action.type) {
+            case _quizCommon.ACTIVE_QUIZ_SESSION_CHANGE:
+            case _quizCommon.BACKTRACKING_NEXT_QUESTION:
+            case _quizCommon.PREVIOUS_QUESTION:
+            case _quizCommon.SET_CURRENT_SESSION_ITEM_POSITION:
+              persistTakingInfo(store, persistedLocalStore);
+              break;
+
+            case _quizCommon.PERSIST_PRINT_FONT_SIZE_PREFERENCE:
+              persistPrintFontSizePreference(store, persistedLocalStore);
+              break;
+          }
+        }
+
+        return nextState;
+      };
+    };
+  };
+};
+
+var _default = persistedStorageMiddleware;
+exports.default = _default;

package/lib/common/react-redux.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.connect = connectToSDKStore;
+exports.Provider = void 0;
+
+var _reactRedux = require("react-redux");
+
+/* eslint "no-param-reassign": "warn" */
+var STORE_KEY = 'SDKStore';
+
+function connectToSDKStore(mapStateToProps, mapDispatchToProps, mergeProps) {
+  var options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
+  options.storeKey = options.storeKey || STORE_KEY;
+  return (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps, mergeProps, options);
+}
+
+var Provider = (0, _reactRedux.createProvider)(STORE_KEY);
+exports.Provider = Provider;

package/lib/common/records/Alert.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.Alert = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _immutable = require("immutable");
+
+var Alert = /*#__PURE__*/function (_Record) {
+  (0, _inherits2.default)(Alert, _Record);
+
+  var _super = (0, _createSuper2.default)(Alert);
+
+  function Alert() {
+    (0, _classCallCheck2.default)(this, Alert);
+    return _super.apply(this, arguments);
+  }
+
+  return Alert;
+}((0, _immutable.Record)({
+  message: null,
+  uuid: null,
+  variant: 'info'
+}));
+
+exports.Alert = Alert;
+var _default = Alert;
+exports.default = _default;

package/lib/common/records/Bank.js

@@ -0,0 +1,129 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.Bank = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _immutable = require("immutable");
+
+var _reduxRecord = _interopRequireDefault(require("./reduxRecord.js"));
+
+var _formatMessage = _interopRequireDefault(require("@instructure/quiz-i18n/es/format-message"));
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _instructureValidations = require("instructure-validations");
+
+var _quizInteractions = require("@instructure/quiz-interactions");
+
+var _qtiImports = require("../selectors/qtiImports.js");
+
+var Bank = /*#__PURE__*/function (_ReduxRecord) {
+  (0, _inherits2.default)(Bank, _ReduxRecord);
+
+  var _super = (0, _createSuper2.default)(Bank);
+
+  function Bank() {
+    (0, _classCallCheck2.default)(this, Bank);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(Bank, [{
+    key: "createdAt",
+    value: function createdAt() {
+      return new Date(this.get('createdAt'));
+    }
+  }, {
+    key: "updatedAt",
+    value: function updatedAt() {
+      return new Date(this.get('updatedAt'));
+    }
+  }, {
+    key: "lastUsed",
+    value: function lastUsed() {
+      var lastUsed = this.get('lastUsed');
+      return lastUsed ? new Date(lastUsed) : null;
+    }
+  }, {
+    key: "isLoaded",
+    value: function isLoaded() {
+      return this.id !== '0';
+    }
+  }, {
+    key: "isTemporary",
+    value: function isTemporary() {
+      return this.id === _quizCommon.TEMPORARY_BANK_ID;
+    }
+  }, {
+    key: "getWorkingInstance",
+    value: function getWorkingInstance() {
+      var data = this.merge(this.getState().getIn(['modifications', 'banks', this.id]));
+      return Bank.create(data);
+    }
+  }, {
+    key: "hasModifications",
+    value: function hasModifications() {
+      return false;
+    }
+  }, {
+    key: "canImport",
+    value: function canImport() {
+      return this.status === 'waiting' && this.entryCount === 0;
+    }
+  }, {
+    key: "getLatestImport",
+    value: function getLatestImport() {
+      return (0, _qtiImports.getLatestQtiImportForParentWithType)(this.getState(), this.id, 'Bank');
+    }
+  }, {
+    key: "canEdit",
+    value: function canEdit() {
+      return this.permission === _quizCommon.CAN_EDIT;
+    }
+  }], [{
+    key: "validations",
+    value: function validations() {
+      return {
+        title: [(0, _instructureValidations.rule)('presence', {
+          message: (0, _quizInteractions.presenceMessage)((0, _formatMessage.default)('Bank name'))
+        })]
+      };
+    }
+  }]);
+  return Bank;
+}((0, _reduxRecord.default)({
+  accountPermission: null,
+  archived: false,
+  bankEntries: (0, _immutable.Set)(),
+  createdAt: null,
+  entryCount: 0,
+  // item count + stimulus count
+  filters: null,
+  id: '0',
+  itemEntryCount: 0,
+  // item count only
+  language: null,
+  creator: '',
+  permission: '',
+  sharedCount: 0,
+  status: null,
+  title: '',
+  updatedAt: null,
+  lastUpdated: null,
+  lastUsed: null
+}));
+
+exports.Bank = Bank;
+var _default = Bank;
+exports.default = _default;

package/lib/common/records/BankEntry.js

@@ -0,0 +1,96 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.BankEntry = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _immutable = require("immutable");
+
+var _reduxRecord = _interopRequireDefault(require("./reduxRecord.js"));
+
+var _Item2 = _interopRequireDefault(require("./Item.js"));
+
+var _Stimulus2 = _interopRequireDefault(require("./Stimulus.js"));
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var BankEntry = /*#__PURE__*/function (_ReduxRecord) {
+  (0, _inherits2.default)(BankEntry, _ReduxRecord);
+
+  var _super = (0, _createSuper2.default)(BankEntry);
+
+  function BankEntry() {
+    (0, _classCallCheck2.default)(this, BankEntry);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(BankEntry, [{
+    key: "getEntry",
+    value: function getEntry() {
+      var _this = this;
+
+      if (this.entry === _quizCommon.TEMPORARY_ITEM_ID) {
+        return _Item2.default.create(this.getState().getIn(['modifications', 'items', _quizCommon.TEMPORARY_ITEM_ID]));
+      }
+
+      if (this.entry === _quizCommon.TEMPORARY_STIMULUS_ID) {
+        return _Stimulus2.default.create(this.getState().getIn(['modifications', 'stimuli', _quizCommon.TEMPORARY_STIMULUS_ID]));
+      }
+
+      var entryCreator = {
+        Item: function Item() {
+          return _Item2.default.create(_this.getState().getIn(['items', _this.entry.get('id')]));
+        },
+        Stimulus: function Stimulus() {
+          return _Stimulus2.default.create(_this.getState().getIn(['stimuli', _this.entry.get('id')]));
+        }
+      }[this.entryType];
+      if (entryCreator) return entryCreator();
+    }
+  }, {
+    key: "getNestedEntries",
+    value: function getNestedEntries() {
+      var entry = this.getEntry();
+      var getNestedEntriesFunction = {
+        Item: function Item() {
+          return [entry];
+        }
+      }[this.entryType];
+      if (getNestedEntriesFunction) return getNestedEntriesFunction();
+    }
+  }, {
+    key: "getWorkingInstance",
+    value: function getWorkingInstance() {
+      return this.merge(this.getState().getIn(['modifications', 'bankEntries', this.id]));
+    }
+  }, {
+    key: "isStimulus",
+    get: function get() {
+      return this.entryType === 'Stimulus';
+    }
+  }]);
+  return BankEntry;
+}((0, _reduxRecord.default)({
+  id: '0',
+  entry: (0, _immutable.Map)(),
+  bankId: '0',
+  archived: false,
+  entryType: null,
+  createdAt: null,
+  updatedAt: null
+}));
+
+exports.BankEntry = BankEntry;
+var _default = BankEntry;
+exports.default = _default;

package/lib/common/records/Item.js

@@ -0,0 +1,151 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.Item = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _immutable = require("immutable");
+
+var _quizInteractions = require("@instructure/quiz-interactions");
+
+var _formatMessage = _interopRequireDefault(require("@instructure/quiz-i18n/es/format-message"));
+
+var _instructureValidations = require("instructure-validations");
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _reduxRecord = _interopRequireDefault(require("./reduxRecord.js"));
+
+var _interactionTypes = require("../selectors/interactionTypes.js");
+
+var Item = /*#__PURE__*/function (_ReduxRecord) {
+  (0, _inherits2.default)(Item, _ReduxRecord);
+
+  var _super = (0, _createSuper2.default)(Item);
+
+  function Item() {
+    (0, _classCallCheck2.default)(this, Item);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(Item, [{
+    key: "isLoaded",
+    value: function isLoaded() {
+      return this.id !== '0';
+    }
+  }, {
+    key: "hasResponse",
+    value: function hasResponse(userResponse) {
+      if (!userResponse || userResponse.value === null || userResponse.value === void 0) return false;
+      return this.getInteractionType().hasResponse(userResponse.value, this.interactionData.toJS());
+    }
+  }, {
+    key: "getChoice",
+    value: function getChoice(choiceId) {
+      return this.getIn(['interactionData', 'choices'], (0, _immutable.fromJS)([])).find(function (choice) {
+        return choice.get('id') === choiceId;
+      });
+    }
+  }, {
+    key: "getInteractionType",
+    value: function getInteractionType() {
+      // if the interaction type wasn't normalized (sample items), we need to get the id from the object
+      var interactionTypeId = typeof this.interactionType === 'object' ? this.interactionType.id : this.interactionType;
+      return (0, _interactionTypes.getInteractionType)(this.getState(), interactionTypeId) || new _quizInteractions.InteractionType();
+    }
+  }, {
+    key: "hasModifications",
+    value: function hasModifications() {
+      return !(0, _immutable.is)(this.getWorkingInstance(), this);
+    }
+  }, {
+    key: "hasFeedback",
+    value: function hasFeedback() {
+      return this.getIn(['feedback', 'correct']) || this.getIn(['feedback', 'incorrect']) || this.getIn(['feedback', 'neutral']);
+    }
+  }, {
+    key: "getScoringAlgorithm",
+    value: function getScoringAlgorithm() {
+      return this.scoringAlgorithm || this.getInteractionType().scoringAlgorithmDefault;
+    }
+  }, {
+    key: "getWorkingInstance",
+    value: function getWorkingInstance(overrides) {
+      var mods = this.getState().getIn(['modifications', 'items', this.id]);
+      var data = this.merge(overrides, mods); // needed so we can maintain state... this is sad
+
+      return Item.create(data, this.getState());
+    }
+  }, {
+    key: "isImmutable",
+    value: function isImmutable() {
+      return this.status === 'immutable';
+    }
+  }, {
+    key: "isTemporary",
+    value: function isTemporary() {
+      return this.id === _quizCommon.TEMPORARY_ITEM_ID;
+    } // PRIVATE METHODS
+
+  }, {
+    key: "__defaultItem",
+    value: function __defaultItem() {
+      return this.id === '0';
+    }
+  }, {
+    key: "isStimulus",
+    get: function get() {
+      return false;
+    }
+  }], [{
+    key: "validations",
+    value: function validations() {
+      return {
+        onSelf: [(0, _instructureValidations.rule)('maxContent', {
+          limit: _quizCommon.BUILD_CHAR_LIMIT
+        })]
+      };
+    }
+  }]);
+  return Item;
+}((0, _reduxRecord.default)({
+  id: '0',
+  title: (0, _formatMessage.default)('Title'),
+  label: (0, _formatMessage.default)('label'),
+  itemBody: (0, _formatMessage.default)('Question stem'),
+  interactionTypeId: '0',
+  interactionType: '0',
+  interactionData: (0, _immutable.Map)(),
+  properties: (0, _immutable.Map)(),
+  contextId: null,
+  toolName: null,
+  parentItemId: null,
+  parentItemRelationship: null,
+  createdAt: null,
+  updatedAt: null,
+  scoringAlgorithm: null,
+  scoringData: (0, _immutable.Map)(),
+  scoringDataSchema: (0, _immutable.Map)(),
+  status: 'mutable',
+  outcomeDeclaration: null,
+  outcomeAlignmentSetGuid: null,
+  feedback: (0, _immutable.Map)(),
+  answerFeedback: (0, _immutable.Map)(),
+  stimulusId: null,
+  calculatorType: 'none'
+}));
+
+exports.Item = Item;
+var _default = Item;
+exports.default = _default;

package/lib/common/records/ItemAnalysis.js

@@ -0,0 +1,177 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ItemAnalysis = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _immutable = require("immutable");
+
+var _d3Array = require("d3-array");
+
+var _quizI18n = require("@instructure/quiz-i18n");
+
+var _reduxRecord = _interopRequireDefault(require("./reduxRecord.js"));
+
+var _interactionTypeMetadata = require("../util/interactionTypeMetadata.js");
+
+var ItemAnalysis = /*#__PURE__*/function (_ReduxRecord) {
+  (0, _inherits2.default)(ItemAnalysis, _ReduxRecord);
+
+  var _super = (0, _createSuper2.default)(ItemAnalysis);
+
+  function ItemAnalysis() {
+    (0, _classCallCheck2.default)(this, ItemAnalysis);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(ItemAnalysis, [{
+    key: "isLoaded",
+    value: function isLoaded() {
+      return this.itemId !== '0';
+    }
+  }, {
+    key: "interactionTypeName",
+    value: function interactionTypeName() {
+      var intData = (0, _interactionTypeMetadata.interactionTypeMetadata)({
+        slug: this.interactionType
+      });
+      return intData.name;
+    }
+  }, {
+    key: "correctAnswerInfo",
+    value: function correctAnswerInfo() {
+      return this.itemAnalysis.get('correctAnswerInfo', (0, _immutable.Map)());
+    }
+  }, {
+    key: "incorrectAnswerInfo",
+    value: function incorrectAnswerInfo() {
+      return this.itemAnalysis.get('incorrectAnswerInfo', (0, _immutable.Map)());
+    }
+  }, {
+    key: "isPresent",
+    value: function isPresent() {
+      return !this.notFound;
+    }
+  }, {
+    key: "scoreInfo",
+    value: function scoreInfo() {
+      return this.itemAnalysis.get('scoreInfo', (0, _immutable.Map)());
+    }
+  }, {
+    key: "choiceInfo",
+    value: function choiceInfo() {
+      return this.itemAnalysis.get('choiceInfo', (0, _immutable.List)());
+    }
+  }, {
+    key: "topCorrectAnswerInfo",
+    value: function topCorrectAnswerInfo() {
+      return this.itemAnalysis.get('topCorrectAnswerInfo', (0, _immutable.Map)());
+    }
+  }, {
+    key: "bottomCorrectAnswerInfo",
+    value: function bottomCorrectAnswerInfo() {
+      return this.itemAnalysis.get('bottomCorrectAnswerInfo', (0, _immutable.Map)());
+    }
+  }, {
+    key: "unansweredInfo",
+    value: function unansweredInfo() {
+      return this.itemAnalysis.get('unansweredInfo', 0);
+    }
+  }, {
+    key: "quintile",
+    value: function quintile() {
+      return this.itemAnalysis.get('quintile', (0, _immutable.List)([0, 0, 0, 0, 0])).toJS();
+    }
+  }, {
+    key: "choiceCounts",
+    value: function choiceCounts() {
+      return this.choiceInfo().toJS().map(function (c) {
+        return c.choiceCount;
+      }).concat(this.unansweredInfo());
+    }
+  }, {
+    key: "choiceCountMax",
+    value: function choiceCountMax() {
+      return (0, _d3Array.max)(this.choiceCounts());
+    }
+  }, {
+    key: "choiceCountSum",
+    value: function choiceCountSum() {
+      return (0, _d3Array.sum)(this.choiceCounts());
+    }
+  }, {
+    key: "calculateMeanScore",
+    value: function calculateMeanScore(scoreInfo) {
+      var sum = scoreInfo.get('resultSum') || 0;
+      var count = scoreInfo.get('resultCount') || 0;
+      return sum / count;
+    }
+  }, {
+    key: "calculateDifficultyRatio",
+    value: function calculateDifficultyRatio(correctAnswerInfo) {
+      var correctAnswerCount = correctAnswerInfo.get('resultCount') || 0;
+      var appearedCount = correctAnswerInfo.get('appearedCount') || 0;
+      return correctAnswerCount / appearedCount;
+    }
+  }, {
+    key: "formatDecimal",
+    value: function formatDecimal(value, locale) {
+      return isFinite(value) ? (0, _quizI18n.formatDecimal2FractionDigits)(value, locale) : null;
+    }
+  }, {
+    key: "meanScore",
+    value: function meanScore(locale) {
+      return this.formatDecimal(this.calculateMeanScore(this.scoreInfo()), locale);
+    }
+  }, {
+    key: "difficultyIndex",
+    value: function difficultyIndex(locale) {
+      return this.formatDecimal(this.calculateDifficultyRatio(this.correctAnswerInfo()), locale);
+    }
+  }, {
+    key: "pointBiserial",
+    value: function pointBiserial(locale) {
+      var correctMean = this.calculateMeanScore(this.correctAnswerInfo());
+      var incorrectMean = this.calculateMeanScore(this.incorrectAnswerInfo());
+      var stdDeviation = this.scoreInfo().get('scoreStddevPop');
+      var numCorrect = this.correctAnswerInfo().get('resultCount');
+      var numInCorrect = this.incorrectAnswerInfo().get('resultCount');
+      var totalTakers = this.correctAnswerInfo().get('appearedCount');
+      var firstTerm = (correctMean - incorrectMean) / stdDeviation;
+      var secondTerm = Math.sqrt(numCorrect * numInCorrect / (totalTakers * totalTakers));
+      return this.formatDecimal(firstTerm * secondTerm, locale);
+    }
+  }, {
+    key: "discriminationIndex",
+    value: function discriminationIndex(locale) {
+      var topDifficulty = this.calculateDifficultyRatio(this.topCorrectAnswerInfo());
+      var bottomDifficulty = this.calculateDifficultyRatio(this.bottomCorrectAnswerInfo());
+      return this.formatDecimal(topDifficulty - bottomDifficulty, locale);
+    }
+  }]);
+  return ItemAnalysis;
+}((0, _reduxRecord.default)({
+  itemId: '0',
+  quizId: '0',
+  pointsPossible: '0',
+  interactionType: null,
+  itemBody: null,
+  itemAnalysis: null,
+  notFound: false,
+  outcomeAlignmentSetGuid: null
+}));
+
+exports.ItemAnalysis = ItemAnalysis;
+var _default = ItemAnalysis;
+exports.default = _default;