@pie-element/extended-text-entry 10.1.2 → 10.2.0

package/module/controller.js

@@ -0,0 +1,248 @@
+var feedback$1 = {};
+
+var feedback = {};
+
+var interopRequireDefault = {exports: {}};
+
+(function (module) {
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    "default": obj
+  };
+}
+
+module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}(interopRequireDefault));
+
+var defineProperty = {exports: {}};
+
+(function (module) {
+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;
+}
+
+module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}(defineProperty));
+
+var _interopRequireDefault = interopRequireDefault.exports;
+
+Object.defineProperty(feedback, "__esModule", {
+  value: true
+});
+feedback.getFeedbackForCorrectness = feedback.getFeedback = feedback.defaults = void 0;
+
+var _defineProperty2 = _interopRequireDefault(defineProperty.exports);
+
+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 defaults$1 = {
+  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'
+  }
+};
+/**
+ * @typedef {Object} FeedbackConfig
+ * @property {'default'|'none'|'custom'} type
+ * @property {string} default
+ * @property {string} custom
+ *
+ * @typedef {Object} Feedback
+ *  @property {FeedbackConfig} correct
+ *  @property {FeedbackConfig} incorrect
+ *  @property {FeedbackConfig} partial
+ */
+
+feedback.defaults = defaults$1;
+
+var normalizeCorrectness = function normalizeCorrectness(c) {
+  if (c === 'partially-correct') {
+    return 'partial';
+  }
+
+  return c;
+};
+/**
+ * Get the feedback for the correctness
+ *
+ * @param {'correct'|'incorrect'|'partial'} correctness
+ * @param {Feedback} feedback
+ */
+
+
+var getFeedbackForCorrectness = function getFeedbackForCorrectness(correctness, feedback) {
+  return new Promise(function (resolve) {
+    feedback = _objectSpread(_objectSpread({}, defaults$1), feedback);
+    correctness = normalizeCorrectness(correctness);
+    var fb = feedback[correctness] || defaults$1[correctness] || {};
+    var d = defaults$1[correctness] || {};
+    getFeedback(fb, d[fb.type || 'default']).then(function (result) {
+      return resolve(result);
+    });
+  });
+};
+/**
+ * Get the feedback from a {FeedbackConfig}
+ *
+ * @param {FeedbackConfig} feedback
+ * @param {string} fallback
+ */
+
+
+feedback.getFeedbackForCorrectness = getFeedbackForCorrectness;
+
+var getFeedback = function getFeedback(feedback, fallback) {
+  return new Promise(function (resolve) {
+    if (!feedback || feedback.type === 'none') {
+      resolve(undefined);
+      return;
+    }
+
+    feedback = feedback || {};
+    var out = feedback[feedback.type] || fallback;
+    resolve(out);
+  });
+};
+
+feedback.getFeedback = getFeedback;
+
+(function (exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "defaults", {
+  enumerable: true,
+  get: function get() {
+    return _feedback.defaults;
+  }
+});
+Object.defineProperty(exports, "getFeedback", {
+  enumerable: true,
+  get: function get() {
+    return _feedback.getFeedback;
+  }
+});
+Object.defineProperty(exports, "getFeedbackForCorrectness", {
+  enumerable: true,
+  get: function get() {
+    return _feedback.getFeedbackForCorrectness;
+  }
+});
+
+var _feedback = feedback;
+
+}(feedback$1));
+
+var defaults = {
+  dimensions: {
+    height: 100,
+    width: 500,
+  },
+};
+
+async function createDefaultModel(model = {}) {
+
+  return {
+    ...defaults,
+    ...model,
+  };
+}
+
+const normalize = (question) => ({
+  ...defaults,
+  feedbackEnabled: false,
+  rationaleEnabled: true,
+  promptEnabled: true,
+  teacherInstructionsEnabled: true,
+  studentInstructionsEnabled: true,
+  playerSpellCheckDisabled: true,
+  ...question,
+});
+
+async function model(question, session, env) {
+  const normalizedQuestion = normalize(question);
+
+  const fb =
+    env.mode === 'evaluate' && normalizedQuestion.feedbackEnabled
+      ? feedback$1.getFeedback(normalizedQuestion.feedback, 'Your answer has been submitted')
+      : Promise.resolve(undefined);
+
+  let teacherInstructions = null;
+  if (env.role === 'instructor' && (env.mode === 'view' || env.mode === 'evaluate')) {
+    teacherInstructions = normalizedQuestion.teacherInstructionsEnabled ? normalizedQuestion.teacherInstructions : null;
+  } else {
+    teacherInstructions = null;
+  }
+
+  let equationEditor = normalizedQuestion.equationEditor || 'miscellaneous';
+
+  switch (normalizedQuestion.equationEditor) {
+    case 'Grade 1 - 2':
+      equationEditor = 1;
+      break;
+    case 'Grade 3 - 5':
+      equationEditor = 3;
+      break;
+    case 'Grade 6 - 7':
+      equationEditor = 6;
+      break;
+    case 'Grade 8 - HS':
+      equationEditor = 8;
+      break;
+  }
+
+  return fb.then((feedback) => ({
+    prompt: normalizedQuestion.promptEnabled ? normalizedQuestion.prompt : null,
+    dimensions: normalizedQuestion.dimensions,
+    customKeys: normalizedQuestion.customKeys || [],
+    disabled: env.mode !== 'gather',
+    feedback,
+    teacherInstructions,
+    mathInput: normalizedQuestion.mathInput,
+    spanishInput: normalizedQuestion.spanishInput,
+    specialInput: normalizedQuestion.specialInput,
+    equationEditor,
+    spellCheckEnabled: !normalizedQuestion.playerSpellCheckDisabled,
+    playersToolbarPosition: normalizedQuestion.playersToolbarPosition || 'bottom',
+  }));
+}
+
+async function outcome(/*question, session, env*/) {
+  return {
+    score: 0,
+    completed: 'n/a',
+    note: 'Requires manual scoring',
+  };
+}
+
+export { createDefaultModel, model, normalize, outcome };

package/module/demo.js

@@ -0,0 +1,37 @@
+import Configure from './configure.js';
+import Element from './element.js';
+import * as controller from './controller.js';
+
+var generate = {};
+
+generate.model = (id, element) => ({
+  id,
+  element,
+  customKeys: ['\\square'],
+  feedback: { type: 'default', default: 'this is default feedback' },
+  prompt: 'This is the question prompt',
+  promptEnabled: true,
+  mathInput: true,
+  playersToolbarPosition: 'bottom',
+  toolbarEditorPosition: 'bottom',
+  spellCheckEnabled: true,
+  rubricEnabled: false,
+});
+
+const { model } = generate;
+var config = {
+  elements: {
+    'extended-text-entry': '../..',
+  },
+  models: [model('1', 'extended-text-entry')],
+};
+
+//Note: demo-el is a custom element loaded in the markup.
+  customElements.whenDefined("demo-el").then(() => {
+    config.models.forEach((m) => {
+      const de = document.createElement("demo-el");
+      document.body.appendChild(de);
+      de.def = { tagName: m.element, Element, Configure, controller };
+      de.model = m;
+    });
+  });