@khanacademy/perseus-score 1.1.0 → 2.1.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,43 +12560,23 @@ function validateCategorizer(userInput, validationData) {
   return null;
 }
 
-function scoreCategorizer(userInput, scoringData) {
-  const validationError = validateCategorizer(userInput, scoringData);
-  if (validationError) {
-    return validationError;
-  }
-  let allCorrect = true;
-  scoringData.values.forEach((value, i) => {
-    if (userInput.values[i] !== value) {
-      allCorrect = false;
-    }
-  });
-  return {
-    type: "points",
-    earned: allCorrect ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
-// TODO: merge this with scoreIframe, it's the same code
-function scoreCSProgram(state) {
+function scoreCSProgram(userInput) {
   // The CS program can tell us whether it's correct or incorrect,
   // and pass an optional message
-  if (state.status === "correct") {
+  if (userInput.status === "correct") {
     return {
       type: "points",
       earned: 1,
       total: 1,
-      message: state.message || null
+      message: userInput.message || null
     };
   }
-  if (state.status === "incorrect") {
+  if (userInput.status === "incorrect") {
     return {
       type: "points",
       earned: 0,
       total: 1,
-      message: state.message || null
+      message: userInput.message || null
     };
   }
   return {
@@ -12590,25 +12585,7 @@ function scoreCSProgram(state) {
   };
 }
 
-/**
- * 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",
@@ -12619,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,13 +12627,7 @@ function validateExpression(userInput) {
  *   show the user an error. TODO(joel) - what error?
  * - Otherwise, pass through the resulting points and message.
  */
-function scoreExpression(userInput, rubric,
-// TODO: remove strings as a param for scorers
-strings, locale) {
-  const validationError = validateExpression(userInput);
-  if (validationError) {
-    return validationError;
-  }
+function scoreExpression(userInput, rubric, locale) {
   const options = _.clone(rubric);
   _.extend(options, {
     decimal_separator: getDecimalSeparator(locale)
@@ -12676,7 +12643,11 @@ strings, locale) {
     // in the function variables list for the expression.
     if (!expression.parsed) {
       /* c8 ignore next */
-      throw new PerseusError("Unable to parse solution answer for expression", Errors.InvalidInput);
+      throw new PerseusError("Unable to parse solution answer for expression", Errors.InvalidInput, {
+        metadata: {
+          rubric: JSON.stringify(rubric)
+        }
+      });
     }
     return KhanAnswerTypes.expression.createValidatorFunctional(expression.expr, _({}).extend(options, {
       simplify: answer.simplify,
@@ -12771,6 +12742,24 @@ strings, 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;
@@ -13072,47 +13061,33 @@ function scoreInteractiveGraph(userInput, rubric) {
 
 // Question state for marker as result of user selected answers.
 
-function scoreLabelImageMarker(marker) {
+function scoreLabelImageMarker(userInput, rubric) {
   const score = {
     hasAnswers: false,
     isCorrect: false
   };
-  if (marker.selected && marker.selected.length > 0) {
+  if (userInput && userInput.length > 0) {
     score.hasAnswers = true;
   }
-  if (marker.answers.length > 0) {
-    if (marker.selected && marker.selected.length === marker.answers.length) {
+  if (rubric.length > 0) {
+    if (userInput && userInput.length === rubric.length) {
       // All correct answers are selected by the user.
-      score.isCorrect = marker.selected.every(choice => marker.answers.includes(choice));
+      score.isCorrect = userInput.every(choice => rubric.includes(choice));
     }
-  } else if (!marker.selected || marker.selected.length === 0) {
+  } else if (!userInput || userInput.length === 0) {
     // Correct as no answers should be selected by the user.
     score.isCorrect = true;
   }
   return score;
 }
-
-// TODO(LEMS-2440): May need to pull answers out of PerseusLabelImageWidgetOptions[markers] for the rubric
 function scoreLabelImage(userInput, rubric) {
-  let numAnswered = 0;
   let numCorrect = 0;
-  for (const marker of userInput.markers) {
-    const score = scoreLabelImageMarker(marker);
-    if (score.hasAnswers) {
-      numAnswered++;
-    }
+  for (let i = 0; i < userInput.markers.length; i++) {
+    const score = scoreLabelImageMarker(userInput.markers[i].selected, rubric.markers[i].answers);
     if (score.isCorrect) {
       numCorrect++;
     }
   }
-
-  // We expect all question markers to be answered before grading.
-  if (numAnswered !== userInput.markers.length) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
   return {
     type: "points",
     // Markers with no expected answers are graded as correct if user
@@ -13123,8 +13098,8 @@ function scoreLabelImage(userInput, rubric) {
   };
 }
 
-function scoreMatcher(state, rubric) {
-  const correct = _.isEqual(state.left, rubric.left) && _.isEqual(state.right, rubric.right);
+function scoreMatcher(userInput, rubric) {
+  const correct = _.isEqual(userInput.left, rubric.left) && _.isEqual(userInput.right, rubric.right);
   return {
     type: "points",
     earned: correct ? 1 : 0,
@@ -13133,35 +13108,7 @@ function scoreMatcher(state, 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, validationData) {
-  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 validationResult = validateMatrix(userInput);
-  if (validationResult != null) {
-    return validationResult;
-  }
   const solution = rubric.answers;
   const supplied = userInput.answers;
   const solutionSize = getMatrixSize(solution);
@@ -13206,35 +13153,35 @@ 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, scoringData) {
-  const validationError = validateNumberLine(userInput);
-  if (validationError) {
-    return validationError;
-  }
-  const range = scoringData.range;
-  const start = scoringData.initialX != null ? scoringData.initialX : range[0];
-  const startRel = scoringData.isInequality ? "ge" : "eq";
-  const correctRel = scoringData.correctRel || "eq";
-  const correctPos = number.equal(userInput.numLinePosition, scoringData.correctX || 0);
+function scoreNumberLine(userInput, rubric) {
+  const range = rubric.range;
+  const start = rubric.initialX != null ? rubric.initialX : range[0];
+  const startRel = rubric.isInequality ? "ge" : "eq";
+  const correctRel = rubric.correctRel || "eq";
+  const correctPos = number.equal(userInput.numLinePosition, rubric.correctX || 0);
   if (correctPos && correctRel === userInput.rel) {
     return {
       type: "points",
@@ -13258,6 +13205,26 @@ function scoreNumberLine(userInput, scoringData) {
   };
 }
 
+/**
+ * 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++) {
@@ -13531,6 +13498,16 @@ function scoreNumericInput(userInput, rubric) {
   };
 }
 
+function scoreOrderer(userInput, rubric) {
+  const correct = _.isEqual(userInput.current, rubric.correctOptions.map(option => option.content));
+  return {
+    type: "points",
+    earned: correct ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
 /**
  * Checks user input from the orderer widget to see if the user has started
  * ordering the options, making the widget scorable.
@@ -13547,15 +13524,10 @@ function validateOrderer(userInput) {
   return null;
 }
 
-function scoreOrderer(userInput, rubric) {
-  const validateError = validateOrderer(userInput);
-  if (validateError) {
-    return validateError;
-  }
-  const correct = _.isEqual(userInput.current, rubric.correctOptions.map(option => option.content));
+function scorePlotter(userInput, rubric) {
   return {
     type: "points",
-    earned: correct ? 1 : 0,
+    earned: approximateDeepEqual(userInput, rubric.correct) ? 1 : 0,
     total: 1,
     message: null
   };
@@ -13577,45 +13549,7 @@ function validatePlotter(userInput, validationData) {
   return null;
 }
 
-function scorePlotter(userInput, scoringData) {
-  const validationError = validatePlotter(userInput, scoringData);
-  if (validationError) {
-    return validationError;
-  }
-  return {
-    type: "points",
-    earned: approximateDeepEqual(userInput, scoringData.correct) ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
-/**
- * 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 scoreRadio(userInput, rubric) {
-  const validationError = validateRadio(userInput);
-  if (validationError) {
-    return validationError;
-  }
   const numSelected = userInput.choicesSelected.reduce((sum, selected) => {
     return sum + (selected ? 1 : 0);
   }, 0);
@@ -13656,6 +13590,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.
@@ -13679,20 +13644,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.
@@ -13836,5 +13787,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 };
+/**
+ * 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