@pie-element/select-text 11.0.1 → 11.0.3-esm.0

package/module/controller.js

@@ -972,17 +972,46 @@ 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
@@ -995,64 +1024,45 @@ 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 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;
+const getFeedback = (feedback, fallback) => new Promise(resolve => {
+  if (!feedback || feedback.type === 'none') {
+    resolve(undefined);
+    return;
   }
 
-  return typeof defaultValue === 'boolean' ? defaultValue : true;
-};
+  feedback = feedback || {};
+  const out = feedback[feedback.type] || fallback;
+  resolve(out);
+}); // TODO: should replace getFeedbackForCorrectness
 
 var getNative = _getNative;
 
@@ -1717,8 +1727,33 @@ var Symbol = _Symbol;
 var symbolProto = Symbol ? Symbol.prototype : undefined;
     symbolProto ? symbolProto.toString : undefined;
 
-// eslint-disable-next-line no-console
-const lg = (n) => console[n].bind(console, 'controller-utils:');
+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:');
+
 lg('debug');
 lg('log');
 lg('warn');
@@ -1814,11 +1849,11 @@ const outcome = (question, session, env) =>
     if (env.mode !== 'evaluate') {
       resolve({ score: undefined, completed: undefined });
     } else {
-      const enabled$1 = enabled(question, env, true);
+      const enabled = partialScoring.enabled(question, env, true);
       const totalCorrect = question.tokens.filter((t) => t.correct);
       const score = getPartialScore(question, session, totalCorrect);
       resolve({
-        score: enabled$1 ? score : score === 1 ? 1 : 0,
+        score: enabled ? score : score === 1 ? 1 : 0,
       });
     }
   });