@pie-element/graphing-solution-set 4.0.1 → 4.2.0

package/esm/controller.js

@@ -1,690 +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';
-
-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;
-}
-
-/*
- * This file contains the default configuration for the Graphing Solution Set Item Type.
- * Model is similar to the one used in graphing item type except for the gssLineData object which handles
- * the configuration for the lines and the solution set.
- *
- * Same model is used in configure/src default.js
- * */
-var defaults = {
-  answers: {
-    correctAnswer: {
-      name: 'Correct Answer',
-      marks: []
-    }
-  },
-  arrows: {
-    left: true,
-    right: true,
-    up: true,
-    down: true
-  },
-  marks: [],
-  defaultGridConfiguration: 0,
-  domain: {
-    min: -5,
-    max: 5,
-    step: 1,
-    labelStep: 1,
-    axisLabel: 'x'
-  },
-  graph: {
-    width: 500,
-    height: 500
-  },
-  gssLineData: {
-    numberOfLines: 1,
-    selectedTool: 'lineA',
-    sections: [],
-    lineA: {
-      lineType: 'Solid'
-    }
-  },
-  includeAxes: true,
-  labels: {},
-  labelsEnabled: true,
-  padding: true,
-  prompt: '',
-  range: {
-    min: -5,
-    max: 5,
-    step: 1,
-    labelStep: 1,
-    axisLabel: 'y'
-  },
-  rationale: '',
-  standardGrid: false,
-  title: '',
-  coordinatesOnHover: false,
-  promptEnabled: true,
-  rationaleEnabled: true,
-  teacherInstructionsEnabled: true,
-  studentInstructionsEnabled: true
-};
-
-var _excluded$1 = ["type"];
-
-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; }
-/*
- * Constant to check equal segments
- * @param {Object} segment1 - segment 1
- * @param {Object} segment2 - segment 2
- * */
-
-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);
-}; // this function is implemented in configure as well
-
-/*
- * Constant to get sorted answers
- * @param {Object} answers - answers
- * */
-
-var sortedAnswers = answers => Object.keys(answers || {}).sort().reduce((result, key) => {
-  if (key !== 'correctAnswer') {
-    result[key] = answers[key];
-  }
-
-  return result;
-}, {});
-/*
- * Constant to return line equation coefficients
- * @param {Object} line - line
- * */
-
-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
-  };
-};
-/*
- * Constant to get significant decimals
- * @param {Number} number - number
- * */
-
-
-var getSignificantDecimals = number => Math.round(number * 10000) / 10000;
-/*
- * Constant to check equal lines
- * @param {Object} line1 - line 1
- * @param {Object} line2 - line 2
- * */
-
-
-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 && line1.fill === line2.fill; // (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))));
-};
-/*
- * Constant to construct segments from points
- * @param {Array} points - points
- * */
-
-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]
-  }));
-};
-/*
- * Constant to remove duplicate segments
- * @param {Array} segments - segments
- * */
-
-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));
-};
-/*
- * Constant to remove invalid segments
- * @param {Array} segments - segments
- * */
-
-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));
-};
-/*
- * Constant to check equal polygons
- * @param {Object} poly1 - polygon 1 points
- * @param {Object} poly2 - polygon 2 points
- * */
-
-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);
-};
-/*
- * Constant to compare equal marks
- * */
-
-var equalMarks = {
-  line: (sessAnswer, mark) => equalLine(sessAnswer, mark),
-  polygon: (sessAnswer, poly) => equalPolygon(sessAnswer, poly)
-};
-/*
- * Check if a point is correct and complete
- * @param {Object} point - point object
- * */
-
-var completePoint = point => point && Number.isFinite(point.x) && Number.isFinite(point.y);
-/*
- * Check if a line is complete
- * @param {Object} item - mark object
- * */
-
-
-var completeFromTo = item => item && completeMark.point(item.from) && completeMark.point(item.to);
-/*
- * Check if a point is correct and complete
- * @param {Object} item - mark object
- * */
-
-
-var completePoints = item => item && item.points && item.points.length && (item.points.filter(point => completePoint(point)) || []).length === item.points.length;
-/*
- * Complete mark object for line and point
- * */
-
-
-var completeMark = {
-  point: completePoint,
-  line: completeFromTo,
-  polygon: completePoints
-};
-/*
- * Function to remove invalid answers
- * @param {Array} answers - answers array
- * */
-
-var removeInvalidAnswers = answers => answers ? (answers || []).filter(_ref => {
-  var {
-    type
-  } = _ref,
-      answer = _objectWithoutProperties(_ref, _excluded$1);
-
-  return completeMark[type] ? completeMark[type](answer) : false;
-}) : [];
-
-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-solution-set:controller');
-
-var initializeGraphMap = () => ({
-  line: []
-});
-/*
- * Function to compare two marks
- * @param {Object} mark1 - first mark
- * @param {Object} mark2 - second mark
- * */
-
-
-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));
-};
-/*
- * Function to get the corrected answer
- * @param {Object} sessionAnswers - array of marks from session
- * @param {Object} marks - array of marks from correct answer
- * */
-
-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';
-    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];
-};
-/*
- * Function to get the best answer
- * @param {Object} question - question object
- * @param {Object} session - session object
- * @param {Object} env - env object
- * */
-
-var getBestAnswer = function getBestAnswer(question, session) {
-  // 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(_ref2 => {
-    var [key, value] = _ref2;
-    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 || []; // initialize one possible answer if no values
-
-  if (isEmpty(questionPossibleAnswers)) {
-    questionPossibleAnswers = {
-      correctAnswer: initializeGraphMap()
-    };
-  } else {
-    questionPossibleAnswers = _objectSpread({
-      correctAnswer: questionPossibleAnswers.correctAnswer
-    }, sortedAnswers(questionPossibleAnswers));
-  } // 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) {
-      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
-  });
-};
-/*
- * Constant normalize
- * @param {Object} question - question object
- * */
-
-var normalize = question => _objectSpread(_objectSpread({}, defaults), question);
-/*
- * Function to set model
- * @param {Object} question - question object
- * @param {Object} session - session object
- * @param {Object} env - env object
- * */
-
-function model(question, session, env) {
-  return new Promise(resolve => {
-    var normalizedQuestion = normalize(question); // ensure removing of invalid answers
-    // need this if undo redo was last operation
-
-    session.answer = removeInvalidAnswers(session.answer); // console.log('normalizedQuestion', normalizedQuestion);
-
-    var _ref3 = normalizedQuestion || {},
-        {
-      defaultTool,
-      extraCSSRules,
-      prompt,
-      promptEnabled,
-      graph,
-      answers,
-      toolbarTools
-    } = _ref3,
-        questionProps = _objectWithoutProperties(_ref3, _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
-        };
-      }
-    }
-
-    var base = _objectSpread(_objectSpread({}, questionProps), {}, {
-      answers,
-      arrows,
-      defaultTool: 'line',
-      disabled: env.mode !== 'gather',
-      prompt: promptEnabled ? prompt : null,
-      rationale: null,
-      size: graph,
-      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); // array of marks from session with 'correctness' property set
-
-        base.answersCorrected = answersCorrected;
-        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 to check the outcome
- * @param {Object} question - question object
- * @param {Object} session - session object
- * @param {Object} env - env object
- * */
-
-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);
-    resolve({
-      score: bestScore
-    });
-  });
-}
-/*
- * Constant to create correct response session
- * @param {Object} question - question object
- * @param {Object} env - env object
- * */
-
-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);
-    }
-  });
-};
-/*
- * Constant to validate model before saving item
- * @param {Object} model - model object
- * */
-
-var validate = function validate() {
-  var model = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var {
-    answers,
-    gssLineData
-  } = model;
-  var errors = {};
-  var correctAnswerErrors = {};
-  var found = false;
-
-  if (gssLineData.numberOfLines === 1) {
-    if (answers.correctAnswer.marks.length < 1) {
-      found = true;
-      correctAnswerErrors.correctAnswer = 'At least 1 line object should be defined.';
-    } else if (answers.correctAnswer.marks.length === 1 && answers.correctAnswer.marks[0].building) {
-      found = true;
-      correctAnswerErrors.correctAnswer = '1 or more graph object should be correctly defined.';
-    }
-  } else {
-    if (answers.correctAnswer.marks.length < 2) {
-      found = true;
-      correctAnswerErrors.correctAnswer = 'At least 2 line object should be defined.';
-    } else if (answers.correctAnswer.marks.length === 2) {
-      if (answers.correctAnswer.marks[0].building || answers.correctAnswer.marks[1].building) {
-        found = true;
-        correctAnswerErrors.correctAnswer = '1 or more graph object should be correctly defined.';
-      }
-    }
-  }
-
-  var polygon = answers.correctAnswer.marks.find(mark => mark.type === 'polygon');
-
-  if (!found && (!gssLineData.selectedTool === 'solutionSet' || !polygon)) {
-    correctAnswerErrors.correctAnswer = 'Please select a solution set for the graphing solution set item.';
-  }
-
-  if (!isEmpty(correctAnswerErrors)) {
-    errors.correctAnswerErrors = correctAnswerErrors;
-  }
-
-  return errors;
-};
-
-export { compareMarks, createCorrectResponseSession, getAnswerCorrected, getBestAnswer, model, normalize, outcome, validate };
-//# sourceMappingURL=controller.js.map