@pie-element/categorize 11.0.1 → 11.0.2-esm.0

package/esm/controller.js

@@ -5,83 +5,50 @@ import { getFeedbackForCorrectness } from '@pie-lib/feedback';
 import { partialScoring, lockChoices, getShuffledChoices } from '@pie-lib/controller-utils';
 import Translator from '@pie-lib/translator';
 
-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);
+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];
+        }
       }
+    }
 
-      _next(undefined);
-    });
+    return target;
   };
-}
-
-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;
+  return _extends.apply(this, arguments);
 }
 
 // used in configure too, for consistency modify it there too
-var multiplePlacements = {
+const multiplePlacements = {
   enabled: 'Yes',
   disabled: 'No',
   perChoice: 'Set Per Choice'
 }; // used to validate the config
 
-var isCorrectResponseDuplicated = (choices, alternate) => {
+const isCorrectResponseDuplicated = (choices, alternate) => {
   if (choices.length < 1 || alternate.length < 1) {
     return -1;
   }
 
-  var stringChoices = JSON.stringify(choices.sort());
-  var stringAlternate = alternate.reduce((total, current) => current.length > 0 ? [...total, JSON.stringify(current.sort())] : total, []);
-  var foundIndexDuplicate = stringAlternate.findIndex(alternate => alternate.length && alternate === stringChoices);
+  const stringChoices = JSON.stringify(choices.sort());
+  const stringAlternate = alternate.reduce((total, current) => current.length > 0 ? [...total, JSON.stringify(current.sort())] : total, []);
+  const foundIndexDuplicate = stringAlternate.findIndex(alternate => alternate.length && alternate === stringChoices);
   return foundIndexDuplicate;
 };
-var isAlternateDuplicated = alternate => {
+const isAlternateDuplicated = alternate => {
   if (alternate.length <= 1) {
     return -1;
   }
 
-  var elementSet = new Set();
-  var stringAlternate = alternate.reduce((total, current) => current.length > 0 ? [...total, JSON.stringify(current.sort())] : total, []);
+  const elementSet = new Set();
+  const stringAlternate = alternate.reduce((total, current) => current.length > 0 ? [...total, JSON.stringify(current.sort())] : total, []);
 
-  for (var i = 0; i < stringAlternate.length; i++) {
+  for (let i = 0; i < stringAlternate.length; i++) {
     if (elementSet.has(stringAlternate[i]) && stringAlternate[i]) {
       return i;
     }
@@ -118,52 +85,43 @@ var defaults = {
   minRowHeight: '80px'
 };
 
-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 {
+const {
   translator
 } = Translator;
-var 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 {
+  const {
     placements,
     score
-  } = builtCategories.reduce((acc, _ref) => {
-    var {
-      choices = []
-    } = _ref;
-    return {
-      placements: acc.placements + choices.length,
-      score: acc.score + choices.filter(ch => ch.correct).length
-    };
-  }, {
+  } = builtCategories.reduce((acc, {
+    choices: _choices = []
+  }) => ({
+    placements: acc.placements + _choices.length,
+    score: acc.score + _choices.filter(ch => ch.correct).length
+  }), {
     placements: 0,
     score: 0
   }); // in the correct response, we make a sum of the max possible score
 
-  var {
+  const {
     maxScore
-  } = correctResponse.reduce((acc, _ref2) => {
-    var {
-      choices
-    } = _ref2;
-    return {
-      maxScore: acc.maxScore + choices.length
-    };
-  }, {
+  } = correctResponse.reduce((acc, {
+    choices
+  }) => ({
+    maxScore: acc.maxScore + choices.length
+  }), {
     maxScore: 0
   }); // if there are any extra placements, we subtract from the obtained score
 
-  var extraPlacements = placements > maxScore ? placements - maxScore : 0;
-  var totalScore = (score - extraPlacements) / maxScore;
+  const extraPlacements = placements > maxScore ? placements - maxScore : 0;
+  const totalScore = (score - extraPlacements) / maxScore;
   return totalScore < 0 ? 0 : parseFloat(totalScore.toFixed(2));
 };
 
-var getAlternates = correctResponse => correctResponse.map(c => c.alternateResponses).filter(alternate => alternate);
+const getAlternates = correctResponse => correctResponse.map(c => c.alternateResponses).filter(alternate => alternate);
 
-var getTotalScore = (question, session, env) => {
+const getTotalScore = (question, session, env) => {
   if (!session) {
     return 0;
   }
@@ -172,26 +130,26 @@ var getTotalScore = (question, session, env) => {
     return 0;
   }
 
-  var {
+  const {
     categories,
     choices
   } = question || {};
-  var {
+  let {
     correctResponse
   } = question || {};
-  var {
+  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 {
+  const {
     categories: builtCategories,
     correct
   } = buildState(categories, choices, answers, correctResponse);
-  var alternates = getAlternates(correctResponse);
-  var enabled = partialScoring.enabled(question, env); // if there are any alternates, there will be no partial scoring!
+  const alternates = getAlternates(correctResponse);
+  const enabled = partialScoring.enabled(question, env); // if there are any alternates, there will be no partial scoring!
 
   if (enabled && !alternates.length) {
     // we apply partial scoring
@@ -201,14 +159,14 @@ var getTotalScore = (question, session, env) => {
 
   return correct ? 1 : 0;
 };
-var getCorrectness = (question, session, env) => {
+const getCorrectness = (question, session, env) => {
   return new Promise(resolve => {
     if (env.mode === 'evaluate') {
-      var _score = getTotalScore(question, session, env);
+      const score = getTotalScore(question, session, env);
 
-      if (_score === 1) {
+      if (score === 1) {
         resolve('correct');
-      } else if (_score === 0) {
+      } else if (score === 0) {
         resolve('incorrect');
       } else {
         resolve('partially-correct');
@@ -218,13 +176,10 @@ var getCorrectness = (question, session, env) => {
     }
   });
 };
-var createDefaultModel = function createDefaultModel() {
-  var model = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  return new Promise(resolve => {
-    resolve(_objectSpread(_objectSpread({}, defaults), model));
-  });
-};
-var normalize = question => _objectSpread(_objectSpread({}, defaults), question);
+const createDefaultModel = (model = {}) => new Promise(resolve => {
+  resolve(_extends({}, defaults, model));
+});
+const normalize = question => _extends({}, defaults, question);
 /**
  *
  * @param {*} question
@@ -233,108 +188,102 @@ var normalize = question => _objectSpread(_objectSpread({}, defaults), question)
  * @param {*} updateSession - optional - a function that will set the properties passed into it on the session.
  */
 
-var model = (question, session, env, updateSession) => new Promise( /*#__PURE__*/function () {
-  var _ref3 = _asyncToGenerator(function* (resolve) {
-    var normalizedQuestion = normalize(question);
-    var answerCorrectness = yield getCorrectness(normalizedQuestion, session, env);
-    var {
-      mode,
-      role
-    } = env || {};
-    var {
-      categories,
-      categoriesPerRow,
-      choicesLabel,
-      choicesPosition,
-      correctResponse,
-      feedback,
-      feedbackEnabled,
-      promptEnabled,
-      prompt,
-      rowLabels,
-      rationaleEnabled,
-      rationale,
-      teacherInstructionsEnabled,
-      teacherInstructions,
-      language,
-      maxChoicesPerCategory,
-      extraCSSRules,
-      minRowHeight,
-      fontSizeFactor,
-      autoplayAudioEnabled,
-      completeAudioEnabled,
-      customAudioButton
-    } = normalizedQuestion;
-    var {
-      choices,
-      note
-    } = normalizedQuestion;
-    var fb;
-    var lockChoiceOrder = lockChoices(normalizedQuestion, session, env);
-    var filteredCorrectResponse = correctResponse.map(response => {
-      var filteredChoices = (response.choices || []).filter(choice => choice !== 'null');
-      return _objectSpread(_objectSpread({}, response), {}, {
-        choices: filteredChoices
-      });
+const model = (question, session, env, updateSession) => new Promise(async resolve => {
+  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 = lockChoices(normalizedQuestion, session, env);
+  const filteredCorrectResponse = correctResponse.map(response => {
+    const filteredChoices = (response.choices || []).filter(choice => choice !== 'null');
+    return _extends({}, response, {
+      choices: filteredChoices
     });
+  });
 
-    if (mode === 'evaluate' && feedbackEnabled) {
-      fb = yield getFeedbackForCorrectness(answerCorrectness, feedback);
-    }
+  if (mode === 'evaluate' && feedbackEnabled) {
+    fb = await getFeedbackForCorrectness(answerCorrectness, feedback);
+  }
 
-    if (!lockChoiceOrder) {
-      choices = yield getShuffledChoices(choices, session, updateSession, 'id');
-    }
+  if (!lockChoiceOrder) {
+    choices = await getShuffledChoices(choices, session, updateSession, 'id');
+  }
 
-    if (!note) {
-      note = translator.t('common:commonCorrectAnswerWithAlternates', {
-        lng: language
-      });
-    }
+  if (!note) {
+    note = translator.t('common:commonCorrectAnswerWithAlternates', {
+      lng: language
+    });
+  }
 
-    var alternates = getAlternates(filteredCorrectResponse);
-    var 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
-    };
-
-    if (role === 'instructor' && (mode === 'view' || mode === 'evaluate')) {
-      out.rationale = rationaleEnabled ? rationale : null;
-      out.teacherInstructions = teacherInstructionsEnabled ? teacherInstructions : null;
-    } else {
-      out.rationale = null;
-      out.teacherInstructions = null;
-    }
+  const alternates = getAlternates(filteredCorrectResponse);
+  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
+  };
 
-    resolve(out);
-  });
+  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 function (_x) {
-    return _ref3.apply(this, arguments);
-  };
-}());
-var outcome = (question, session, env) => {
+  resolve(out);
+});
+const outcome = (question, session, env) => {
   if (env.mode !== 'evaluate') {
     return Promise.reject(new Error('Can not call outcome when mode is not evaluate'));
   } else {
@@ -346,15 +295,15 @@ var outcome = (question, session, env) => {
     });
   }
 };
-var createCorrectResponseSession = (question, env) => {
+const createCorrectResponseSession = (question, env) => {
   return new Promise(resolve => {
-    var {
+    const {
       mode,
       role
     } = env || {};
 
     if (mode !== 'evaluate' && role === 'instructor') {
-      var {
+      const {
         correctResponse
       } = question;
       resolve({
@@ -367,87 +316,85 @@ 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 {
     categories,
     choices,
     correctResponse,
     maxAnswerChoices
   } = model;
-  var {
+  const {
     minChoices = 1,
     minCategories = 1,
     maxCategories = 12,
     maxLengthPerChoice = 300,
     maxLengthPerCategory = 150
   } = config;
-  var reversedChoices = [...(choices || [])].reverse();
-  var errors = {};
-  var choicesErrors = {};
-  var categoriesErrors = {};
+  const reversedChoices = [...(choices || [])].reverse();
+  const errors = {};
+  const choicesErrors = {};
+  const categoriesErrors = {};
   ['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.';
     }
   });
   (categories || []).forEach(category => {
-    var {
+    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((choice, index) => {
-    var {
+    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(c => 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;
+    let hasAssociations = false;
     (correctResponse || []).forEach(response => {
-      var {
+      const {
         choices = [],
         alternateResponses = []
       } = response;
@@ -462,10 +409,10 @@ var validate = function validate() {
         });
       }
     });
-    var duplicateAlternateIndex = -1;
-    var duplicateCategory = '';
+    let duplicateAlternateIndex = -1;
+    let duplicateCategory = '';
     (correctResponse || []).forEach(response => {
-      var {
+      const {
         choices = [],
         alternateResponses = [],
         category