@pie-element/match 11.0.5-esm.1 → 11.1.2-next.1

package/controller/lib/index.js

@@ -1,7 +1,6 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -9,61 +8,29 @@ exports.createCorrectResponseSession = void 0;
 exports.createDefaultModel = createDefaultModel;
 exports.model = model;
 exports.validate = exports.outcome = exports.normalize = void 0;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
-
-var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
-
-var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
-
+var _lodashEs = require("lodash-es");
 var _feedback = require("@pie-lib/feedback");
-
 var _controllerUtils = require("@pie-lib/controller-utils");
-
 var _debug = _interopRequireDefault(require("debug"));
-
 var _defaults = _interopRequireDefault(require("./defaults"));
-
-var _excluded = ["extraCSSRules", "feedbackEnabled", "promptEnabled", "prompt", "lockChoiceOrder"];
-
-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) { (0, _defineProperty2["default"])(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 = (0, _debug["default"])('@pie-element:match:controller');
-
-var getResponseCorrectness = function getResponseCorrectness(model, answers) {
-  var env = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
-  var isPartialScoring = _controllerUtils.partialScoring.enabled(model, env);
-
-  var rows = model.rows;
-  var checkboxMode = model.choiceMode === 'checkbox';
-
+const log = (0, _debug.default)('@pie-element:match:controller');
+const getResponseCorrectness = (model, answers, env = {}) => {
+  const isPartialScoring = _controllerUtils.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 {
     correctAnswers = getCorrectRadios(rows, answers);
   }
-
   if (totalCorrectAnswers === correctAnswers && !incorrectAnswers) {
     return 'correct';
   } else if (correctAnswers === 0) {
@@ -71,26 +38,20 @@ var getResponseCorrectness = function getResponseCorrectness(model, answers) {
   } else if (isPartialScoring) {
     return 'partial';
   }
-
   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 = function getCheckboxes(rows, answers) {
-  var correctAnswers = 0;
-  var incorrectAnswers = 0;
-  rows.forEach(function (row) {
-    var answer = answers[row.id];
-
+const getCheckboxes = (rows, answers) => {
+  let correctAnswers = 0;
+  let incorrectAnswers = 0;
+  rows.forEach(row => {
+    const answer = answers[row.id];
     if (answer) {
-      row.values.forEach(function (v, i) {
+      row.values.forEach((v, i) => {
         if (answer[i] && answer[i] === v) {
           correctAnswers += 1;
         } else if (answer[i] && answer[i] !== v) {
@@ -100,31 +61,28 @@ var getCheckboxes = function getCheckboxes(rows, answers) {
     }
   });
   return {
-    correctAnswers: correctAnswers,
-    incorrectAnswers: incorrectAnswers
+    correctAnswers,
+    incorrectAnswers
   };
 };
-
-var getCorrectRadios = function getCorrectRadios(rows, answers) {
-  var correctAnswers = 0;
-  rows.forEach(function (row) {
-    if ((0, _isEqual["default"])(row.values, answers[row.id])) {
+const getCorrectRadios = (rows, answers) => {
+  let correctAnswers = 0;
+  rows.forEach(row => {
+    if ((0, _lodashEs.isEqual)(row.values, answers[row.id])) {
       correctAnswers += 1;
     }
   });
   return correctAnswers;
 };
-
-var getTotalCorrect = function 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 = function getTotalCorrectAnswers(question) {
-  var noOfTotalCorrectAnswers = 0;
-  question.rows.forEach(function (row) {
-    row.values.forEach(function (value) {
+const getTotalCorrectAnswers = question => {
+  let noOfTotalCorrectAnswers = 0;
+  question.rows.forEach(row => {
+    row.values.forEach(value => {
       if (value) {
         noOfTotalCorrectAnswers += 1;
       }
@@ -132,78 +90,68 @@ var getTotalCorrectAnswers = function getTotalCorrectAnswers(question) {
   });
   return noOfTotalCorrectAnswers;
 };
-
-var getPartialScore = function getPartialScore(question, answers) {
-  var checkboxMode = question.choiceMode === 'checkbox';
-
+const getPartialScore = (question, answers) => {
+  const checkboxMode = question.choiceMode === 'checkbox';
   if (checkboxMode) {
-    var _getCheckboxes = getCheckboxes(question.rows, answers),
-        correctAnswers = _getCheckboxes.correctAnswers,
-        incorrectAnswers = _getCheckboxes.incorrectAnswers;
-
-    var totalCorrect = getTotalCorrectAnswers(question);
-    var total = totalCorrect === 0 ? 1 : totalCorrect;
-
+    const {
+      correctAnswers,
+      incorrectAnswers
+    } = getCheckboxes(question.rows, answers);
+    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 = _controllerUtils.partialScoring.enabled(question, env);
-
+const getOutComeScore = (question, env, answers = {}) => {
+  const correctness = getCorrectness(question, env, answers);
+  const isPartialScoring = _controllerUtils.partialScoring.enabled(question, env);
   return correctness === 'correct' ? 1 : correctness === 'partial' && isPartialScoring ? getPartialScore(question, answers) : 0;
 };
-
-var outcome = function outcome(question, session, env) {
-  return new Promise(function (resolve) {
+const outcome = (question, session, env) => {
+  return new Promise(resolve => {
     if (env.mode !== 'evaluate') {
       resolve({
         score: undefined,
         completed: undefined
       });
     } else {
-      if (!session || (0, _isEmpty["default"])(session)) {
+      if (!session || (0, _lodashEs.isEmpty)(session)) {
         resolve({
           score: 0,
           empty: true
         });
       }
-
-      var out = {
+      const out = {
         score: getOutComeScore(question, env, session.answers)
       };
       resolve(out);
     }
   });
 };
-
 exports.outcome = outcome;
-
-function createDefaultModel() {
-  var model = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  return new Promise(function (resolve) {
-    resolve(_objectSpread(_objectSpread({}, _defaults["default"]), model));
+function createDefaultModel(model = {}) {
+  return new Promise(resolve => {
+    resolve({
+      ..._defaults.default,
+      ...model
+    });
   });
 }
+const normalize = question => ({
+  ..._defaults.default,
+  ...question
+});
 
-var normalize = function normalize(question) {
-  return _objectSpread(_objectSpread({}, _defaults["default"]), question);
-};
 /**
  *
  * @param {*} question
@@ -211,258 +159,182 @@ var normalize = function normalize(question) {
  * @param {*} env
  * @param {*} updateSession - optional - a function that will set the properties passed into it on the session.
  */
-
-
 exports.normalize = normalize;
-
-function model(question, session, env, updateSession) {
-  return new Promise( /*#__PURE__*/function () {
-    var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(resolve) {
-      var normalizedQuestion, correctness, score, correctResponse, correctInfo, lockChoiceOrder, fb;
-      return _regenerator["default"].wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              normalizedQuestion = (0, _cloneDeep["default"])(normalize(question));
-
-              if ((!session || (0, _isEmpty["default"])(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, "%");
-              }
-
-              correctResponse = {};
-              correctInfo = {
-                score: score,
-                correctness: correctness
-              };
-              lockChoiceOrder = (0, _controllerUtils.lockChoices)(normalizedQuestion, session, env);
-
-              if (lockChoiceOrder) {
-                _context.next = 9;
-                break;
-              }
-
-              _context.next = 8;
-              return (0, _controllerUtils.getShuffledChoices)(normalizedQuestion.rows, session, updateSession, 'id');
-
-            case 8:
-              normalizedQuestion.rows = _context.sent;
-
-            case 9:
-              normalizedQuestion.rows.forEach(function (row) {
-                correctResponse[row.id] = row.values;
-
-                if (env.mode !== 'evaluate') {
-                  delete row.values;
-                }
-              });
-              fb = env.mode === 'evaluate' && normalizedQuestion.feedbackEnabled ? (0, _feedback.getFeedbackForCorrectness)(correctInfo.correctness, normalizedQuestion.feedback) : Promise.resolve(undefined);
-              fb.then(function (feedback) {
-                var extraCSSRules = normalizedQuestion.extraCSSRules,
-                    feedbackEnabled = normalizedQuestion.feedbackEnabled,
-                    promptEnabled = normalizedQuestion.promptEnabled,
-                    prompt = normalizedQuestion.prompt,
-                    lockChoiceOrder = normalizedQuestion.lockChoiceOrder,
-                    essentials = (0, _objectWithoutProperties2["default"])(normalizedQuestion, _excluded);
-
-                var out = _objectSpread(_objectSpread({}, essentials), {}, {
-                  extraCSSRules: extraCSSRules,
-                  allowFeedback: feedbackEnabled,
-                  prompt: promptEnabled ? prompt : null,
-                  shuffled: !lockChoiceOrder,
-                  feedback: 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.mode === 'evaluate') {
-                  Object.assign(out, {
-                    correctResponse: correctResponse,
-                    correctness: correctInfo
-                  });
-                }
-
-                log('out: ', out);
-                resolve(out);
-              });
-
-            case 12:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee);
-    }));
-
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }());
+async function model(question, session, env, updateSession) {
+  const normalizedQuestion = (0, _lodashEs.cloneDeep)(normalize(question));
+  let correctness, score;
+  if ((!session || (0, _lodashEs.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}%`;
+  }
+  const correctResponse = {};
+  const correctInfo = {
+    score,
+    correctness
+  };
+  const lockChoiceOrder = (0, _controllerUtils.lockChoices)(normalizedQuestion, session, env);
+  if (!lockChoiceOrder) {
+    normalizedQuestion.rows = await (0, _controllerUtils.getShuffledChoices)(normalizedQuestion.rows, session, updateSession, 'id');
+  }
+  normalizedQuestion.rows.forEach(row => {
+    correctResponse[row.id] = row.values;
+    if (env.mode !== 'evaluate') {
+      delete row.values;
+    }
+  });
+  const feedback = env.mode === 'evaluate' && normalizedQuestion.feedbackEnabled ? await (0, _feedback.getFeedbackForCorrectness)(correctInfo.correctness, normalizedQuestion.feedback) : undefined;
+  const {
+    extraCSSRules,
+    feedbackEnabled,
+    promptEnabled,
+    prompt,
+    lockChoiceOrder: _,
+    ...essentials
+  } = normalizedQuestion;
+  const out = {
+    ...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.mode === 'evaluate') {
+    Object.assign(out, {
+      correctResponse,
+      correctness: correctInfo
+    });
+  }
+  log('out: ', out);
+  return out;
 }
-
-var createCorrectResponseSession = function createCorrectResponseSession(question, env) {
-  return new Promise(function (resolve) {
+const createCorrectResponseSession = (question, env) => {
+  return new Promise(resolve => {
     if (env.mode !== 'evaluate' && env.role === 'instructor') {
-      var rows = question.rows;
-      var answers = {};
-      rows.forEach(function (r) {
+      const {
+        rows
+      } = question;
+      const answers = {};
+      rows.forEach(r => {
         answers[r.id] = r.values;
       });
       resolve({
-        answers: answers,
+        answers,
         id: '1'
       });
     } else {
       resolve(null);
     }
   });
-}; // remove all html tags
-
-
-exports.createCorrectResponseSession = createCorrectResponseSession;
-
-var getInnerText = function getInnerText(html) {
-  return (html || '').replaceAll(/<[^>]*>/g, '');
-}; // remove all html tags except img, iframe and source tag for audio
-
-
-var getContent = function getContent(html) {
-  return (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 rows = model.rows,
-      choiceMode = model.choiceMode,
-      headers = model.headers;
-  var minQuestions = config.minQuestions,
-      maxQuestions = config.maxQuestions,
-      maxLengthQuestionsHeading = config.maxLengthQuestionsHeading,
-      maxAnswers = config.maxAnswers,
-      maxLengthAnswers = config.maxLengthAnswers,
-      maxLengthFirstColumnHeading = config.maxLengthFirstColumnHeading;
-  var rowsErrors = {};
-  var columnsErrors = {};
-  var errors = {};
-  ['teacherInstructions', 'prompt', 'rationale'].forEach(function (field) {
-    var _config$field;
-
-    if ((_config$field = config[field]) !== null && _config$field !== void 0 && _config$field.required && !getContent(model[field])) {
+// remove all html tags
+exports.createCorrectResponseSession = createCorrectResponseSession;
+const getInnerText = html => (html || '').replaceAll(/<[^>]*>/g, '');
+
+// remove all html tags except img, iframe and source tag for audio
+const getContent = html => (html || '').replace(/(<(?!img|iframe|source)([^>]+)>)/gi, '');
+const validate = (model = {}, config = {}) => {
+  const {
+    rows,
+    choiceMode,
+    headers
+  } = model;
+  const {
+    minQuestions,
+    maxQuestions,
+    maxLengthQuestionsHeading,
+    maxAnswers,
+    maxLengthAnswers,
+    maxLengthFirstColumnHeading
+  } = config;
+  const rowsErrors = {};
+  const columnsErrors = {};
+  const errors = {};
+  ['teacherInstructions', 'prompt', 'rationale'].forEach(field => {
+    if (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(function (row, index) {
-    var id = row.id,
-        _row$values = row.values,
-        values = _row$values === void 0 ? [] : _row$values,
-        title = row.title;
+  (rows || []).forEach((row, index) => {
+    const {
+      id,
+      values = [],
+      title
+    } = row;
     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(function (r) {
-        return 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(function (value) {
-      return !!value;
-    });
-
+    const hasCorrectResponse = values.some(value => !!value);
     if (!hasCorrectResponse) {
       rowsErrors[id] += 'No correct response defined.';
     }
   });
-
   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(function (heading) {
-    return getContent(heading);
-  });
+  const headersContent = (headers || []).map(heading => getContent(heading));
   headersContent.shift(); // remove first column since it does not require validation
 
-  headersContent.forEach(function (heading, index) {
-    var headerIndex = index + 1; // we need to add 1 because we removed first header from validation
-
+  headersContent.forEach((heading, index) => {
+    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(function (head) {
-        return 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(function (error) {
-    return (error || '').length;
-  });
-
+  const hasRowErrors = Object.values(rowsErrors).some(error => (error || '').length);
   if (hasRowErrors) {
     errors.rowsErrors = rowsErrors;
-    var noCorrectAnswer = Object.values(rowsErrors).some(function (error) {
-      return (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(function (error) {
-    return (error || '').length;
-  });
-
+  const hasColumnErrors = Object.values(columnsErrors).some(error => (error || '').length);
   if (hasColumnErrors) {
     errors.columnsErrors = columnsErrors;
   }
-
   return errors;
 };
-
 exports.validate = validate;
 //# sourceMappingURL=index.js.map