@pie-element/graphing 8.0.1 → 8.2.0-mui-update.0

package/esm/controller.js

@@ -1,846 +0,0 @@
-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