@pie-element/categorize 11.3.4-next.0 → 12.0.0-beta.0

package/controller/lib/index.js

@@ -1,144 +1,110 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.outcome = exports.normalize = exports.model = exports.getTotalScore = exports.getPartialScore = exports.getCorrectness = exports.createDefaultModel = exports.createCorrectResponseSession = void 0;
 Object.defineProperty(exports, "score", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _categorize.score;
   }
 });
 exports.validate = void 0;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
-
 var _categorize = require("@pie-lib/categorize");
-
 var _feedback = require("@pie-lib/feedback");
-
 var _controllerUtils = require("@pie-lib/controller-utils");
-
 var _translator = _interopRequireDefault(require("@pie-lib/translator"));
-
 var _defaults = _interopRequireDefault(require("./defaults"));
-
 var _utils = require("./utils");
+const {
+  translator
+} = _translator.default;
 
-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 translator = _translator["default"].translator;
+// eslint-disable-next-line no-console
 
-var getPartialScore = function getPartialScore(correctResponse, builtCategories) {
+const getPartialScore = (correctResponse, builtCategories) => {
   // in the resulted best scenario we make a sum with all the correct responses
   // and all the placements
-  var _builtCategories$redu = builtCategories.reduce(function (acc, _ref) {
-    var _ref$choices = _ref.choices,
-        choices = _ref$choices === void 0 ? [] : _ref$choices;
-    return {
-      placements: acc.placements + choices.length,
-      score: acc.score + choices.filter(function (ch) {
-        return ch.correct;
-      }).length
-    };
-  }, {
+  const {
+    placements,
+    score
+  } = builtCategories.reduce((acc, {
+    choices = []
+  }) => ({
+    placements: acc.placements + choices.length,
+    score: acc.score + choices.filter(ch => ch.correct).length
+  }), {
     placements: 0,
     score: 0
-  }),
-      placements = _builtCategories$redu.placements,
-      score = _builtCategories$redu.score; // in the correct response, we make a sum of the max possible score
-
+  });
 
-  var _correctResponse$redu = correctResponse.reduce(function (acc, _ref2) {
-    var choices = _ref2.choices;
-    return {
-      maxScore: acc.maxScore + choices.length
-    };
-  }, {
+  // in the correct response, we make a sum of the max possible score
+  const {
+    maxScore
+  } = correctResponse.reduce((acc, {
+    choices
+  }) => ({
+    maxScore: acc.maxScore + choices.length
+  }), {
     maxScore: 0
-  }),
-      maxScore = _correctResponse$redu.maxScore; // if there are any extra placements, we subtract from the obtained score
-
+  });
 
-  var extraPlacements = placements > maxScore ? placements - maxScore : 0;
-  var totalScore = (score - extraPlacements) / maxScore;
+  // if there are any extra placements, we subtract from the obtained score
+  const extraPlacements = placements > maxScore ? placements - maxScore : 0;
+  const totalScore = (score - extraPlacements) / maxScore;
   return totalScore < 0 ? 0 : parseFloat(totalScore.toFixed(2));
 };
-
 exports.getPartialScore = getPartialScore;
-
-var getAlternates = function getAlternates(correctResponse) {
-  return correctResponse.map(function (c) {
-    return c.alternateResponses;
-  }).filter(function (alternate) {
-    return alternate;
-  });
-};
-
-var getTotalScore = function getTotalScore(question, session, env) {
+const getAlternates = correctResponse => correctResponse.map(c => c.alternateResponses).filter(alternate => alternate);
+const getTotalScore = (question, session, env) => {
   if (!session) {
     return 0;
   }
-
   if (Object.keys(session).length === 0) {
     return 0;
   }
-
-  var _ref3 = question || {},
-      categories = _ref3.categories,
-      choices = _ref3.choices;
-
-  var _ref4 = question || {},
-      correctResponse = _ref4.correctResponse;
-
-  var _ref5 = session || {},
-      answers = _ref5.answers;
-
+  const {
+    categories,
+    choices
+  } = question || {};
+  let {
+    correctResponse
+  } = question || {};
+  let {
+    answers
+  } = session || {};
   answers = answers || [];
-  correctResponse = correctResponse || []; // this function is used in pie-ui/categorize as well, in order to get the best scenario
-  // so we get the best scenario and calculate the score
-
-  var _buildState = (0, _categorize.buildState)(categories, choices, answers, correctResponse),
-      builtCategories = _buildState.categories,
-      correct = _buildState.correct;
-
-  var alternates = getAlternates(correctResponse);
-
-  var enabled = _controllerUtils.partialScoring.enabled(question, env); // if there are any alternates, there will be no partial scoring!
-
+  correctResponse = correctResponse || [];
 
+  // this function is used in pie-ui/categorize as well, in order to get the best scenario
+  // so we get the best scenario and calculate the score
+  const {
+    categories: builtCategories,
+    correct
+  } = (0, _categorize.buildState)(categories, choices, answers, correctResponse);
+  const alternates = getAlternates(correctResponse);
+  const enabled = _controllerUtils.partialScoring.enabled(question, env);
+
+  // if there are any alternates, there will be no partial scoring!
   if (enabled && !alternates.length) {
     // we apply partial scoring
     return getPartialScore(correctResponse, builtCategories);
-  } // else we apply dichotomous
-
+  }
 
+  // else we apply dichotomous
   return correct ? 1 : 0;
 };
-
 exports.getTotalScore = getTotalScore;
-
-var getCorrectness = function getCorrectness(question, session, env) {
-  return new Promise(function (resolve) {
+const getCorrectness = (question, session, env) => {
+  return new Promise(resolve => {
     if (env.mode === 'evaluate') {
-      var _score = getTotalScore(question, session, env);
-
-      if (_score === 1) {
+      const score = getTotalScore(question, session, env);
+      if (score === 1) {
         resolve('correct');
-      } else if (_score === 0) {
+      } else if (score === 0) {
         resolve('incorrect');
       } else {
         resolve('partially-correct');
@@ -148,21 +114,19 @@ var getCorrectness = function getCorrectness(question, session, env) {
     }
   });
 };
-
 exports.getCorrectness = getCorrectness;
-
-var createDefaultModel = function createDefaultModel() {
-  var model = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  return new Promise(function (resolve) {
-    resolve(_objectSpread(_objectSpread({}, _defaults["default"]), model));
+const createDefaultModel = (model = {}) => new Promise(resolve => {
+  resolve({
+    ..._defaults.default,
+    ...model
   });
-};
-
+});
 exports.createDefaultModel = createDefaultModel;
+const normalize = question => ({
+  ..._defaults.default,
+  ...question
+});
 
-var normalize = function normalize(question) {
-  return _objectSpread(_objectSpread({}, _defaults["default"]), question);
-};
 /**
  *
  * @param {*} question
@@ -170,148 +134,129 @@ 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;
-
-var model = function model(question, session, env, updateSession) {
-  return new Promise( /*#__PURE__*/function () {
-    var _ref6 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(resolve) {
-      var normalizedQuestion, answerCorrectness, _ref7, mode, role, categories, categoriesPerRow, choicesLabel, choicesPosition, correctResponse, feedback, feedbackEnabled, promptEnabled, prompt, rowLabels, rationaleEnabled, rationale, teacherInstructionsEnabled, teacherInstructions, language, maxChoicesPerCategory, extraCSSRules, minRowHeight, fontSizeFactor, autoplayAudioEnabled, completeAudioEnabled, customAudioButton, choices, note, fb, lockChoiceOrder, filteredCorrectResponse, alternates, _getCompleteResponseD, responseAreasToBeFilled, possibleResponses, hasUnplacedChoices, out;
-
-      return _regenerator["default"].wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              normalizedQuestion = normalize(question);
-              _context.next = 3;
-              return getCorrectness(normalizedQuestion, session, env);
-
-            case 3:
-              answerCorrectness = _context.sent;
-              _ref7 = env || {}, mode = _ref7.mode, role = _ref7.role;
-              categories = normalizedQuestion.categories, categoriesPerRow = normalizedQuestion.categoriesPerRow, choicesLabel = normalizedQuestion.choicesLabel, choicesPosition = normalizedQuestion.choicesPosition, correctResponse = normalizedQuestion.correctResponse, feedback = normalizedQuestion.feedback, feedbackEnabled = normalizedQuestion.feedbackEnabled, promptEnabled = normalizedQuestion.promptEnabled, prompt = normalizedQuestion.prompt, rowLabels = normalizedQuestion.rowLabels, rationaleEnabled = normalizedQuestion.rationaleEnabled, rationale = normalizedQuestion.rationale, teacherInstructionsEnabled = normalizedQuestion.teacherInstructionsEnabled, teacherInstructions = normalizedQuestion.teacherInstructions, language = normalizedQuestion.language, maxChoicesPerCategory = normalizedQuestion.maxChoicesPerCategory, extraCSSRules = normalizedQuestion.extraCSSRules, minRowHeight = normalizedQuestion.minRowHeight, fontSizeFactor = normalizedQuestion.fontSizeFactor, autoplayAudioEnabled = normalizedQuestion.autoplayAudioEnabled, completeAudioEnabled = normalizedQuestion.completeAudioEnabled, customAudioButton = normalizedQuestion.customAudioButton;
-              choices = normalizedQuestion.choices, note = normalizedQuestion.note;
-              lockChoiceOrder = (0, _controllerUtils.lockChoices)(normalizedQuestion, session, env);
-              filteredCorrectResponse = correctResponse.map(function (response) {
-                var filteredChoices = (response.choices || []).filter(function (choice) {
-                  return choice !== 'null';
-                });
-                return _objectSpread(_objectSpread({}, response), {}, {
-                  choices: filteredChoices
-                });
-              });
-
-              if (!(mode === 'evaluate' && feedbackEnabled)) {
-                _context.next = 13;
-                break;
-              }
-
-              _context.next = 12;
-              return (0, _feedback.getFeedbackForCorrectness)(answerCorrectness, feedback);
-
-            case 12:
-              fb = _context.sent;
-
-            case 13:
-              if (lockChoiceOrder) {
-                _context.next = 17;
-                break;
-              }
-
-              _context.next = 16;
-              return (0, _controllerUtils.getShuffledChoices)(choices, session, updateSession, 'id');
-
-            case 16:
-              choices = _context.sent;
-
-            case 17:
-              if (!note) {
-                note = translator.t('common:commonCorrectAnswerWithAlternates', {
-                  lng: language
-                });
-              }
-
-              alternates = getAlternates(filteredCorrectResponse);
-              _getCompleteResponseD = (0, _utils.getCompleteResponseDetails)(filteredCorrectResponse, normalizedQuestion.allowAlternateEnabled ? alternates : [], normalizedQuestion.choices), responseAreasToBeFilled = _getCompleteResponseD.responseAreasToBeFilled, possibleResponses = _getCompleteResponseD.possibleResponses, hasUnplacedChoices = _getCompleteResponseD.hasUnplacedChoices;
-              out = {
-                categories: categories || [],
-                categoriesPerRow: categoriesPerRow || 2,
-                maxChoicesPerCategory: maxChoicesPerCategory,
-                correctness: answerCorrectness,
-                choices: choices || [],
-                choicesLabel: choicesLabel || '',
-                choicesPosition: choicesPosition,
-                disabled: mode !== 'gather',
-                feedback: fb,
-                lockChoiceOrder: lockChoiceOrder,
-                prompt: promptEnabled ? prompt : null,
-                rowLabels: rowLabels,
-                note: note,
-                env: env,
-                showNote: alternates && alternates.length > 0,
-                correctResponse: mode === 'evaluate' ? filteredCorrectResponse : undefined,
-                language: language,
-                extraCSSRules: extraCSSRules,
-                fontSizeFactor: fontSizeFactor,
-                minRowHeight: minRowHeight,
-                autoplayAudioEnabled: autoplayAudioEnabled,
-                completeAudioEnabled: completeAudioEnabled,
-                customAudioButton: customAudioButton,
-                possibleResponses: possibleResponses,
-                responseAreasToBeFilled: responseAreasToBeFilled,
-                hasUnplacedChoices: hasUnplacedChoices
-              };
-
-              if (role === 'instructor' && (mode === 'view' || mode === 'evaluate')) {
-                out.rationale = rationaleEnabled ? rationale : null;
-                out.teacherInstructions = teacherInstructionsEnabled ? teacherInstructions : null;
-              } else {
-                out.rationale = null;
-                out.teacherInstructions = null;
-              }
-
-              resolve(out);
-
-            case 23:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee);
-    }));
-
-    return function (_x) {
-      return _ref6.apply(this, arguments);
+const model = async (question, session, env, updateSession) => {
+  const normalizedQuestion = normalize(question);
+  const answerCorrectness = await getCorrectness(normalizedQuestion, session, env);
+  const {
+    mode,
+    role
+  } = env || {};
+  const {
+    categories,
+    categoriesPerRow,
+    choicesLabel,
+    choicesPosition,
+    correctResponse,
+    feedback,
+    feedbackEnabled,
+    promptEnabled,
+    prompt,
+    rowLabels,
+    rationaleEnabled,
+    rationale,
+    teacherInstructionsEnabled,
+    teacherInstructions,
+    language,
+    maxChoicesPerCategory,
+    extraCSSRules,
+    minRowHeight,
+    fontSizeFactor,
+    autoplayAudioEnabled,
+    completeAudioEnabled,
+    customAudioButton
+  } = normalizedQuestion;
+  let {
+    choices,
+    note
+  } = normalizedQuestion;
+  let fb;
+  const lockChoiceOrder = (0, _controllerUtils.lockChoices)(normalizedQuestion, session, env);
+  const filteredCorrectResponse = correctResponse.map(response => {
+    const filteredChoices = (response.choices || []).filter(choice => choice !== 'null');
+    return {
+      ...response,
+      choices: filteredChoices
     };
-  }());
+  });
+  if (mode === 'evaluate' && feedbackEnabled) {
+    fb = await (0, _feedback.getFeedbackForCorrectness)(answerCorrectness, feedback);
+  }
+  if (!lockChoiceOrder) {
+    choices = await (0, _controllerUtils.getShuffledChoices)(choices, session, updateSession, 'id');
+  }
+  if (!note) {
+    note = translator.t('common:commonCorrectAnswerWithAlternates', {
+      lng: language
+    });
+  }
+  const alternates = getAlternates(filteredCorrectResponse);
+  const {
+    responseAreasToBeFilled,
+    possibleResponses,
+    hasUnplacedChoices
+  } = (0, _utils.getCompleteResponseDetails)(filteredCorrectResponse, normalizedQuestion.allowAlternateEnabled ? alternates : [], normalizedQuestion.choices);
+  const out = {
+    categories: categories || [],
+    categoriesPerRow: categoriesPerRow || 2,
+    maxChoicesPerCategory,
+    correctness: answerCorrectness,
+    choices: choices || [],
+    choicesLabel: choicesLabel || '',
+    choicesPosition,
+    disabled: mode !== 'gather',
+    feedback: fb,
+    lockChoiceOrder,
+    prompt: promptEnabled ? prompt : null,
+    rowLabels,
+    note,
+    env,
+    showNote: alternates && alternates.length > 0,
+    correctResponse: mode === 'evaluate' ? filteredCorrectResponse : undefined,
+    language,
+    extraCSSRules,
+    fontSizeFactor,
+    minRowHeight: minRowHeight,
+    autoplayAudioEnabled,
+    completeAudioEnabled,
+    customAudioButton,
+    possibleResponses,
+    responseAreasToBeFilled,
+    hasUnplacedChoices
+  };
+  if (role === 'instructor' && (mode === 'view' || mode === 'evaluate')) {
+    out.rationale = rationaleEnabled ? rationale : null;
+    out.teacherInstructions = teacherInstructionsEnabled ? teacherInstructions : null;
+  } else {
+    out.rationale = null;
+    out.teacherInstructions = null;
+  }
+  return out;
 };
-
 exports.model = model;
-
-var outcome = function outcome(question, session, env) {
+const outcome = (question, session, env) => {
   if (env.mode !== 'evaluate') {
     return Promise.reject(new Error('Can not call outcome when mode is not evaluate'));
   } else {
-    return new Promise(function (resolve) {
+    return new Promise(resolve => {
       resolve({
         score: getTotalScore(question, session, env),
-        empty: !session || (0, _isEmpty["default"])(session)
+        empty: !session || (0, _isEmpty.default)(session)
       });
     });
   }
 };
-
 exports.outcome = outcome;
-
-var createCorrectResponseSession = function createCorrectResponseSession(question, env) {
-  return new Promise(function (resolve) {
-    var _ref8 = env || {},
-        mode = _ref8.mode,
-        role = _ref8.role;
-
+const createCorrectResponseSession = (question, env) => {
+  return new Promise(resolve => {
+    const {
+      mode,
+      role
+    } = env || {};
     if (mode !== 'evaluate' && role === 'instructor') {
-      var correctResponse = question.correctResponse;
+      const {
+        correctResponse
+      } = question;
       resolve({
         answers: correctResponse,
         id: 1
@@ -320,151 +265,125 @@ var createCorrectResponseSession = function createCorrectResponseSession(questio
       return 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 categories = model.categories,
-      choices = model.choices,
-      correctResponse = model.correctResponse,
-      maxAnswerChoices = model.maxAnswerChoices;
-  var _config$minChoices = config.minChoices,
-      minChoices = _config$minChoices === void 0 ? 1 : _config$minChoices,
-      _config$minCategories = config.minCategories,
-      minCategories = _config$minCategories === void 0 ? 1 : _config$minCategories,
-      _config$maxCategories = config.maxCategories,
-      maxCategories = _config$maxCategories === void 0 ? 12 : _config$maxCategories,
-      _config$maxLengthPerC = config.maxLengthPerChoice,
-      maxLengthPerChoice = _config$maxLengthPerC === void 0 ? 300 : _config$maxLengthPerC,
-      _config$maxLengthPerC2 = config.maxLengthPerCategory,
-      maxLengthPerCategory = _config$maxLengthPerC2 === void 0 ? 150 : _config$maxLengthPerC2;
-  var reversedChoices = (0, _toConsumableArray2["default"])(choices || []).reverse();
-  var errors = {};
-  var choicesErrors = {};
-  var categoriesErrors = {};
-  ['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 {
+    categories,
+    choices,
+    correctResponse,
+    maxAnswerChoices
+  } = model;
+  const {
+    minChoices = 1,
+    minCategories = 1,
+    maxCategories = 12,
+    maxLengthPerChoice = 300,
+    maxLengthPerCategory = 150
+  } = config;
+  const reversedChoices = [...(choices || [])].reverse();
+  const errors = {};
+  const choicesErrors = {};
+  const categoriesErrors = {};
+  ['teacherInstructions', 'prompt', 'rationale'].forEach(field => {
+    if (config[field]?.required && !getContent(model[field])) {
       errors[field] = 'This field is required.';
     }
   });
-  (categories || []).forEach(function (category) {
-    var id = category.id,
-        label = category.label;
-
+  (categories || []).forEach(category => {
+    const {
+      id,
+      label
+    } = category;
     if (getInnerText(label).length > maxLengthPerCategory) {
-      categoriesErrors[id] = "Category labels should be no more than ".concat(maxLengthPerCategory, " characters long.");
+      categoriesErrors[id] = `Category labels should be no more than ${maxLengthPerCategory} characters long.`;
     }
   });
-  (reversedChoices || []).forEach(function (choice, index) {
-    var id = choice.id,
-        content = choice.content;
-
+  (reversedChoices || []).forEach((choice, index) => {
+    const {
+      id,
+      content
+    } = choice;
     if (getInnerText(content).length > maxLengthPerChoice) {
-      choicesErrors[id] = "Tokens should be no more than ".concat(maxLengthPerChoice, " characters long.");
+      choicesErrors[id] = `Tokens should be no more than ${maxLengthPerChoice} characters long.`;
     }
-
     if (!getContent(content)) {
       choicesErrors[id] = 'Tokens should not be empty.';
     } else {
-      var identicalAnswer = reversedChoices.slice(index + 1).some(function (c) {
-        return c.content === content;
-      });
-
+      const identicalAnswer = reversedChoices.slice(index + 1).some(c => c.content === content);
       if (identicalAnswer) {
         choicesErrors[id] = 'Tokens content should be unique.';
       }
     }
   });
-  var nbOfCategories = (categories || []).length;
-  var nbOfChoices = (choices || []).length;
-
+  const nbOfCategories = (categories || []).length;
+  const nbOfChoices = (choices || []).length;
   if (nbOfCategories > maxCategories) {
-    errors.categoriesError = "No more than ".concat(maxCategories, " categories should be defined.");
+    errors.categoriesError = `No more than ${maxCategories} categories should be defined.`;
   } else if (nbOfCategories < minCategories) {
-    errors.categoriesError = "There should be at least ".concat(minCategories, " category defined.");
+    errors.categoriesError = `There should be at least ${minCategories} category defined.`;
   }
-
   if (nbOfChoices < minChoices) {
-    errors.choicesError = "There should be at least ".concat(minChoices, " choices defined.");
+    errors.choicesError = `There should be at least ${minChoices} choices defined.`;
   } else if (nbOfChoices > maxAnswerChoices) {
-    errors.choicesError = "No more than ".concat(maxAnswerChoices, " choices should be defined.");
+    errors.choicesError = `No more than ${maxAnswerChoices} choices should be defined.`;
   }
-
   if (nbOfChoices && nbOfCategories) {
-    var hasAssociations = false;
-    (correctResponse || []).forEach(function (response) {
-      var _response$choices = response.choices,
-          choices = _response$choices === void 0 ? [] : _response$choices,
-          _response$alternateRe = response.alternateResponses,
-          alternateResponses = _response$alternateRe === void 0 ? [] : _response$alternateRe;
-
+    let hasAssociations = false;
+    (correctResponse || []).forEach(response => {
+      const {
+        choices = [],
+        alternateResponses = []
+      } = response;
       if (choices.length) {
         hasAssociations = true;
       } else {
-        alternateResponses.forEach(function (alternate) {
+        alternateResponses.forEach(alternate => {
           if ((alternate || []).length) {
             hasAssociations = true;
           }
         });
       }
     });
-    var duplicateAlternateIndex = -1;
-    var duplicateCategory = '';
-    (correctResponse || []).forEach(function (response) {
-      var _response$choices2 = response.choices,
-          choices = _response$choices2 === void 0 ? [] : _response$choices2,
-          _response$alternateRe2 = response.alternateResponses,
-          alternateResponses = _response$alternateRe2 === void 0 ? [] : _response$alternateRe2,
-          category = response.category;
-
+    let duplicateAlternateIndex = -1;
+    let duplicateCategory = '';
+    (correctResponse || []).forEach(response => {
+      const {
+        choices = [],
+        alternateResponses = [],
+        category
+      } = response;
       if (duplicateAlternateIndex === -1) {
         duplicateAlternateIndex = (0, _utils.isCorrectResponseDuplicated)(choices, alternateResponses);
-
         if (duplicateAlternateIndex === -1) {
           duplicateAlternateIndex = (0, _utils.isAlternateDuplicated)(alternateResponses);
         }
-
         duplicateCategory = category;
       }
     });
-
     if (duplicateAlternateIndex > -1) {
       errors.duplicateAlternate = {
         index: duplicateAlternateIndex,
         category: duplicateCategory
       };
     }
-
     if (!hasAssociations) {
       errors.associationError = 'At least one token should be assigned to at least one category.';
     }
   }
-
-  if (!(0, _isEmpty["default"])(choicesErrors)) {
+  if (!(0, _isEmpty.default)(choicesErrors)) {
     errors.choicesErrors = choicesErrors;
   }
-
-  if (!(0, _isEmpty["default"])(categoriesErrors)) {
+  if (!(0, _isEmpty.default)(categoriesErrors)) {
     errors.categoriesErrors = categoriesErrors;
   }
-
   return errors;
 };
-
 exports.validate = validate;
 //# sourceMappingURL=index.js.map