@pie-element/graphing 8.0.1-next.0 → 8.0.1

package/esm/controller.js

@@ -0,0 +1,846 @@
+import debug from 'debug';
+import cloneDeep from 'lodash/cloneDeep';
+import uniqWith from 'lodash/uniqWith';
+import isEmpty from 'lodash/isEmpty';
+import isEqual from 'lodash/isEqual';
+import lodash from 'lodash';
+import differenceWith from 'lodash/differenceWith';
+import { pointsToABC, pointsToAForAbsolute, pointsToABForExponential, getAmplitudeAndFreq } from '@pie-lib/graphing-utils';
+import { partialScoring } from '@pie-lib/controller-utils';
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  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;
+}
+
+// TODO: This is lifted from @pie-lib/graphing, however importing this will break a controller build because it has jsx source in that package.
+var allTools = ['circle', 'line', 'label', 'parabola', 'point', 'polygon', 'ray', 'segment', 'sine', 'vector' // 'absolute', // - not available as default
+// 'exponential', // - not available as default
+];
+/* model defaults */
+
+var defaults = {
+  answers: {
+    correctAnswer: {
+      name: 'Correct Answer',
+      marks: []
+    }
+  },
+  arrows: {
+    left: true,
+    right: true,
+    up: true,
+    down: true
+  },
+  backgroundMarks: [],
+  coordinatesOnHover: false,
+  defaultGridConfiguration: 0,
+  domain: {
+    min: -5,
+    max: 5,
+    step: 1,
+    labelStep: 1,
+    axisLabel: 'x'
+  },
+  graph: {
+    width: 500,
+    height: 500
+  },
+  includeAxes: true,
+  labels: {},
+  labelsEnabled: true,
+  padding: true,
+  prompt: '',
+  promptEnabled: true,
+  range: {
+    min: -5,
+    max: 5,
+    step: 1,
+    labelStep: 1,
+    axisLabel: 'y'
+  },
+  rationale: '',
+  rationaleEnabled: true,
+  standardGrid: false,
+  studentInstructionsEnabled: true,
+  teacherInstructions: '',
+  teacherInstructionsEnabled: true,
+  title: '',
+  titleEnabled: true,
+  toolbarTools: allTools
+};
+
+function ownKeys$1(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$1(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var equalPoint = (A, B) => {
+  A = _objectSpread$1({}, A);
+  B = _objectSpread$1({}, B);
+
+  if (A.label || B.label) {
+    isEqual(A.label, B.label);
+  }
+
+  return isEqual(A.x, B.x) && isEqual(A.y, B.y);
+};
+var equalSegment = (segment1, segment2) => {
+  // A.from = B.from, A.to = B.to OR A.from = B.to, A.to = B.from
+  // x1 = x3 & y1 = y3 & x2 = x4 & y2 = y4
+  return isEqual(segment1.from, segment2.from) && isEqual(segment1.to, segment2.to) || isEqual(segment1.to, segment2.from) && isEqual(segment1.from, segment2.to);
+};
+var equalVector = (vector1, vector2) => {
+  // A.from = B.from, A.to = B.to;
+  // x1 = x3 & y1 = y3 & x2 = x4 & y2 = y4
+  return isEqual(vector1.from, vector2.from) && isEqual(vector1.to, vector2.to);
+}; // this function is implemented in configure as well
+
+var sortedAnswers = answers => Object.keys(answers || {}).sort().reduce((result, key) => {
+  if (key !== 'correctAnswer') {
+    result[key] = answers[key];
+  }
+
+  return result;
+}, {});
+
+var returnLineEquationCoefficients = line => {
+  line = _objectSpread$1(_objectSpread$1({}, line), {}, {
+    to: _objectSpread$1({}, line.to),
+    from: _objectSpread$1({}, line.from)
+  });
+  var xA = line.from.x;
+  var yA = line.from.y;
+  var xB = line.to.x;
+  var yB = line.to.y;
+  return {
+    a: yB - yA,
+    b: xA - xB,
+    c: xB * yA - xA * yB
+  };
+};
+
+var getSignificantDecimals = number => Math.round(number * 10000) / 10000;
+
+var equalLine = (line1, line2) => {
+  // line equation: ax + by + c = 0
+  // 2 lines are equal if a1/a2 = b1/b2 = c1/c2, where a, b, c are the coefficients in line equation
+  // line equation knowing 2 points: (y - yA) / (yB - yA) = (x - xA) / (xB - xA)
+  // extending this equation, we get: x * (yB - yA) + y * (xA - xB) + (xB * yA - xA * yB) = 0
+  // where a = yB - yA; b = xA - xB; c = xB * yA - xA * yB
+  var {
+    a: a1,
+    b: b1,
+    c: c1
+  } = returnLineEquationCoefficients(line1);
+  var {
+    a: a2,
+    b: b2,
+    c: c2
+  } = returnLineEquationCoefficients(line2);
+  var proportions = [];
+
+  if (a2 !== 0) {
+    proportions.push(getSignificantDecimals(a1 / a2));
+  } else if (a1 !== a2) {
+    return false;
+  }
+
+  if (b2 !== 0) {
+    proportions.push(getSignificantDecimals(b1 / b2));
+  } else if (b1 !== b2) {
+    return false;
+  }
+
+  if (c2 !== 0) {
+    proportions.push(getSignificantDecimals(c1 / c2));
+  } else if (c1 !== c2) {
+    return false;
+  }
+
+  return lodash.uniq(proportions).length === 1; // (y2 - y1)/(x2 - x1) = (y4 - y3)/(x4 - x3);
+  // return ((Math.abs((line1.to.y - line1.from.y) / (line1.to.x - line1.from.x))) === (Math.abs((line2.to.y - line2.from.y) / (line2.to.x - line2.from.x))));
+};
+var equalRay = (ray1, ray2) => {
+  ray1 = _objectSpread$1(_objectSpread$1({}, ray1), {}, {
+    to: _objectSpread$1({}, ray1.to),
+    from: _objectSpread$1({}, ray1.from)
+  });
+  ray2 = _objectSpread$1(_objectSpread$1({}, ray2), {}, {
+    to: _objectSpread$1({}, ray2.to),
+    from: _objectSpread$1({}, ray2.from)
+  }); // slope: m = (y2-y1)/(x2-x1)
+  // slope & x1 = x3 & y1 = y3 & angle between (x1, y1) (x2, y2) is same as angle between (x3, y3) (x4, y4)
+
+  var mRay1 = (ray1.to.y - ray1.from.y) / (ray1.to.x - ray1.from.x);
+  var mRay2 = (ray2.to.y - ray2.from.y) / (ray2.to.x - ray2.from.x);
+  var angleRay1 = Math.atan2(ray1.to.y - ray1.from.y, ray1.to.x - ray1.from.x) * 180 / Math.PI;
+  var angleRay2 = Math.atan2(ray2.to.y - ray2.from.y, ray2.to.x - ray2.from.x) * 180 / Math.PI;
+  return mRay1 === mRay2 && ray1.from.x === ray2.from.x && ray1.from.y === ray2.from.y && angleRay1 === angleRay2;
+};
+var constructSegmentsFromPoints = points => {
+  // takes the list of points that represent a polygon and transforms it into a list of segments; eg.:
+  // points: A, B, C, D => segments: AB, BC, CD, DA
+  return (points || []).map((point, index) => ({
+    from: point,
+    to: points[(index + 1) % points.length]
+  }));
+};
+var removeDuplicateSegments = segments => {
+  segments = segments || []; // removes segments that are duplicates; eg. These segments are the same, so one will be removed:
+  // segment1: from: { x: 1, y: 1 }, to: { x: 2, y: 1 }
+  // segment2: from: { x: 2, y: 1 }, to: { x: 1, y: 1 }
+
+  return uniqWith(segments, (s1, s2) => equalSegment(s1, s2));
+};
+var removeInvalidSegments = segments => {
+  segments = segments || []; // removes segments that start in a point and end in the same point (eg.: from: { x: 1, y: 1 }, to: { x: 1, y: 1 })
+
+  return segments.filter(segment => !isEqual(segment.from, segment.to));
+};
+var equalPolygon = (poly1, poly2) => {
+  var {
+    points: points1
+  } = poly1;
+  var {
+    points: points2
+  } = poly2; // generate segments
+
+  var segments1 = constructSegmentsFromPoints(points1);
+  var segments2 = constructSegmentsFromPoints(points2);
+  var segments1NoDuplicates = removeDuplicateSegments(removeInvalidSegments(segments1));
+  var segments2NoDuplicates = removeDuplicateSegments(removeInvalidSegments(segments2));
+  var differentSegments1 = differenceWith(segments1NoDuplicates, segments2NoDuplicates, equalSegment);
+  var differentSegments2 = differenceWith(segments2NoDuplicates, segments1NoDuplicates, equalSegment);
+  return (!differentSegments1 || !differentSegments1.length) && (!differentSegments2 || !differentSegments2.length);
+};
+var equalCircle = (c1, c2) => {
+  c1 = _objectSpread$1(_objectSpread$1({}, c1), {}, {
+    root: _objectSpread$1({}, c1.root),
+    edge: _objectSpread$1({}, c1.edge)
+  });
+  c2 = _objectSpread$1(_objectSpread$1({}, c2), {}, {
+    root: _objectSpread$1({}, c2.root),
+    edge: _objectSpread$1({}, c2.edge)
+  });
+  var equalRootAndEdge = isEqual(c2.edge, c1.edge) && isEqual(c2.root, c1.root); // if both edge and root are the same, it means the shapes are exactly the same
+
+  if (equalRootAndEdge) return true;
+  var rC1 = Math.sqrt((c1.edge.x - c1.root.x) ** 2 + (c1.edge.y - c1.root.y) ** 2);
+  var rC2 = Math.sqrt((c2.edge.x - c2.root.x) ** 2 + (c2.edge.y - c2.root.y) ** 2); // if both root and radius are the same, it means the shapes are equal
+
+  return isEqual(c2.root, c1.root) && isEqual(rC1, rC2);
+};
+var equalSine = (sine1, sine2) => {
+  var getPoints = _ref => {
+    var {
+      root,
+      edge
+    } = _ref;
+    root = _objectSpread$1({}, root);
+    edge = _objectSpread$1({}, edge);
+    var {
+      amplitude,
+      freq
+    } = getAmplitudeAndFreq(root, edge); // the height of the sine wave
+
+    var tY = Math.abs(root.y - edge.y) * 2; // the distance on x axis between edge and root
+
+    var tXRoot = Math.abs(root.x - edge.x); // the distance on x axis between 2 edges for sine wave (min & max)
+
+    var tX = tXRoot * 2; // the first edge placed east side of root
+
+    var edgeAboveZeroX = edge.x;
+    var edgeAboveZeroY = edge.y; // if edge less then 0, find out the appropriate edge placed east side of zero (0)
+
+    while (edgeAboveZeroX < 0 && tX !== 0) {
+      edgeAboveZeroX = edgeAboveZeroX + tX;
+      edgeAboveZeroY = edgeAboveZeroY < root.y ? edgeAboveZeroY + tY : edgeAboveZeroY - tY;
+    } // if edge more then 0, find out the appropriate edge placed east side of zero (0)
+
+
+    while (edgeAboveZeroX - tX > 0 && tX !== 0) {
+      edgeAboveZeroX = edgeAboveZeroX - tX;
+      edgeAboveZeroY = edgeAboveZeroY < root.y ? edgeAboveZeroY + tY : edgeAboveZeroY - tY;
+    }
+
+    return {
+      amplitude: getSignificantDecimals(amplitude),
+      freq: getSignificantDecimals(freq),
+      min: getSignificantDecimals(edge.y < root.y ? edge.y : edge.y - tY),
+      max: getSignificantDecimals(edge.y < root.y ? edge.y + tY : edge.y),
+      edgeAboveZeroX: getSignificantDecimals(edgeAboveZeroX),
+      edgeAboveZeroY: getSignificantDecimals(edgeAboveZeroY)
+    };
+  };
+
+  var studentAnswerBpY = getPoints(sine1);
+  var correctAnswerBpY = getPoints(sine2);
+  var {
+    amplitude: amplitude1,
+    freq: freq1,
+    min: min1,
+    max: max1,
+    edgeAboveZeroX: edgeAboveZeroX1,
+    edgeAboveZeroY: edgeAboveZeroY1
+  } = studentAnswerBpY;
+  var {
+    amplitude: amplitude2,
+    freq: freq2,
+    min: min2,
+    max: max2,
+    edgeAboveZeroX: edgeAboveZeroX2,
+    edgeAboveZeroY: edgeAboveZeroY2
+  } = correctAnswerBpY;
+  return Math.abs(amplitude1) === Math.abs(amplitude2) && Math.abs(freq1) === Math.abs(freq2) && min1 === min2 && max1 === max2 && edgeAboveZeroX1 === edgeAboveZeroX2 && edgeAboveZeroY1 === edgeAboveZeroY2; // rootDiff1 === rootDiff2);
+};
+var equalParabola = (p1, p2) => {
+  var {
+    edge: edgeP1
+  } = p1;
+  var {
+    edge: edgeP2
+  } = p2;
+  var {
+    root: rootP1
+  } = p1;
+  var {
+    root: rootP2
+  } = p2;
+  rootP1 = _objectSpread$1({}, rootP1);
+  rootP2 = _objectSpread$1({}, rootP2);
+
+  var p1edge = edgeP1 || _objectSpread$1({}, rootP1);
+
+  var p2edge = edgeP2 || _objectSpread$1({}, rootP2);
+
+  var p1mirrorEdge = {
+    x: rootP1.x - (p1edge.x - rootP1.x),
+    y: p1edge.y
+  };
+  var p2mirrorEdge = {
+    x: rootP2.x - (p2edge.x - rootP2.x),
+    y: p2edge.y
+  };
+  if (!edgeP1 || !edgeP2) return false;
+  var {
+    a: a1,
+    b: b1,
+    c: c1
+  } = pointsToABC(rootP1, edgeP1, p1mirrorEdge);
+  var {
+    a: a2,
+    b: b2,
+    c: c2
+  } = pointsToABC(rootP2, edgeP2, p2mirrorEdge); // sometimes numbers have this form: 1.00000000002 because of calculations, we have to round them
+
+  var round = number => Math.round(number * 10000) / 10000;
+
+  return round(a1) === round(a2) && round(b1) === round(b2) && round(c1) === round(c2);
+};
+/*
+ * Function to check if given two points for absolute function
+ * for correct answer and student answer are equal or not.
+ * @param p1 - student answer
+ * @param p2 - correct answer
+ * */
+
+var equalAbsolute = (p1, p2) => {
+  var {
+    edge: edgeP1
+  } = p1;
+  var {
+    edge: edgeP2
+  } = p2;
+  var {
+    root: rootP1
+  } = p1;
+  var {
+    root: rootP2
+  } = p2;
+  rootP1 = _objectSpread$1({}, rootP1);
+  rootP2 = _objectSpread$1({}, rootP2);
+
+  var p1edge = edgeP1 || _objectSpread$1({}, rootP1);
+
+  var p2edge = edgeP2 || _objectSpread$1({}, rootP2);
+
+  var p1a1 = pointsToAForAbsolute(rootP1, p1edge);
+  var p2a2 = pointsToAForAbsolute(rootP2, p2edge); // if both root and a value are equal
+
+  return isEqual(rootP2, rootP1) && isEqual(p2a2, p1a1);
+};
+/*
+ * Function to check if given two points for exponential function
+ * for correct answer and student answer are equal or not.
+ * @param p1 - student answer
+ * @param p2 - correct answer
+ * */
+
+var equalExponential = (p1, p2) => {
+  var {
+    edge: edgeP1
+  } = p1;
+  var {
+    edge: edgeP2
+  } = p2;
+  var {
+    root: rootP1
+  } = p1;
+  var {
+    root: rootP2
+  } = p2;
+  rootP1 = _objectSpread$1({}, rootP1);
+  rootP2 = _objectSpread$1({}, rootP2);
+
+  var p1edge = edgeP1 || _objectSpread$1({}, rootP1);
+
+  var p2edge = edgeP2 || _objectSpread$1({}, rootP2);
+
+  var {
+    a1,
+    b1
+  } = pointsToABForExponential(rootP1, p1edge);
+  var {
+    a2,
+    b2
+  } = pointsToABForExponential(rootP2, p2edge); // if both a and b value are equal
+
+  return isEqual(a2, a1) && isEqual(b2, b1);
+};
+var equalMarks = {
+  circle: (sessAnswer, mark) => equalCircle(sessAnswer, mark),
+  line: (sessAnswer, mark) => equalLine(sessAnswer, mark),
+  parabola: (sessAnswer, mark) => equalParabola(sessAnswer, mark),
+  absolute: (sessAnswer, mark) => equalAbsolute(sessAnswer, mark),
+  exponential: (sessAnswer, mark) => equalExponential(sessAnswer, mark),
+  point: (sessAnswer, mark) => equalPoint(sessAnswer, mark),
+  polygon: (sessAnswer, poly) => equalPolygon(sessAnswer, poly),
+  ray: (sessAnswer, mark) => equalRay(sessAnswer, mark),
+  segment: (sessAnswer, mark) => equalSegment(sessAnswer, mark),
+  sine: (sessAnswer, mark) => equalSine(sessAnswer, mark),
+  vector: (sessAnswer, mark) => equalVector(sessAnswer, mark)
+};
+
+var _excluded = ["defaultTool", "extraCSSRules", "prompt", "promptEnabled", "graph", "answers", "toolbarTools"];
+
+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 log = debug('@pie-element:graphing:controller');
+
+var initializeGraphMap = () => ({
+  point: [],
+  segment: [],
+  line: [],
+  ray: [],
+  vector: [],
+  polygon: [],
+  circle: [],
+  sine: [],
+  parabola: [],
+  absolute: [],
+  exponential: []
+});
+
+var graphObjectsOrder = {
+  incorrect: 0,
+  correct: 1,
+  missing: 2
+};
+var compareMarks = (mark1, mark2) => {
+  // marks can be compared with equalMarks[type] function only if they have the same type;
+  // if type is different, they are clearly not equal
+  return !!(mark1 && mark2 && mark1.type === mark2.type && equalMarks[mark1.type] && equalMarks[mark1.type](mark1, mark2));
+};
+var comparLabelMarks = (mark1, mark2) => {
+  return mark1.label === mark2.label ? 'correct' : 'incorrect';
+};
+var getAnswerCorrected = _ref => {
+  var {
+    sessionAnswers,
+    marks: correctAnswers
+  } = _ref;
+  sessionAnswers = sessionAnswers || [];
+  correctAnswers = correctAnswers || [];
+  var rez = cloneDeep(sessionAnswers).reduce((correctedAnswer, answer) => {
+    var answerIsCorrect = correctAnswers.find(mark => compareMarks(answer, mark));
+    answer.correctness = answerIsCorrect ? 'correct' : 'incorrect';
+
+    if (answerIsCorrect) {
+      answer.correctnesslabel = comparLabelMarks(answer, answerIsCorrect);
+      answer.correctlabel = answerIsCorrect.label ? answerIsCorrect.label : '';
+      answer.label = answer.label ? answer.label : '';
+    }
+
+    return [...correctedAnswer, answer];
+  }, []); // add missing objects from correct answer
+
+  var missingAnswers = cloneDeep(correctAnswers).reduce((correctedAnswer, answer) => {
+    var answerIndex = sessionAnswers.find(mark => compareMarks(answer, mark));
+
+    if (!answerIndex) {
+      // means that corrected answer is missing from session, so we mark it as missing object
+      return [...correctedAnswer, _objectSpread(_objectSpread({}, answer), {}, {
+        correctness: 'missing'
+      })];
+    }
+
+    return correctedAnswer;
+  }, []);
+  return [...rez, ...missingAnswers];
+};
+
+var getPartialScoring = _ref2 => {
+  var {
+    scoringType,
+    env
+  } = _ref2;
+  var pS = scoringType; // if scoringType is undefined, partialScoring should be considered undefined (not set)
+  // because partialScoring.enabled is using that information
+  // if it has a value, we check if it is partial scoring or dichotomous
+
+  if (scoringType) {
+    pS = scoringType === 'partial scoring';
+  }
+
+  return partialScoring.enabled({
+    partialScoring: pS
+  }, env);
+};
+
+var getBestAnswer = function getBestAnswer(question, session) {
+  var env = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  // questionPossibleAnswers contains all possible answers (correct response and alternates);
+  var {
+    answers: questionPossibleAnswers = {},
+    scoringType
+  } = question || {};
+  var {
+    answer
+  } = session || {}; // filter the incomplete objects
+
+  Object.entries(questionPossibleAnswers || {}).forEach(_ref3 => {
+    var [key, value] = _ref3;
+    return questionPossibleAnswers[key] = _objectSpread(_objectSpread({}, value), {}, {
+      marks: value === null || value === void 0 ? void 0 : value.marks.filter(mark => !mark.building)
+    });
+  }); // initialize answer if no values
+
+  answer = answer || []; //filter the incomplete objects for student response - Fix for SC-33160
+
+  answer = answer.filter(mark => !mark.building); // initialize one possible answer if no values
+
+  if (isEmpty(questionPossibleAnswers)) {
+    questionPossibleAnswers = {
+      correctAnswer: initializeGraphMap()
+    };
+  } else {
+    questionPossibleAnswers = _objectSpread({
+      correctAnswer: questionPossibleAnswers.correctAnswer
+    }, sortedAnswers(questionPossibleAnswers));
+  }
+
+  var partialScoringEnabled = getPartialScoring({
+    scoringType,
+    env
+  }); // student's answers without DUPLICATES
+
+  var sessionAnswers = uniqWith(answer, compareMarks); // array of possible answers entries
+
+  var possibleAnswers = Object.entries(questionPossibleAnswers);
+  return possibleAnswers.reduce((acc, entry) => {
+    // iterating each possible answer (main + alternates)
+    var possibleAnswerKey = entry[0];
+    var possibleAnswer = entry[1] || {};
+    var {
+      marks
+    } = possibleAnswer;
+
+    if (!marks || !marks.length) {
+      return acc;
+    } // returns array of marks, each having 'correctness' property
+
+
+    var correctedAnswer = getAnswerCorrected({
+      sessionAnswers,
+      marks
+    });
+    var correctMarks = correctedAnswer.filter(answer => answer.correctness === 'correct'); // filter out missing objects because they do not affect the calculation of the score
+    // only correct and incorrect are needed
+
+    var scoredCorrectedAnswer = correctedAnswer.filter(answer => answer.correctness !== 'missing');
+    var maxScore = marks.length;
+    var score = correctMarks.length; // if extra placements
+
+    if (scoredCorrectedAnswer.length > maxScore) {
+      score -= scoredCorrectedAnswer.length - maxScore;
+    }
+
+    if (score < 0) {
+      score = 0;
+    }
+
+    if (score / maxScore > acc.bestScore || !acc.foundOneSolution) {
+      if (partialScoringEnabled) {
+        acc.bestScore = parseFloat((score / maxScore).toFixed(2));
+      } else {
+        acc.bestScore = Math.floor(score / maxScore);
+      }
+
+      acc.bestScoreAnswerKey = possibleAnswerKey;
+      acc.answersCorrected = correctedAnswer;
+      acc.foundOneSolution = true;
+    }
+
+    return acc;
+  }, {
+    bestScore: 0,
+    bestScoreAnswerKey: null,
+    // initially we just suppose all the answers are incorrect
+    answersCorrected: cloneDeep(sessionAnswers).map(answer => _objectSpread(_objectSpread({}, answer), {}, {
+      correctness: 'incorrect'
+    })),
+    foundOneSolution: false
+  });
+};
+var normalize = question => _objectSpread(_objectSpread({}, defaults), question);
+function model(question, session, env) {
+  return new Promise(resolve => {
+    var normalizedQuestion = normalize(question); // added a sanity check for session for environments where it is not passed initially (ex. pie-website)
+
+    if (session === undefined || session === null) {
+      session = {};
+    } // console.log('normalizedQuestion', normalizedQuestion);
+
+
+    var _ref4 = normalizedQuestion || {},
+        {
+      defaultTool,
+      extraCSSRules,
+      prompt,
+      promptEnabled,
+      graph,
+      answers,
+      toolbarTools
+    } = _ref4,
+        questionProps = _objectWithoutProperties(_ref4, _excluded);
+
+    var {
+      arrows
+    } = normalizedQuestion;
+    var {
+      mode,
+      role
+    } = env || {}; // This is used for offering support for old models which have the property arrows: boolean
+    // Same thing is set in authoring : packages/graphing/configure/src/configure.jsx - componentDidMount
+
+    if (typeof arrows === 'boolean') {
+      if (arrows) {
+        arrows = {
+          left: true,
+          right: true,
+          up: true,
+          down: true
+        };
+      } else {
+        arrows = {
+          left: false,
+          right: false,
+          up: false,
+          down: false
+        };
+      }
+    } // added support for models without defaultTool defined; also used in packages/graphing/configure/src/index.js
+
+
+    var toolbarToolsNoLabel = (toolbarTools || []).filter(tool => tool !== 'label');
+    var normalizedDefaultTool = defaultTool || toolbarToolsNoLabel.length && toolbarToolsNoLabel[0] || '';
+
+    var base = _objectSpread(_objectSpread({}, questionProps), {}, {
+      answers,
+      arrows,
+      defaultTool: normalizedDefaultTool,
+      disabled: env.mode !== 'gather',
+      prompt: promptEnabled ? prompt : null,
+      rationale: null,
+      size: graph,
+      showKeyLegend: env.mode === 'evaluate',
+      showToggle: env.mode === 'evaluate' && !isEmpty(answers) && answers.correctAnswer && answers.correctAnswer.marks && !isEmpty(answers.correctAnswer.marks),
+      teacherInstructions: null,
+      toolbarTools,
+      extraCSSRules
+    });
+
+    if (role === 'instructor' && (mode === 'view' || mode === 'evaluate')) {
+      var {
+        rationale,
+        rationaleEnabled,
+        teacherInstructions,
+        teacherInstructionsEnabled
+      } = normalizedQuestion || {};
+      base.rationale = rationaleEnabled ? rationale : null;
+      base.teacherInstructions = teacherInstructionsEnabled ? teacherInstructions : null;
+    }
+
+    if (mode === 'evaluate') {
+      if (!isEmpty(answers) && answers.correctAnswer && answers.correctAnswer.marks && !isEmpty(answers.correctAnswer.marks)) {
+        var {
+          answersCorrected,
+          bestScoreAnswerKey,
+          bestScore
+        } = getBestAnswer(normalizedQuestion, session, env); // array of marks from session with 'correctness' property set
+
+        base.answersCorrected = answersCorrected.sort((a, b) => graphObjectsOrder[a.correctness] - graphObjectsOrder[b.correctness]);
+        base.correctResponse = bestScoreAnswerKey ? (answers[bestScoreAnswerKey] || {}).marks : [];
+        base.showToggle = base.showToggle && bestScore !== 1;
+      } else {
+        base.answersCorrected = session && session.answer || [];
+        base.correctResponse = [];
+      }
+    }
+
+    log('base: ', base);
+    resolve(base);
+  });
+}
+function outcome(question, session) {
+  var env = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return new Promise(resolve => {
+    if (!session || isEmpty(session)) {
+      resolve({
+        score: 0,
+        empty: true
+      });
+    }
+
+    if (env.mode !== 'evaluate' || isEmpty(question.answers) || question.answers && question.answers.correctAnswer && isEmpty(question.answers.correctAnswer.marks)) {
+      resolve({
+        score: 0
+      });
+    }
+
+    var {
+      bestScore
+    } = getBestAnswer(question, session, env);
+    resolve({
+      score: bestScore
+    });
+  });
+}
+var createCorrectResponseSession = (question, env) => {
+  return new Promise(resolve => {
+    if (env.mode !== 'evaluate' && env.role === 'instructor') {
+      var {
+        answers
+      } = question || {};
+      var marks = [];
+
+      if (answers && Object.values(answers)) {
+        var correctAnswer = answers.correctAnswer || Object.values(answers)[0] || {};
+        marks = correctAnswer.marks || [];
+      }
+
+      resolve({
+        answer: marks,
+        id: '1'
+      });
+    } else {
+      resolve(null);
+    }
+  });
+}; // remove all html tags
+
+
+var 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 {
+    answers,
+    toolbarTools
+  } = model;
+  var errors = {};
+  var correctAnswerErrors = {};
+  var toolbarToolsNoLabel = (toolbarTools || []).filter(tool => tool !== 'label');
+
+  if (!toolbarToolsNoLabel.length) {
+    errors.toolbarToolsError = 'There should be at least 1 tool defined.';
+  }
+
+  ['teacherInstructions', 'prompt', 'rationale'].forEach(field => {
+    var _config$field;
+
+    if ((_config$field = config[field]) !== null && _config$field !== void 0 && _config$field.required && !getContent(model[field])) {
+      errors[field] = 'This field is required.';
+    }
+  });
+  Object.entries(answers || {}).forEach(_ref5 => {
+    var [key, value] = _ref5;
+
+    if (!value.marks.length) {
+      correctAnswerErrors[key] = 'At least 1 graph object should be defined.';
+    } // check if all graph objects are correctly defined with respect to root, edge and from, to
+
+
+    if (value.marks.length > 0) {
+      value.marks.forEach(mark => {
+        if (mark.building) {
+          correctAnswerErrors[key] = 'At least 1 graph object is not correctly defined.';
+        }
+      });
+    }
+  });
+
+  if (!isEmpty(correctAnswerErrors)) {
+    errors.correctAnswerErrors = correctAnswerErrors;
+  }
+
+  return errors;
+};
+
+export { comparLabelMarks, compareMarks, createCorrectResponseSession, getAnswerCorrected, getBestAnswer, model, normalize, outcome, validate };
+//# sourceMappingURL=controller.js.map