@khanacademy/perseus-score 1.1.0 → 2.1.0

package/dist/index.js

@@ -12551,6 +12551,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.
@@ -12570,43 +12585,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 {
@@ -12615,25 +12610,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",
@@ -12644,15 +12621,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
@@ -12679,13 +12652,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: perseusCore.getDecimalSeparator(locale)
@@ -12701,7 +12668,11 @@ strings, locale) {
     // in the function variables list for the expression.
     if (!expression.parsed) {
       /* c8 ignore next */
-      throw new perseusCore.PerseusError("Unable to parse solution answer for expression", perseusCore.Errors.InvalidInput);
+      throw new perseusCore.PerseusError("Unable to parse solution answer for expression", perseusCore.Errors.InvalidInput, {
+        metadata: {
+          rubric: JSON.stringify(rubric)
+        }
+      });
     }
     return KhanAnswerTypes.expression.createValidatorFunctional(expression.expr, _({}).extend(options, {
       simplify: answer.simplify,
@@ -12796,6 +12767,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;
@@ -13097,47 +13086,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
@@ -13148,8 +13123,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,
@@ -13158,35 +13133,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 = perseusCore.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 = perseusCore.getMatrixSize(solution);
@@ -13231,35 +13178,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 = perseusCore.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 = kmath.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 = kmath.number.equal(userInput.numLinePosition, rubric.correctX || 0);
   if (correctPos && correctRel === userInput.rel) {
     return {
       type: "points",
@@ -13283,6 +13230,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;
+}
+
 /*
  * In this file, an `expression` is some portion of valid TeX enclosed in
  * curly brackets.
@@ -13545,6 +13512,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.
@@ -13561,15 +13538,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: perseusCore.approximateDeepEqual(userInput, rubric.correct) ? 1 : 0,
     total: 1,
     message: null
   };
@@ -13591,45 +13563,7 @@ function validatePlotter(userInput, validationData) {
   return null;
 }
 
-function scorePlotter(userInput, scoringData) {
-  const validationError = validatePlotter(userInput, scoringData);
-  if (validationError) {
-    return validationError;
-  }
-  return {
-    type: "points",
-    earned: perseusCore.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);
@@ -13670,6 +13604,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 = perseusCore.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.
@@ -13693,20 +13658,6 @@ function validateSorter(userInput) {
   return null;
 }
 
-function scoreSorter(userInput, rubric) {
-  const validationError = validateSorter(userInput);
-  if (validationError) {
-    return validationError;
-  }
-  const correct = perseusCore.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.
@@ -13850,9 +13801,289 @@ function scoreInputNumber(userInput, rubric) {
   };
 }
 
+/**
+ * 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() {
+  let points = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 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?.(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 => {
+  return widgets[name]?.validator ?? null;
+};
+const getWidgetScorer = name => {
+  return 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 perseusCore.PerseusError("PerseusScore with unknown type encountered", perseusCore.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 = perseusCore.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 = perseusCore.getUpgradedWidgetOptions(widgets);
+  const gradedWidgetIds = widgetIds.filter(id => {
+    const props = upgradedWidgets[id];
+    const widgetIsGraded = props?.graded == null || props.graded;
+    const widgetIsStatic = !!props?.static;
+    // Ungraded widgets or widgets set to static shouldn't be graded.
+    return widgetIsGraded && !widgetIsStatic;
+  });
+  const widgetScores = {};
+  gradedWidgetIds.forEach(id => {
+    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?.(userInput, widget.options, locale) ?? scorer?.(userInput, widget.options, locale);
+    if (score != null) {
+      widgetScores[id] = score;
+    }
+  });
+  return widgetScores;
+}
+
 exports.ErrorCodes = ErrorCodes;
 exports.KhanAnswerTypes = KhanAnswerTypes;
+exports.emptyWidgetsFunctional = emptyWidgetsFunctional;
+exports.flattenScores = flattenScores;
+exports.getWidgetScorer = getWidgetScorer;
+exports.getWidgetValidator = getWidgetValidator;
 exports.inputNumberAnswerTypes = inputNumberAnswerTypes;
+exports.registerWidget = registerWidget;
 exports.scoreCSProgram = scoreCSProgram;
 exports.scoreCategorizer = scoreCategorizer;
 exports.scoreDropdown = scoreDropdown;
@@ -13868,8 +14099,20 @@ exports.scoreMatrix = scoreMatrix;
 exports.scoreNumberLine = scoreNumberLine;
 exports.scoreNumericInput = scoreNumericInput;
 exports.scoreOrderer = scoreOrderer;
+exports.scorePerseusItem = scorePerseusItem;
 exports.scorePlotter = scorePlotter;
 exports.scoreRadio = scoreRadio;
 exports.scoreSorter = scoreSorter;
 exports.scoreTable = scoreTable;
+exports.scoreWidgetsFunctional = scoreWidgetsFunctional;
+exports.validateCategorizer = validateCategorizer;
+exports.validateDropdown = validateDropdown;
+exports.validateExpression = validateExpression;
+exports.validateMatrix = validateMatrix;
+exports.validateNumberLine = validateNumberLine;
+exports.validateOrderer = validateOrderer;
+exports.validatePlotter = validatePlotter;
+exports.validateRadio = validateRadio;
+exports.validateSorter = validateSorter;
+exports.validateTable = validateTable;
 //# sourceMappingURL=index.js.map