@khanacademy/perseus-score 2.0.0 → 2.2.0

package/dist/es/index.js

@@ -1,6 +1,6 @@
 import * as KAS from '@khanacademy/kas';
 import { KhanMath, number, geometry, angles, coefficients } from '@khanacademy/kmath';
-import { PerseusError, Errors, getDecimalSeparator, GrapherUtil, approximateDeepEqual, approximateEqual, deepClone, getMatrixSize } from '@khanacademy/perseus-core';
+import { PerseusError, Errors, getDecimalSeparator, GrapherUtil, approximateDeepEqual, approximateEqual, deepClone, getMatrixSize, getWidgetIdsFromContent, getUpgradedWidgetOptions } from '@khanacademy/perseus-core';
 import { ErrorCodes as ErrorCodes$1 } from '@khanacademy/perseus-score';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -12526,6 +12526,21 @@ const KhanAnswerTypes = {
   }
 };
 
+function scoreCategorizer(userInput, rubric) {
+  let allCorrect = true;
+  rubric.values.forEach((value, i) => {
+    if (userInput.values[i] !== value) {
+      allCorrect = false;
+    }
+  });
+  return {
+    type: "points",
+    earned: allCorrect ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
 /**
  * Checks userInput from the categorizer widget to see if the user has selected
  * a category for each item.
@@ -12545,25 +12560,6 @@ function validateCategorizer(userInput, validationData) {
   return null;
 }
 
-function scoreCategorizer(userInput, rubric) {
-  const validationError = validateCategorizer(userInput, rubric);
-  if (validationError) {
-    return validationError;
-  }
-  let allCorrect = true;
-  rubric.values.forEach((value, i) => {
-    if (userInput.values[i] !== value) {
-      allCorrect = false;
-    }
-  });
-  return {
-    type: "points",
-    earned: allCorrect ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 function scoreCSProgram(userInput) {
   // The CS program can tell us whether it's correct or incorrect,
   // and pass an optional message
@@ -12589,25 +12585,7 @@ function scoreCSProgram(userInput) {
   };
 }
 
-/**
- * Checks if the user has selected an item from the dropdown before scoring.
- * This is shown with a userInput value / index other than 0.
- */
-function validateDropdown(userInput) {
-  if (userInput.value === 0) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
-
 function scoreDropdown(userInput, rubric) {
-  const validationError = validateDropdown(userInput);
-  if (validationError) {
-    return validationError;
-  }
   const correct = rubric.choices[userInput.value - 1].correct;
   return {
     type: "points",
@@ -12618,15 +12596,11 @@ function scoreDropdown(userInput, rubric) {
 }
 
 /**
- * Checks user input from the expression widget to see if it is scorable.
- *
- * Note: Most of the expression widget's validation requires the Rubric because
- * of its use of KhanAnswerTypes as a core part of scoring.
- *
- * @see `scoreExpression()` for more details.
+ * Checks if the user has selected an item from the dropdown before scoring.
+ * This is shown with a userInput value / index other than 0.
  */
-function validateExpression(userInput) {
-  if (userInput === "") {
+function validateDropdown(userInput) {
+  if (userInput.value === 0) {
     return {
       type: "invalid",
       message: null
@@ -12654,10 +12628,6 @@ function validateExpression(userInput) {
  * - Otherwise, pass through the resulting points and message.
  */
 function scoreExpression(userInput, rubric, locale) {
-  const validationError = validateExpression(userInput);
-  if (validationError) {
-    return validationError;
-  }
   const options = _.clone(rubric);
   _.extend(options, {
     decimal_separator: getDecimalSeparator(locale)
@@ -12772,6 +12742,24 @@ function scoreExpression(userInput, rubric, locale) {
   };
 }
 
+/**
+ * Checks user input from the expression widget to see if it is scorable.
+ *
+ * Note: Most of the expression widget's validation requires the Rubric because
+ * of its use of KhanAnswerTypes as a core part of scoring.
+ *
+ * @see `scoreExpression()` for more details.
+ */
+function validateExpression(userInput) {
+  if (userInput === "") {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return null;
+}
+
 function getCoefficientsByType(data) {
   if (data.coords == null) {
     return undefined;
@@ -12859,7 +12847,8 @@ function scoreIframe(userInput) {
 const {
   collinear,
   canonicalSineCoefficients,
-  similar
+  similar,
+  clockwise
 } = geometry;
 const {
   getClockwiseAngle
@@ -13019,9 +13008,27 @@ function scoreInteractiveGraph(userInput, rubric) {
         };
       }
     } else if (userInput.type === "angle" && rubric.correct.type === "angle") {
-      const guess = userInput.coords;
+      const coords = userInput.coords;
       const correct = rubric.correct.coords;
       const allowReflexAngles = rubric.correct.allowReflexAngles;
+
+      // While the angle graph should always have 3 points, our types
+      // technically allow for null values. We'll check for that here.
+      // TODO: (LEMS-2857) We would like to update the type of coords
+      // to be non-nullable, as the graph should always have 3 points.
+      if (!coords) {
+        return {
+          type: "invalid",
+          message: null
+        };
+      }
+
+      // We need to check both the direction of the angle and the
+      // whether the graph allows for reflexive angles in order to
+      // to determine if we need to reverse the coords for scoring.
+      const areClockwise = clockwise([coords[0], coords[2], coords[1]]);
+      const shouldReverseCoords = areClockwise && !allowReflexAngles;
+      const guess = shouldReverseCoords ? coords.slice().reverse() : coords;
       let match;
       if (rubric.correct.match === "congruent") {
         const angles = _.map([guess, correct], function (coords) {
@@ -13035,13 +13042,7 @@ function scoreInteractiveGraph(userInput, rubric) {
         match = approximateEqual(...angles);
       } else {
         /* exact */
-        match =
-        // @ts-expect-error - TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'.
-        approximateDeepEqual(guess[1], correct[1]) &&
-        // @ts-expect-error - TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'.
-        collinear(correct[1], correct[0], guess[0]) &&
-        // @ts-expect-error - TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'.
-        collinear(correct[1], correct[2], guess[2]);
+        match = approximateDeepEqual(guess[1], correct[1]) && collinear(correct[1], correct[0], guess[0]) && collinear(correct[1], correct[2], guess[2]);
       }
       if (match) {
         return {
@@ -13071,24 +13072,6 @@ function scoreInteractiveGraph(userInput, rubric) {
   };
 }
 
-function validateLabelImage(userInput) {
-  let numAnswered = 0;
-  for (let i = 0; i < userInput.markers.length; i++) {
-    const userSelection = userInput.markers[i].selected;
-    if (userSelection && userSelection.length > 0) {
-      numAnswered++;
-    }
-  }
-  // We expect all question markers to be answered before grading.
-  if (numAnswered !== userInput.markers.length) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
-
 // Question state for marker as result of user selected answers.
 
 function scoreLabelImageMarker(userInput, rubric) {
@@ -13111,10 +13094,6 @@ function scoreLabelImageMarker(userInput, rubric) {
   return score;
 }
 function scoreLabelImage(userInput, rubric) {
-  const validationError = validateLabelImage(userInput);
-  if (validationError) {
-    return validationError;
-  }
   let numCorrect = 0;
   for (let i = 0; i < userInput.markers.length; i++) {
     const score = scoreLabelImageMarker(userInput.markers[i].selected, rubric.markers[i].answers);
@@ -13142,35 +13121,7 @@ function scoreMatcher(userInput, rubric) {
   };
 }
 
-/**
- * Checks user input from the matrix widget to see if it is scorable.
- *
- * Note: The matrix widget cannot do much validation without the Scoring
- * Data because of its use of KhanAnswerTypes as a core part of scoring.
- *
- * @see `scoreMatrix()` for more details.
- */
-function validateMatrix(userInput) {
-  const supplied = userInput.answers;
-  const suppliedSize = getMatrixSize(supplied);
-  for (let row = 0; row < suppliedSize[0]; row++) {
-    for (let col = 0; col < suppliedSize[1]; col++) {
-      if (supplied[row][col] == null || supplied[row][col].toString().length === 0) {
-        return {
-          type: "invalid",
-          message: ErrorCodes.FILL_ALL_CELLS_ERROR
-        };
-      }
-    }
-  }
-  return null;
-}
-
 function scoreMatrix(userInput, rubric) {
-  const validationError = validateMatrix(userInput);
-  if (validationError != null) {
-    return validationError;
-  }
   const solution = rubric.answers;
   const supplied = userInput.answers;
   const solutionSize = getMatrixSize(solution);
@@ -13215,30 +13166,30 @@ function scoreMatrix(userInput, rubric) {
 }
 
 /**
- * Checks user input is within the allowed range and not the same as the initial
- * state.
- * @param userInput
- * @see 'scoreNumberLine' for the scoring logic.
+ * Checks user input from the matrix widget to see if it is scorable.
+ *
+ * Note: The matrix widget cannot do much validation without the Scoring
+ * Data because of its use of KhanAnswerTypes as a core part of scoring.
+ *
+ * @see `scoreMatrix()` for more details.
  */
-function validateNumberLine(userInput) {
-  const divisionRange = userInput.divisionRange;
-  const outsideAllowedRange = userInput.numDivisions > divisionRange[1] || userInput.numDivisions < divisionRange[0];
-
-  // TODO: I don't think isTickCrtl is a thing anymore
-  if (userInput.isTickCrtl && outsideAllowedRange) {
-    return {
-      type: "invalid",
-      message: "Number of divisions is outside the allowed range."
-    };
+function validateMatrix(userInput) {
+  const supplied = userInput.answers;
+  const suppliedSize = getMatrixSize(supplied);
+  for (let row = 0; row < suppliedSize[0]; row++) {
+    for (let col = 0; col < suppliedSize[1]; col++) {
+      if (supplied[row][col] == null || supplied[row][col].toString().length === 0) {
+        return {
+          type: "invalid",
+          message: ErrorCodes.FILL_ALL_CELLS_ERROR
+        };
+      }
+    }
   }
   return null;
 }
 
 function scoreNumberLine(userInput, rubric) {
-  const validationError = validateNumberLine(userInput);
-  if (validationError) {
-    return validationError;
-  }
   const range = rubric.range;
   const start = rubric.initialX != null ? rubric.initialX : range[0];
   const startRel = rubric.isInequality ? "ge" : "eq";
@@ -13267,6 +13218,26 @@ function scoreNumberLine(userInput, rubric) {
   };
 }
 
+/**
+ * Checks user input is within the allowed range and not the same as the initial
+ * state.
+ * @param userInput
+ * @see 'scoreNumberLine' for the scoring logic.
+ */
+function validateNumberLine(userInput) {
+  const divisionRange = userInput.divisionRange;
+  const outsideAllowedRange = userInput.numDivisions > divisionRange[1] || userInput.numDivisions < divisionRange[0];
+
+  // TODO: I don't think isTickCrtl is a thing anymore
+  if (userInput.isTickCrtl && outsideAllowedRange) {
+    return {
+      type: "invalid",
+      message: "Number of divisions is outside the allowed range."
+    };
+  }
+  return null;
+}
+
 function _extends() {
   return _extends = Object.assign ? Object.assign.bind() : function (n) {
     for (var e = 1; e < arguments.length; e++) {
@@ -13540,27 +13511,7 @@ function scoreNumericInput(userInput, rubric) {
   };
 }
 
-/**
- * Checks user input from the orderer widget to see if the user has started
- * ordering the options, making the widget scorable.
- * @param userInput
- * @see `scoreOrderer` for more details.
- */
-function validateOrderer(userInput) {
-  if (userInput.current.length === 0) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
-
 function scoreOrderer(userInput, rubric) {
-  const validationError = validateOrderer(userInput);
-  if (validationError) {
-    return validationError;
-  }
   const correct = _.isEqual(userInput.current, rubric.correctOptions.map(option => option.content));
   return {
     type: "points",
@@ -13571,13 +13522,13 @@ function scoreOrderer(userInput, rubric) {
 }
 
 /**
- * Checks user input to confirm it is not the same as the starting values for the graph.
- * This means the user has modified the graph, and the question can be scored.
- *
- * @see 'scorePlotter' for more details on scoring.
+ * Checks user input from the orderer widget to see if the user has started
+ * ordering the options, making the widget scorable.
+ * @param userInput
+ * @see `scoreOrderer` for more details.
  */
-function validatePlotter(userInput, validationData) {
-  if (approximateDeepEqual(userInput, validationData.starting)) {
+function validateOrderer(userInput) {
+  if (userInput.current.length === 0) {
     return {
       type: "invalid",
       message: null
@@ -13587,10 +13538,6 @@ function validatePlotter(userInput, validationData) {
 }
 
 function scorePlotter(userInput, rubric) {
-  const validationError = validatePlotter(userInput, rubric);
-  if (validationError) {
-    return validationError;
-  }
   return {
     type: "points",
     earned: approximateDeepEqual(userInput, rubric.correct) ? 1 : 0,
@@ -13600,18 +13547,13 @@ function scorePlotter(userInput, rubric) {
 }
 
 /**
- * Checks if the user has selected at least one option. Additional validation
- * is done in scoreRadio to check if the number of selected options is correct
- * and if the user has selected both a correct option and the "none of the above"
- * option.
- * @param userInput
- * @see `scoreRadio` for the additional validation logic and the scoring logic.
+ * Checks user input to confirm it is not the same as the starting values for the graph.
+ * This means the user has modified the graph, and the question can be scored.
+ *
+ * @see 'scorePlotter' for more details on scoring.
  */
-function validateRadio(userInput) {
-  const numSelected = userInput.choicesSelected.reduce((sum, selected) => {
-    return sum + (selected ? 1 : 0);
-  }, 0);
-  if (numSelected === 0) {
+function validatePlotter(userInput, validationData) {
+  if (approximateDeepEqual(userInput, validationData.starting)) {
     return {
       type: "invalid",
       message: null
@@ -13621,10 +13563,6 @@ function validateRadio(userInput) {
 }
 
 function scoreRadio(userInput, rubric) {
-  const validationError = validateRadio(userInput);
-  if (validationError) {
-    return validationError;
-  }
   const numSelected = userInput.choicesSelected.reduce((sum, selected) => {
     return sum + (selected ? 1 : 0);
   }, 0);
@@ -13665,6 +13603,37 @@ function scoreRadio(userInput, rubric) {
   };
 }
 
+/**
+ * Checks if the user has selected at least one option. Additional validation
+ * is done in scoreRadio to check if the number of selected options is correct
+ * and if the user has selected both a correct option and the "none of the above"
+ * option.
+ * @param userInput
+ * @see `scoreRadio` for the additional validation logic and the scoring logic.
+ */
+function validateRadio(userInput) {
+  const numSelected = userInput.choicesSelected.reduce((sum, selected) => {
+    return sum + (selected ? 1 : 0);
+  }, 0);
+  if (numSelected === 0) {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return null;
+}
+
+function scoreSorter(userInput, rubric) {
+  const correct = approximateDeepEqual(userInput.options, rubric.correct);
+  return {
+    type: "points",
+    earned: correct ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
 /**
  * Checks user input for the sorter widget to ensure that the user has made
  * changes before attempting to score the widget.
@@ -13688,20 +13657,6 @@ function validateSorter(userInput) {
   return null;
 }
 
-function scoreSorter(userInput, rubric) {
-  const validationError = validateSorter(userInput);
-  if (validationError) {
-    return validationError;
-  }
-  const correct = approximateDeepEqual(userInput.options, rubric.correct);
-  return {
-    type: "points",
-    earned: correct ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 /**
  * Filters the given table (modelled as a 2D array) to remove any rows that are
  * completely empty.
@@ -13845,5 +13800,282 @@ function scoreInputNumber(userInput, rubric) {
   };
 }
 
-export { ErrorCodes, KhanAnswerTypes, inputNumberAnswerTypes, scoreCSProgram, scoreCategorizer, scoreDropdown, scoreExpression, scoreGrapher, scoreIframe, scoreInputNumber, scoreInteractiveGraph, scoreLabelImage, scoreLabelImageMarker, scoreMatcher, scoreMatrix, scoreNumberLine, scoreNumericInput, scoreOrderer, scorePlotter, scoreRadio, scoreSorter, scoreTable, validateCategorizer, validateDropdown, validateExpression, validateMatrix, validateNumberLine, validateOrderer, validatePlotter, validateRadio, validateSorter, validateTable };
+/**
+ * Several widgets don't have "right"/"wrong" scoring logic,
+ * so this just says to move on past those widgets
+ *
+ * TODO(LEMS-2543) widgets that use this probably shouldn't have any
+ * scoring logic and the thing scoring an exercise
+ * should just know to skip these
+ */
+function scoreNoop(points = 0) {
+  return {
+    type: "points",
+    earned: points,
+    total: points,
+    message: null
+  };
+}
+
+// The `group` widget is basically a widget hosting a full Perseus system in
+// it. As such, scoring a group means scoring all widgets it contains.
+function scoreGroup(userInput, rubric, locale) {
+  const scores = scoreWidgetsFunctional(rubric.widgets, Object.keys(rubric.widgets), userInput, locale);
+  return flattenScores(scores);
+}
+
+/**
+ * Checks the given user input to see if any answerable widgets have not been
+ * "filled in" (ie. if they're empty). Another way to think about this
+ * function is that its a check to see if we can score the provided input.
+ */
+function emptyWidgetsFunctional(widgets,
+// This is a port of old code, I'm not sure why
+// we need widgetIds vs the keys of the widgets object
+widgetIds, userInputMap, locale) {
+  return widgetIds.filter(id => {
+    const widget = widgets[id];
+    if (!widget || widget.static === true) {
+      // Static widgets shouldn't count as empty
+      return false;
+    }
+    const validator = getWidgetValidator(widget.type);
+    const userInput = userInputMap[id];
+    const validationData = widget.options;
+    const score = validator == null ? void 0 : validator(userInput, validationData, locale);
+    if (score) {
+      return scoreIsEmpty(score);
+    }
+  });
+}
+
+function validateGroup(userInput, validationData, locale) {
+  const emptyWidgets = emptyWidgetsFunctional(validationData.widgets, Object.keys(validationData.widgets), userInput, locale);
+  if (emptyWidgets.length === 0) {
+    return null;
+  }
+  return {
+    type: "invalid",
+    message: null
+  };
+}
+
+function validateLabelImage(userInput) {
+  let numAnswered = 0;
+  for (let i = 0; i < userInput.markers.length; i++) {
+    const userSelection = userInput.markers[i].selected;
+    if (userSelection && userSelection.length > 0) {
+      numAnswered++;
+    }
+  }
+  // We expect all question markers to be answered before grading.
+  if (numAnswered !== userInput.markers.length) {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return null;
+}
+
+function validateMockWidget(userInput) {
+  if (userInput.currentValue == null || userInput.currentValue === "") {
+    return {
+      type: "invalid",
+      message: ""
+    };
+  }
+  return null;
+}
+
+function scoreMockWidget(userInput, rubric) {
+  const validationResult = validateMockWidget(userInput);
+  if (validationResult != null) {
+    return validationResult;
+  }
+  return {
+    type: "points",
+    earned: userInput.currentValue === rubric.value ? 1 : 0,
+    total: 1,
+    message: ""
+  };
+}
+
+const widgets = {};
+function registerWidget(type, scorer, validator) {
+  widgets[type] = {
+    scorer,
+    validator
+  };
+}
+const getWidgetValidator = name => {
+  var _widgets$name$validat, _widgets$name;
+  return (_widgets$name$validat = (_widgets$name = widgets[name]) == null ? void 0 : _widgets$name.validator) != null ? _widgets$name$validat : null;
+};
+const getWidgetScorer = name => {
+  var _widgets$name$scorer, _widgets$name2;
+  return (_widgets$name$scorer = (_widgets$name2 = widgets[name]) == null ? void 0 : _widgets$name2.scorer) != null ? _widgets$name$scorer : null;
+};
+registerWidget("categorizer", scoreCategorizer, validateCategorizer);
+registerWidget("cs-program", scoreCSProgram);
+registerWidget("dropdown", scoreDropdown, validateDropdown);
+registerWidget("expression", scoreExpression, validateExpression);
+registerWidget("grapher", scoreGrapher);
+registerWidget("group", scoreGroup, validateGroup);
+registerWidget("iframe", scoreIframe);
+registerWidget("input-number", scoreInputNumber);
+registerWidget("interactive-graph", scoreInteractiveGraph);
+registerWidget("label-image", scoreLabelImage, validateLabelImage);
+registerWidget("matcher", scoreMatcher);
+registerWidget("matrix", scoreMatrix, validateMatrix);
+registerWidget("mock-widget", scoreMockWidget, scoreMockWidget);
+registerWidget("number-line", scoreNumberLine, validateNumberLine);
+registerWidget("numeric-input", scoreNumericInput);
+registerWidget("orderer", scoreOrderer, validateOrderer);
+registerWidget("plotter", scorePlotter, validatePlotter);
+registerWidget("radio", scoreRadio, validateRadio);
+registerWidget("sorter", scoreSorter, validateSorter);
+registerWidget("table", scoreTable, validateTable);
+registerWidget("deprecated-standin", () => scoreNoop(1));
+registerWidget("measurer", () => scoreNoop(1));
+registerWidget("definition", scoreNoop);
+registerWidget("explanation", scoreNoop);
+registerWidget("image", scoreNoop);
+registerWidget("interaction", scoreNoop);
+registerWidget("molecule", scoreNoop);
+registerWidget("passage", scoreNoop);
+registerWidget("passage-ref", scoreNoop);
+registerWidget("passage-ref-target", scoreNoop);
+registerWidget("video", scoreNoop);
+
+const noScore = {
+  type: "points",
+  earned: 0,
+  total: 0,
+  message: null
+};
+
+/**
+ * If a widget says that it is empty once it is graded.
+ * Trying to encapsulate references to the score format.
+ */
+function scoreIsEmpty(score) {
+  // HACK(benkomalo): ugh. this isn't great; the Perseus score objects
+  // overload the type "invalid" for what should probably be three
+  // distinct cases:
+  //  - truly empty or not fully filled out
+  //  - invalid or malformed inputs
+  //  - "almost correct" like inputs where the widget wants to give
+  //  feedback (e.g. a fraction needs to be reduced, or `pi` should
+  //  be used instead of 3.14)
+  //
+  //  Unfortunately the coercion happens all over the place, as these
+  //  Perseus style score objects are created *everywhere* (basically
+  //  in every widget), so it's hard to change now. We assume that
+  //  anything with a "message" is not truly empty, and one of the
+  //  latter two cases for now.
+  return score.type === "invalid" && (!score.message || score.message.length === 0);
+}
+
+/**
+ * Combine two score objects.
+ *
+ * Given two score objects for two different widgets, combine them so that
+ * if one is wrong, the total score is wrong, etc.
+ */
+function combineScores(scoreA, scoreB) {
+  let message;
+  if (scoreA.type === "points" && scoreB.type === "points") {
+    if (scoreA.message && scoreB.message && scoreA.message !== scoreB.message) {
+      // TODO(alpert): Figure out how to combine messages usefully
+      message = null;
+    } else {
+      message = scoreA.message || scoreB.message;
+    }
+    return {
+      type: "points",
+      earned: scoreA.earned + scoreB.earned,
+      total: scoreA.total + scoreB.total,
+      message: message
+    };
+  }
+  if (scoreA.type === "points" && scoreB.type === "invalid") {
+    return scoreB;
+  }
+  if (scoreA.type === "invalid" && scoreB.type === "points") {
+    return scoreA;
+  }
+  if (scoreA.type === "invalid" && scoreB.type === "invalid") {
+    if (scoreA.message && scoreB.message && scoreA.message !== scoreB.message) {
+      // TODO(alpert): Figure out how to combine messages usefully
+      message = null;
+    } else {
+      message = scoreA.message || scoreB.message;
+    }
+    return {
+      type: "invalid",
+      message: message
+    };
+  }
+
+  /**
+   * The above checks cover all combinations of score type, so if we get here
+   * then something is amiss with our inputs.
+   */
+  throw new PerseusError("PerseusScore with unknown type encountered", Errors.InvalidInput, {
+    metadata: {
+      scoreA: JSON.stringify(scoreA),
+      scoreB: JSON.stringify(scoreB)
+    }
+  });
+}
+function flattenScores(widgetScoreMap) {
+  return Object.values(widgetScoreMap).reduce(combineScores, noScore);
+}
+
+// once scorePerseusItem is the only one calling scoreWidgetsFunctional
+function scorePerseusItem(perseusRenderData, userInputMap, locale) {
+  // There seems to be a chance that PerseusRenderer.widgets might include
+  // widget data for widgets that are not in PerseusRenderer.content,
+  // so this checks that the widgets are being used before scoring them
+  const usedWidgetIds = getWidgetIdsFromContent(perseusRenderData.content);
+  const scores = scoreWidgetsFunctional(perseusRenderData.widgets, usedWidgetIds, userInputMap, locale);
+  return flattenScores(scores);
+}
+
+// TODO: combine scorePerseusItem with scoreWidgetsFunctional
+function scoreWidgetsFunctional(widgets,
+// This is a port of old code, I'm not sure why
+// we need widgetIds vs the keys of the widgets object
+widgetIds, userInputMap, locale) {
+  const upgradedWidgets = getUpgradedWidgetOptions(widgets);
+  const gradedWidgetIds = widgetIds.filter(id => {
+    const props = upgradedWidgets[id];
+    const widgetIsGraded = (props == null ? void 0 : props.graded) == null || props.graded;
+    const widgetIsStatic = !!(props != null && props.static);
+    // Ungraded widgets or widgets set to static shouldn't be graded.
+    return widgetIsGraded && !widgetIsStatic;
+  });
+  const widgetScores = {};
+  gradedWidgetIds.forEach(id => {
+    var _validator;
+    const widget = upgradedWidgets[id];
+    if (!widget) {
+      return;
+    }
+    const userInput = userInputMap[id];
+    const validator = getWidgetValidator(widget.type);
+    const scorer = getWidgetScorer(widget.type);
+
+    // We do validation (empty checks) first and then scoring. If
+    // validation fails, it's result is itself a PerseusScore.
+    const score = (_validator = validator == null ? void 0 : validator(userInput, widget.options, locale)) != null ? _validator : scorer == null ? void 0 : scorer(userInput, widget.options, locale);
+    if (score != null) {
+      widgetScores[id] = score;
+    }
+  });
+  return widgetScores;
+}
+
+export { ErrorCodes, KhanAnswerTypes, emptyWidgetsFunctional, flattenScores, getWidgetScorer, getWidgetValidator, inputNumberAnswerTypes, registerWidget, scoreCSProgram, scoreCategorizer, scoreDropdown, scoreExpression, scoreGrapher, scoreIframe, scoreInputNumber, scoreInteractiveGraph, scoreLabelImage, scoreLabelImageMarker, scoreMatcher, scoreMatrix, scoreNumberLine, scoreNumericInput, scoreOrderer, scorePerseusItem, scorePlotter, scoreRadio, scoreSorter, scoreTable, scoreWidgetsFunctional, validateCategorizer, validateDropdown, validateExpression, validateMatrix, validateNumberLine, validateOrderer, validatePlotter, validateRadio, validateSorter, validateTable };
 //# sourceMappingURL=index.js.map