@pie-element/select-text 11.2.1 → 11.2.2-next.11

package/module/controller.js

@@ -972,46 +972,17 @@ function isEmpty(value) {
 
 var isEmpty_1 = isEmpty;
 
-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);
-}
-
 const defaults$1 = {
-  correct: {
-    type: 'default',
-    default: 'Correct',
-    custom: 'Correct'
-  },
-  incorrect: {
-    type: 'default',
-    default: 'Incorrect',
-    custom: 'Incorrect'
-  },
-  partial: {
-    type: 'default',
-    default: 'Nearly',
-    custom: 'Nearly'
-  },
+  correct: { type: 'default', default: 'Correct', custom: 'Correct' },
+  incorrect: { type: 'default', default: 'Incorrect', custom: 'Incorrect' },
+  partial: { type: 'default', default: 'Nearly', custom: 'Nearly' },
   unanswered: {
     type: 'default',
     default: 'You have not entered a response',
-    custom: 'You have not entered a response'
-  }
+    custom: 'You have not entered a response',
+  },
 };
+
 /**
  * @typedef {Object} FeedbackConfig
  * @property {'default'|'none'|'custom'} type
@@ -1024,45 +995,64 @@ const defaults$1 = {
  *  @property {FeedbackConfig} partial
  */
 
-const normalizeCorrectness = c => {
+const normalizeCorrectness = (c) => {
   if (c === 'partially-correct') {
     return 'partial';
   }
-
   return c;
 };
+
 /**
  * Get the feedback for the correctness
  *
  * @param {'correct'|'incorrect'|'partial'} correctness
  * @param {Feedback} feedback
  */
+const getFeedbackForCorrectness = (correctness, feedback) =>
+  new Promise((resolve) => {
+    feedback = { ...defaults$1, ...feedback };
+    correctness = normalizeCorrectness(correctness);
+    const fb = feedback[correctness] || defaults$1[correctness] || {};
+    const d = defaults$1[correctness] || {};
+    getFeedback(fb, d[fb.type || 'default']).then((result) => resolve(result));
+  });
 
-
-const getFeedbackForCorrectness = (correctness, feedback) => new Promise(resolve => {
-  feedback = _extends({}, defaults$1, feedback);
-  correctness = normalizeCorrectness(correctness);
-  const fb = feedback[correctness] || defaults$1[correctness] || {};
-  const d = defaults$1[correctness] || {};
-  getFeedback(fb, d[fb.type || 'default']).then(result => resolve(result));
-});
 /**
  * Get the feedback from a {FeedbackConfig}
  *
  * @param {FeedbackConfig} feedback
  * @param {string} fallback
  */
+const getFeedback = (feedback, fallback) =>
+  new Promise((resolve) => {
+    if (!feedback || feedback.type === 'none') {
+      resolve(undefined);
+      return;
+    }
+    feedback = feedback || {};
+    const out = feedback[feedback.type] || fallback;
+    resolve(out);
+  });
 
-const getFeedback = (feedback, fallback) => new Promise(resolve => {
-  if (!feedback || feedback.type === 'none') {
-    resolve(undefined);
-    return;
+const enabled = (config, env, defaultValue) => {
+  // if model.partialScoring = false
+  //  - if env.partialScoring = false || env.partialScoring = true => use dichotomous scoring
+  // else if model.partialScoring = true || undefined
+  //  - if env.partialScoring = false, use dichotomous scoring
+  //  - else if env.partialScoring = true, use partial scoring
+  config = config || {};
+  env = env || {};
+
+  if (config.partialScoring === false) {
+    return false;
+  }
+
+  if (env.partialScoring === false) {
+    return false;
   }
 
-  feedback = feedback || {};
-  const out = feedback[feedback.type] || fallback;
-  resolve(out);
-}); // TODO: should replace getFeedbackForCorrectness
+  return typeof defaultValue === 'boolean' ? defaultValue : true;
+};
 
 var getNative = _getNative;
 
@@ -1727,33 +1717,8 @@ var Symbol = _Symbol;
 var symbolProto = Symbol ? Symbol.prototype : undefined;
     symbolProto ? symbolProto.toString : undefined;
 
-const enabled = (config, env, defaultValue) => {
-  // if model.partialScoring = false
-  //  - if env.partialScoring = false || env.partialScoring = true => use dichotomous scoring
-  // else if model.partialScoring = true || undefined
-  //  - if env.partialScoring = false, use dichotomous scoring
-  //  - else if env.partialScoring = true, use partial scoring
-  config = config || {};
-  env = env || {};
-
-  if (config.partialScoring === false) {
-    return false;
-  }
-
-  if (env.partialScoring === false) {
-    return false;
-  }
-
-  return typeof defaultValue === 'boolean' ? defaultValue : true;
-};
-
-var partialScoring = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  enabled: enabled
-});
-
-const lg = n => console[n].bind(console, 'controller-utils:');
-
+// eslint-disable-next-line no-console
+const lg = (n) => console[n].bind(console, 'controller-utils:');
 lg('debug');
 lg('log');
 lg('warn');
@@ -1849,11 +1814,11 @@ const outcome = (question, session, env) =>
     if (env.mode !== 'evaluate') {
       resolve({ score: undefined, completed: undefined });
     } else {
-      const enabled = partialScoring.enabled(question, env, true);
+      const enabled$1 = enabled(question, env, true);
       const totalCorrect = question.tokens.filter((t) => t.correct);
       const score = getPartialScore(question, session, totalCorrect);
       resolve({
-        score: enabled ? score : score === 1 ? 1 : 0,
+        score: enabled$1 ? score : score === 1 ? 1 : 0,
       });
     }
   });