@pie-element/match 10.0.1 → 11.0.3-esm.0

package/esm/controller.js

@@ -2,9 +2,27 @@ import isEqual from 'lodash/isEqual';
 import isEmpty from 'lodash/isEmpty';
 import cloneDeep from 'lodash/cloneDeep';
 import { getFeedbackForCorrectness } from '@pie-lib/feedback';
-import { partialScoring, lockChoices, getShuffledChoices } from '@pie-lib/controller-utils';
+import { lockChoices, getShuffledChoices, partialScoring } from '@pie-lib/controller-utils';
 import debug from 'debug';
 
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
 function _objectWithoutPropertiesLoose(source, excluded) {
   if (source == null) return {};
   var target = {};
@@ -20,76 +38,6 @@ function _objectWithoutPropertiesLoose(source, excluded) {
   return target;
 }
 
-function _objectWithoutProperties(source, excluded) {
-  if (source == null) return {};
-  var target = _objectWithoutPropertiesLoose(source, excluded);
-  var key, i;
-
-  if (Object.getOwnPropertySymbols) {
-    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-
-    for (i = 0; i < sourceSymbolKeys.length; i++) {
-      key = sourceSymbolKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-      target[key] = source[key];
-    }
-  }
-
-  return target;
-}
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
-  }
-}
-
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-        args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-
-      _next(undefined);
-    });
-  };
-}
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
 var defaults = {
   choiceMode: 'radio',
   feedbackEnabled: false,
@@ -109,29 +57,24 @@ var defaults = {
   toolbarEditorPosition: 'bottom'
 };
 
-var _excluded = ["extraCSSRules", "feedbackEnabled", "promptEnabled", "prompt", "lockChoiceOrder"];
+const _excluded = ["extraCSSRules", "feedbackEnabled", "promptEnabled", "prompt", "lockChoiceOrder"];
+const log = debug('@pie-element:match:controller');
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var log = debug('@pie-element:match:controller');
-
-var getResponseCorrectness = function getResponseCorrectness(model, answers) {
-  var env = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var isPartialScoring = partialScoring.enabled(model, env);
-  var rows = model.rows;
-  var checkboxMode = model.choiceMode === 'checkbox';
+const getResponseCorrectness = (model, answers, env = {}) => {
+  const isPartialScoring = partialScoring.enabled(model, env);
+  const rows = model.rows;
+  const checkboxMode = model.choiceMode === 'checkbox';
 
   if (!answers || Object.keys(answers).length === 0) {
     return 'unanswered';
   }
 
-  var totalCorrectAnswers = checkboxMode ? getTotalCorrectAnswers(model) : getTotalCorrect(model);
-  var correctAnswers;
-  var incorrectAnswers = 0;
+  const totalCorrectAnswers = checkboxMode ? getTotalCorrectAnswers(model) : getTotalCorrect(model);
+  let correctAnswers;
+  let incorrectAnswers = 0;
 
   if (checkboxMode) {
-    var checkboxes = getCheckboxes(rows, answers);
+    const checkboxes = getCheckboxes(rows, answers);
     correctAnswers = checkboxes.correctAnswers;
     incorrectAnswers = checkboxes.incorrectAnswers;
   } else {
@@ -149,19 +92,17 @@ var getResponseCorrectness = function getResponseCorrectness(model, answers) {
   return 'incorrect';
 };
 
-var getCorrectness = function getCorrectness(question, env) {
-  var answers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
+const getCorrectness = (question, env, answers = {}) => {
   if (env.mode === 'evaluate') {
     return getResponseCorrectness(question, answers, env);
   }
 };
 
-var getCheckboxes = (rows, answers) => {
-  var correctAnswers = 0;
-  var incorrectAnswers = 0;
+const getCheckboxes = (rows, answers) => {
+  let correctAnswers = 0;
+  let incorrectAnswers = 0;
   rows.forEach(row => {
-    var answer = answers[row.id];
+    const answer = answers[row.id];
 
     if (answer) {
       row.values.forEach((v, i) => {
@@ -179,8 +120,8 @@ var getCheckboxes = (rows, answers) => {
   };
 };
 
-var getCorrectRadios = (rows, answers) => {
-  var correctAnswers = 0;
+const getCorrectRadios = (rows, answers) => {
+  let correctAnswers = 0;
   rows.forEach(row => {
     if (isEqual(row.values, answers[row.id])) {
       correctAnswers += 1;
@@ -189,14 +130,14 @@ var getCorrectRadios = (rows, answers) => {
   return correctAnswers;
 };
 
-var getTotalCorrect = question => {
-  var checkboxMode = question.choiceMode === 'checkbox';
-  var matchingTable = checkboxMode ? question.layout - 1 : 1;
+const getTotalCorrect = question => {
+  const checkboxMode = question.choiceMode === 'checkbox';
+  const matchingTable = checkboxMode ? question.layout - 1 : 1;
   return (question.rows.length || 0) * matchingTable;
 };
 
-var getTotalCorrectAnswers = question => {
-  var noOfTotalCorrectAnswers = 0;
+const getTotalCorrectAnswers = question => {
+  let noOfTotalCorrectAnswers = 0;
   question.rows.forEach(row => {
     row.values.forEach(value => {
       if (value) {
@@ -207,41 +148,38 @@ var getTotalCorrectAnswers = question => {
   return noOfTotalCorrectAnswers;
 };
 
-var getPartialScore = (question, answers) => {
-  var checkboxMode = question.choiceMode === 'checkbox';
+const getPartialScore = (question, answers) => {
+  const checkboxMode = question.choiceMode === 'checkbox';
 
   if (checkboxMode) {
-    var {
+    const {
       correctAnswers,
       incorrectAnswers
     } = getCheckboxes(question.rows, answers);
-    var totalCorrect = getTotalCorrectAnswers(question);
-    var total = totalCorrect === 0 ? 1 : totalCorrect;
+    const totalCorrect = getTotalCorrectAnswers(question);
+    const total = totalCorrect === 0 ? 1 : totalCorrect;
 
     if (correctAnswers + incorrectAnswers > totalCorrect) {
-      var extraAnswers = correctAnswers + incorrectAnswers - totalCorrect;
-      var score = parseFloat(((correctAnswers - extraAnswers) / total).toFixed(2));
+      const extraAnswers = correctAnswers + incorrectAnswers - totalCorrect;
+      const score = parseFloat(((correctAnswers - extraAnswers) / total).toFixed(2));
       return score < 0 ? 0 : score;
     } else {
       return parseFloat((correctAnswers / total).toFixed(2));
     }
   } else {
-    var _correctAnswers = getCorrectRadios(question.rows, answers);
-
-    var _totalCorrect = getTotalCorrect(question) === 0 ? 1 : getTotalCorrect(question);
-
-    return parseFloat((_correctAnswers / _totalCorrect).toFixed(2));
+    const correctAnswers = getCorrectRadios(question.rows, answers);
+    const totalCorrect = getTotalCorrect(question) === 0 ? 1 : getTotalCorrect(question);
+    return parseFloat((correctAnswers / totalCorrect).toFixed(2));
   }
 };
 
-var getOutComeScore = function getOutComeScore(question, env) {
-  var answers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var correctness = getCorrectness(question, env, answers);
-  var isPartialScoring = partialScoring.enabled(question, env);
+const getOutComeScore = (question, env, answers = {}) => {
+  const correctness = getCorrectness(question, env, answers);
+  const isPartialScoring = partialScoring.enabled(question, env);
   return correctness === 'correct' ? 1 : correctness === 'partial' && isPartialScoring ? getPartialScore(question, answers) : 0;
 };
 
-var outcome = (question, session, env) => {
+const outcome = (question, session, env) => {
   return new Promise(resolve => {
     if (env.mode !== 'evaluate') {
       resolve({
@@ -256,20 +194,19 @@ var outcome = (question, session, env) => {
         });
       }
 
-      var out = {
+      const out = {
         score: getOutComeScore(question, env, session.answers)
       };
       resolve(out);
     }
   });
 };
-function createDefaultModel() {
-  var model = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function createDefaultModel(model = {}) {
   return new Promise(resolve => {
-    resolve(_objectSpread(_objectSpread({}, defaults), model));
+    resolve(_extends({}, defaults, model));
   });
 }
-var normalize = question => _objectSpread(_objectSpread({}, defaults), question);
+const normalize = question => _extends({}, defaults, question);
 /**
  *
  * @param {*} question
@@ -279,90 +216,84 @@ var normalize = question => _objectSpread(_objectSpread({}, defaults), question)
  */
 
 function model(question, session, env, updateSession) {
-  return new Promise( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (resolve) {
-      var normalizedQuestion = cloneDeep(normalize(question));
-      var correctness, score;
-
-      if ((!session || isEmpty(session)) && env.mode === 'evaluate') {
-        correctness = 'unanswered';
-        score = '0%';
-      } else {
-        correctness = getCorrectness(normalizedQuestion, env, session && session.answers);
-        score = "".concat(getOutComeScore(normalizedQuestion, env, session && session.answers) * 100, "%");
-      }
+  return new Promise(async resolve => {
+    const normalizedQuestion = cloneDeep(normalize(question));
+    let correctness, score;
 
-      var correctResponse = {};
-      var correctInfo = {
-        score,
-        correctness
-      };
-      var lockChoiceOrder = lockChoices(normalizedQuestion, session, env);
+    if ((!session || isEmpty(session)) && env.mode === 'evaluate') {
+      correctness = 'unanswered';
+      score = '0%';
+    } else {
+      correctness = getCorrectness(normalizedQuestion, env, session && session.answers);
+      score = `${getOutComeScore(normalizedQuestion, env, session && session.answers) * 100}%`;
+    }
 
-      if (!lockChoiceOrder) {
-        normalizedQuestion.rows = yield getShuffledChoices(normalizedQuestion.rows, session, updateSession, 'id');
-      }
+    const correctResponse = {};
+    const correctInfo = {
+      score,
+      correctness
+    };
+    const lockChoiceOrder = lockChoices(normalizedQuestion, session, env);
 
-      normalizedQuestion.rows.forEach(row => {
-        correctResponse[row.id] = row.values;
+    if (!lockChoiceOrder) {
+      normalizedQuestion.rows = await getShuffledChoices(normalizedQuestion.rows, session, updateSession, 'id');
+    }
 
-        if (env.mode !== 'evaluate') {
-          delete row.values;
-        }
+    normalizedQuestion.rows.forEach(row => {
+      correctResponse[row.id] = row.values;
+
+      if (env.mode !== 'evaluate') {
+        delete row.values;
+      }
+    });
+    const fb = env.mode === 'evaluate' && normalizedQuestion.feedbackEnabled ? getFeedbackForCorrectness(correctInfo.correctness, normalizedQuestion.feedback) : Promise.resolve(undefined);
+    fb.then(feedback => {
+      const {
+        extraCSSRules,
+        feedbackEnabled,
+        promptEnabled,
+        prompt,
+        lockChoiceOrder
+      } = normalizedQuestion,
+            essentials = _objectWithoutPropertiesLoose(normalizedQuestion, _excluded);
+
+      const out = _extends({}, essentials, {
+        extraCSSRules,
+        allowFeedback: feedbackEnabled,
+        prompt: promptEnabled ? prompt : null,
+        shuffled: !lockChoiceOrder,
+        feedback,
+        disabled: env.mode !== 'gather',
+        view: env.mode === 'view'
       });
-      var fb = env.mode === 'evaluate' && normalizedQuestion.feedbackEnabled ? getFeedbackForCorrectness(correctInfo.correctness, normalizedQuestion.feedback) : Promise.resolve(undefined);
-      fb.then(feedback => {
-        var {
-          extraCSSRules,
-          feedbackEnabled,
-          promptEnabled,
-          prompt,
-          lockChoiceOrder
-        } = normalizedQuestion,
-            essentials = _objectWithoutProperties(normalizedQuestion, _excluded);
-
-        var out = _objectSpread(_objectSpread({}, essentials), {}, {
-          extraCSSRules,
-          allowFeedback: feedbackEnabled,
-          prompt: promptEnabled ? prompt : null,
-          shuffled: !lockChoiceOrder,
-          feedback,
-          disabled: env.mode !== 'gather',
-          view: env.mode === 'view'
-        });
 
-        if (env.role === 'instructor' && (env.mode === 'view' || env.mode === 'evaluate')) {
-          out.teacherInstructions = normalizedQuestion.teacherInstructionsEnabled ? normalizedQuestion.teacherInstructions : null;
-          out.rationale = normalizedQuestion.rationaleEnabled ? normalizedQuestion.rationale : null;
-        } else {
-          out.rationale = null;
-          out.teacherInstructions = null;
-        }
+      if (env.role === 'instructor' && (env.mode === 'view' || env.mode === 'evaluate')) {
+        out.teacherInstructions = normalizedQuestion.teacherInstructionsEnabled ? normalizedQuestion.teacherInstructions : null;
+        out.rationale = normalizedQuestion.rationaleEnabled ? normalizedQuestion.rationale : null;
+      } else {
+        out.rationale = null;
+        out.teacherInstructions = null;
+      }
 
-        if (env.mode === 'evaluate') {
-          Object.assign(out, {
-            correctResponse,
-            correctness: correctInfo
-          });
-        }
+      if (env.mode === 'evaluate') {
+        Object.assign(out, {
+          correctResponse,
+          correctness: correctInfo
+        });
+      }
 
-        log('out: ', out);
-        resolve(out);
-      });
+      log('out: ', out);
+      resolve(out);
     });
-
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }());
+  });
 }
-var createCorrectResponseSession = (question, env) => {
+const createCorrectResponseSession = (question, env) => {
   return new Promise(resolve => {
     if (env.mode !== 'evaluate' && env.role === 'instructor') {
-      var {
+      const {
         rows
       } = question;
-      var answers = {};
+      const answers = {};
       rows.forEach(r => {
         answers[r.id] = r.values;
       });
@@ -376,20 +307,18 @@ var createCorrectResponseSession = (question, env) => {
   });
 }; // remove all html tags
 
-var getInnerText = html => (html || '').replaceAll(/<[^>]*>/g, ''); // remove all html tags except img, iframe and source tag for audio
+const getInnerText = html => (html || '').replaceAll(/<[^>]*>/g, ''); // remove all html tags except img, iframe and source tag for audio
 
 
-var getContent = html => (html || '').replace(/(<(?!img|iframe|source)([^>]+)>)/gi, '');
+const getContent = html => (html || '').replace(/(<(?!img|iframe|source)([^>]+)>)/gi, '');
 
-var validate = function validate() {
-  var model = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var {
+const validate = (model = {}, config = {}) => {
+  const {
     rows,
     choiceMode,
     headers
   } = model;
-  var {
+  const {
     minQuestions,
     maxQuestions,
     maxLengthQuestionsHeading,
@@ -397,25 +326,25 @@ var validate = function validate() {
     maxLengthAnswers,
     maxLengthFirstColumnHeading
   } = config;
-  var rowsErrors = {};
-  var columnsErrors = {};
-  var errors = {};
+  const rowsErrors = {};
+  const columnsErrors = {};
+  const errors = {};
   ['teacherInstructions', 'prompt', 'rationale'].forEach(field => {
     var _config$field;
 
-    if ((_config$field = config[field]) !== null && _config$field !== void 0 && _config$field.required && !getContent(model[field])) {
+    if ((_config$field = config[field]) != null && _config$field.required && !getContent(model[field])) {
       errors[field] = 'This field is required.';
     }
   });
 
   if (rows.length < minQuestions) {
-    errors.noOfRowsError = "There should be at least ".concat(minQuestions, " question rows.");
+    errors.noOfRowsError = `There should be at least ${minQuestions} question rows.`;
   } else if (rows.length > maxQuestions) {
-    errors.noOfRowsError = "No more than ".concat(maxQuestions, " question rows should be defined.");
+    errors.noOfRowsError = `No more than ${maxQuestions} question rows should be defined.`;
   }
 
   (rows || []).forEach((row, index) => {
-    var {
+    const {
       id,
       values = [],
       title
@@ -423,21 +352,21 @@ var validate = function validate() {
     rowsErrors[id] = '';
 
     if (maxLengthQuestionsHeading && getInnerText(title).length > maxLengthQuestionsHeading) {
-      rowsErrors[id] += "Content length should be maximum ".concat(maxLengthQuestionsHeading, " characters. ");
+      rowsErrors[id] += `Content length should be maximum ${maxLengthQuestionsHeading} characters. `;
     }
 
     if (!getContent(title)) {
       rowsErrors[id] += 'Content should not be empty. ';
     } else {
       // check for identical content with the previous answers
-      var identicalAnswer = rows.slice(0, index).some(r => getContent(r.title) === getContent(title));
+      const identicalAnswer = rows.slice(0, index).some(r => getContent(r.title) === getContent(title));
 
       if (identicalAnswer) {
         rowsErrors[id] += 'Content should be unique. ';
       }
     }
 
-    var hasCorrectResponse = values.some(value => !!value);
+    const hasCorrectResponse = values.some(value => !!value);
 
     if (!hasCorrectResponse) {
       rowsErrors[id] += 'No correct response defined.';
@@ -445,48 +374,48 @@ var validate = function validate() {
   });
 
   if (maxAnswers && headers.length - 1 > maxAnswers) {
-    errors.columnsLengthError = "There should be maximum ".concat(maxAnswers, " answers.");
+    errors.columnsLengthError = `There should be maximum ${maxAnswers} answers.`;
   }
 
   if (maxLengthFirstColumnHeading && headers[0].length > maxLengthFirstColumnHeading) {
-    columnsErrors[0] = "Content length should be maximum ".concat(maxLengthFirstColumnHeading, " characters.");
+    columnsErrors[0] = `Content length should be maximum ${maxLengthFirstColumnHeading} characters.`;
   }
 
-  var headersContent = (headers || []).map(heading => getContent(heading));
+  const headersContent = (headers || []).map(heading => getContent(heading));
   headersContent.shift(); // remove first column since it does not require validation
 
   headersContent.forEach((heading, index) => {
-    var headerIndex = index + 1; // we need to add 1 because we removed first header from validation
+    const headerIndex = index + 1; // we need to add 1 because we removed first header from validation
 
     columnsErrors[headerIndex] = '';
 
     if (maxLengthAnswers && getInnerText(heading).length > maxLengthAnswers) {
-      columnsErrors[headerIndex] += "Content length should be maximum ".concat(maxLengthAnswers, " characters. ");
+      columnsErrors[headerIndex] += `Content length should be maximum ${maxLengthAnswers} characters. `;
     }
 
     if (!heading) {
       columnsErrors[headerIndex] += 'Content should not be empty.';
     } else {
       // check for identical content with the previous headers
-      var identicalAnswer = headersContent.slice(0, index).some(head => head === heading);
+      const identicalAnswer = headersContent.slice(0, index).some(head => head === heading);
 
       if (identicalAnswer) {
         columnsErrors[index + 1] += 'Content should be unique.';
       }
     }
   });
-  var hasRowErrors = Object.values(rowsErrors).some(error => (error || '').length);
+  const hasRowErrors = Object.values(rowsErrors).some(error => (error || '').length);
 
   if (hasRowErrors) {
     errors.rowsErrors = rowsErrors;
-    var noCorrectAnswer = Object.values(rowsErrors).some(error => (error || '').includes('No correct response defined.'));
+    const noCorrectAnswer = Object.values(rowsErrors).some(error => (error || '').includes('No correct response defined.'));
 
     if (noCorrectAnswer) {
       errors.correctResponseError = choiceMode === 'radio' ? 'There should be a correct response defined for every row.' : 'There should be at least one correct response defined for every row.';
     }
   }
 
-  var hasColumnErrors = Object.values(columnsErrors).some(error => (error || '').length);
+  const hasColumnErrors = Object.values(columnsErrors).some(error => (error || '').length);
 
   if (hasColumnErrors) {
     errors.columnsErrors = columnsErrors;