@khanacademy/perseus-core 3.3.0 → 3.5.0

package/dist/index.js

@@ -4606,7 +4606,7 @@ function throwErrorIfCheatingDetected() {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus-core";
-const libVersion = "3.3.0";
+const libVersion = "3.5.0";
 addLibraryVersionToPerseusDebug(libName, libVersion);
 
 /**
@@ -4705,7 +4705,7 @@ const mapObject = function (obj, lambda) {
   return result;
 };
 
-const defaultWidgetOptions$u = {
+const defaultWidgetOptions$v = {
   items: [],
   categories: [],
   values: [],
@@ -4713,11 +4713,11 @@ const defaultWidgetOptions$u = {
 };
 const categorizerWidgetLogic = {
   name: "categorizer",
-  defaultWidgetOptions: defaultWidgetOptions$u
+  defaultWidgetOptions: defaultWidgetOptions$v
 };
 
 const DEFAULT_HEIGHT = 400;
-const defaultWidgetOptions$t = {
+const defaultWidgetOptions$u = {
   programID: "",
   programType: null,
   settings: [{
@@ -4730,19 +4730,21 @@ const defaultWidgetOptions$t = {
 };
 const csProgramWidgetLogic = {
   name: "cs-program",
-  defaultWidgetOptions: defaultWidgetOptions$t
+  defaultWidgetOptions: defaultWidgetOptions$u,
+  supportedAlignments: ["block", "full-width"]
 };
 
-const defaultWidgetOptions$s = {
+const defaultWidgetOptions$t = {
   togglePrompt: "",
   definition: ""
 };
 const definitionWidgetLogic = {
   name: "definition",
-  defaultWidgetOptions: defaultWidgetOptions$s
+  defaultWidgetOptions: defaultWidgetOptions$t,
+  defaultAlignment: "inline"
 };
 
-const defaultWidgetOptions$r = {
+const defaultWidgetOptions$s = {
   placeholder: "",
   choices: [{
     content: "",
@@ -4751,10 +4753,11 @@ const defaultWidgetOptions$r = {
 };
 const dropdownWidgetLogic = {
   name: "definition",
-  defaultWidgetOptions: defaultWidgetOptions$r
+  defaultWidgetOptions: defaultWidgetOptions$s,
+  defaultAlignment: "inline-block"
 };
 
-const defaultWidgetOptions$q = {
+const defaultWidgetOptions$r = {
   showPrompt: "Explain",
   hidePrompt: "Hide explanation",
   explanation: "explanation goes here\n\nmore explanation",
@@ -4762,7 +4765,8 @@ const defaultWidgetOptions$q = {
 };
 const explanationWidgetLogic = {
   name: "explanation",
-  defaultWidgetOptions: defaultWidgetOptions$q
+  defaultWidgetOptions: defaultWidgetOptions$r,
+  defaultAlignment: "inline"
 };
 
 const currentVersion$3 = {
@@ -4785,7 +4789,7 @@ const widgetOptionsUpgrades$2 = {
     }]
   })
 };
-const defaultWidgetOptions$p = {
+const defaultWidgetOptions$q = {
   answerForms: [],
   times: false,
   buttonSets: ["basic"],
@@ -4796,26 +4800,52 @@ const expressionWidgetLogic = {
   name: "expression",
   version: currentVersion$3,
   widgetOptionsUpgrades: widgetOptionsUpgrades$2,
-  defaultWidgetOptions: defaultWidgetOptions$p
+  defaultWidgetOptions: defaultWidgetOptions$q,
+  defaultAlignment: "inline-block"
 };
 
-const defaultWidgetOptions$o = {
+const defaultWidgetOptions$p = {
   title: "",
   content: "",
   widgets: {},
   images: {},
   hint: null
 };
-const GradedGroupWidgetLogic = {
+const gradedGroupWidgetLogic = {
   name: "graded-group",
-  defaultWidgetOptions: defaultWidgetOptions$o
+  defaultWidgetOptions: defaultWidgetOptions$p
 };
 
-const defaultWidgetOptions$n = {
+const defaultWidgetOptions$o = {
   gradedGroups: []
 };
-const GradedGroupSetWidgetLogic = {
+const gradedGroupSetWidgetLogic = {
   name: "graded-group-set",
+  defaultWidgetOptions: defaultWidgetOptions$o
+};
+
+const defaultWidgetOptions$n = {
+  graph: {
+    labels: ["x", "y"],
+    range: [[-10, 10], [-10, 10]],
+    step: [1, 1],
+    backgroundImage: {
+      url: null
+    },
+    markings: "graph",
+    rulerLabel: "",
+    rulerTicks: 10,
+    valid: true,
+    showTooltips: false
+  },
+  correct: {
+    type: "linear",
+    coords: null
+  },
+  availableTypes: ["linear"]
+};
+const grapherWidgetLogic = {
+  name: "grapher",
   defaultWidgetOptions: defaultWidgetOptions$n
 };
 
@@ -4827,7 +4857,7 @@ const defaultWidgetOptions$m = {
   // `the GroupMetadataEditor`
   metadata: undefined
 };
-const GroupWidgetLogic = {
+const groupWidgetLogic = {
   name: "group",
   defaultWidgetOptions: defaultWidgetOptions$m
 };
@@ -4863,7 +4893,9 @@ const defaultWidgetOptions$k = {
 };
 const imageWidgetLogic = {
   name: "image",
-  defaultWidgetOptions: defaultWidgetOptions$k
+  defaultWidgetOptions: defaultWidgetOptions$k,
+  supportedAlignments: ["block", "full-width"],
+  defaultAlignment: "block"
 };
 
 const defaultWidgetOptions$j = {
@@ -4877,7 +4909,8 @@ const defaultWidgetOptions$j = {
 };
 const inputNumberWidgetLogic = {
   name: "input-number",
-  defaultWidgetOptions: defaultWidgetOptions$j
+  defaultWidgetOptions: defaultWidgetOptions$j,
+  defaultAlignment: "inline-block"
 };
 
 const defaultWidgetOptions$i = {
@@ -5034,7 +5067,8 @@ const defaultWidgetOptions$b = {
 };
 const numericInputWidgetLogic = {
   name: "numeric-input",
-  defaultWidgetOptions: defaultWidgetOptions$b
+  defaultWidgetOptions: defaultWidgetOptions$b,
+  defaultAlignment: "inline-block"
 };
 
 const defaultWidgetOptions$a = {
@@ -5076,7 +5110,8 @@ const defaultWidgetOptions$8 = {
 const passageRefWidgetLogic = {
   name: "passageRef",
   version: currentVersion$1,
-  defaultWidgetOptions: defaultWidgetOptions$8
+  defaultWidgetOptions: defaultWidgetOptions$8,
+  defaultAlignment: "inline"
 };
 
 const defaultWidgetOptions$7 = {
@@ -5084,14 +5119,15 @@ const defaultWidgetOptions$7 = {
 };
 const passageRefTargetWidgetLogic = {
   name: "passageRefTarget",
-  defaultWidgetOptions: defaultWidgetOptions$7
+  defaultWidgetOptions: defaultWidgetOptions$7,
+  defaultAlignment: "inline"
 };
 
 const defaultWidgetOptions$6 = {
   url: "",
   description: ""
 };
-const PhetSimulationWidgetLogic = {
+const phetSimulationWidgetLogic = {
   name: "phet-simulation",
   defaultWidgetOptions: defaultWidgetOptions$6
 };
@@ -5193,9 +5229,242 @@ const defaultWidgetOptions = {
 };
 const videoWidgetLogic = {
   name: "video",
-  defaultWidgetOptions
+  defaultWidgetOptions,
+  supportedAlignments: ["block", "float-left", "float-right", "full-width"],
+  defaultAlignment: "block"
 };
 
+const widgets = {};
+function registerWidget(type, logic) {
+  widgets[type] = logic;
+}
+function isWidgetRegistered(type) {
+  const widgetLogic = widgets[type];
+  return !!widgetLogic;
+}
+function getCurrentVersion(type) {
+  const widgetLogic = widgets[type];
+  return widgetLogic?.version || {
+    major: 0,
+    minor: 0
+  };
+}
+function getWidgetOptionsUpgrades(type) {
+  const widgetLogic = widgets[type];
+  return widgetLogic?.widgetOptionsUpgrades || {};
+}
+function getDefaultWidgetOptions(type) {
+  const widgetLogic = widgets[type];
+  return widgetLogic?.defaultWidgetOptions || {};
+}
+
+/**
+ * Handling for the optional alignments for widgets
+ * See widget-container.jsx for details on how alignments are implemented.
+ */
+
+/**
+ * Returns the list of supported alignments for the given (string) widget
+ * type. This is used primarily at editing time to display the choices
+ * for the user.
+ *
+ * Supported alignments are given as an array of strings in the exports of
+ * a widget's module.
+ */
+const getSupportedAlignments = type => {
+  const widgetLogic = widgets[type];
+  if (!widgetLogic?.supportedAlignments?.[0]) {
+    // default alignments
+    return ["default"];
+  }
+  return widgetLogic?.supportedAlignments;
+};
+
+/**
+ * For the given (string) widget type, determine the default alignment for
+ * the widget. This is used at rendering time to go from "default" alignment
+ * to the actual alignment displayed on the screen.
+ *
+ * The default alignment is given either as a string (called
+ * `defaultAlignment`) or a function (called `getDefaultAlignment`) on
+ * the exports of a widget's module.
+ */
+const getDefaultAlignment = type => {
+  const widgetLogic = widgets[type];
+  if (!widgetLogic?.defaultAlignment) {
+    return "block";
+  }
+  return widgetLogic.defaultAlignment;
+};
+registerWidget("categorizer", categorizerWidgetLogic);
+registerWidget("cs-program", csProgramWidgetLogic);
+registerWidget("definition", definitionWidgetLogic);
+registerWidget("dropdown", dropdownWidgetLogic);
+registerWidget("explanation", explanationWidgetLogic);
+registerWidget("expression", expressionWidgetLogic);
+registerWidget("graded-group", gradedGroupWidgetLogic);
+registerWidget("graded-group-set", gradedGroupSetWidgetLogic);
+registerWidget("grapher", grapherWidgetLogic);
+registerWidget("group", groupWidgetLogic);
+registerWidget("iframe", iframeWidgetLogic);
+registerWidget("image", imageWidgetLogic);
+registerWidget("input-number", inputNumberWidgetLogic);
+registerWidget("interaction", interactionWidgetLogic);
+registerWidget("interactive-graph", interactiveGraphWidgetLogic);
+registerWidget("label-image", labelImageWidgetLogic);
+registerWidget("matcher", matcherWidgetLogic);
+registerWidget("matrix", matrixWidgetLogic);
+registerWidget("measurer", measurerWidgetLogic);
+registerWidget("number-line", numberLineWidgetLogic);
+registerWidget("numeric-input", numericInputWidgetLogic);
+registerWidget("orderer", ordererWidgetLogic);
+registerWidget("passage", passageWidgetLogic);
+registerWidget("passage-ref", passageRefWidgetLogic);
+registerWidget("passage-ref-target", passageRefTargetWidgetLogic);
+registerWidget("phet-simulation", phetSimulationWidgetLogic);
+registerWidget("plotter", plotterWidgetLogic);
+registerWidget("python-program", pythonProgramWidgetLogic);
+registerWidget("radio", radioWidgetLogic);
+registerWidget("sorter", sorterWidgetLogic);
+registerWidget("table", tableWidgetLogic);
+registerWidget("video", videoWidgetLogic);
+
+var coreWidgetRegistry = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isWidgetRegistered: isWidgetRegistered,
+    getCurrentVersion: getCurrentVersion,
+    getWidgetOptionsUpgrades: getWidgetOptionsUpgrades,
+    getDefaultWidgetOptions: getDefaultWidgetOptions,
+    getSupportedAlignments: getSupportedAlignments,
+    getDefaultAlignment: getDefaultAlignment
+});
+
+const DEFAULT_STATIC = false;
+const upgradeWidgetInfoToLatestVersion = oldWidgetInfo => {
+  const type = oldWidgetInfo.type;
+  // NOTE(jeremy): This looks like it could be replaced by fixing types so
+  // that `type` is non-optional. But we're seeing this in Sentry today so I
+  // suspect we have legacy data (potentially unpublished) and we should
+  // figure that out before depending solely on types.
+  if (!_.isString(type)) {
+    throw new PerseusError("widget type must be a string, but was: " + type, Errors.Internal);
+  }
+  if (!isWidgetRegistered(type)) {
+    // If we have a widget that isn't registered, we can't upgrade it
+    // TODO(aria): Figure out what the best thing to do here would be
+    return oldWidgetInfo;
+  }
+
+  // Unversioned widgets (pre-July 2014) are all implicitly 0.0
+  const initialVersion = oldWidgetInfo.version || {
+    major: 0,
+    minor: 0
+  };
+  const latestVersion = getCurrentVersion(type);
+
+  // If the widget version is later than what we understand (major
+  // version is higher than latest, or major versions are equal and minor
+  // version is higher than latest), don't perform any upgrades.
+  if (initialVersion.major > latestVersion.major || initialVersion.major === latestVersion.major && initialVersion.minor > latestVersion.minor) {
+    return oldWidgetInfo;
+  }
+
+  // We do a clone here so that it's safe to mutate the input parameter
+  // in propUpgrades functions (which I will probably accidentally do at
+  // some point, and we would like to not break when that happens).
+  let newEditorOptions = _.clone(oldWidgetInfo.options) || {};
+  const upgradePropsMap = getWidgetOptionsUpgrades(type);
+
+  // Empty props usually mean a newly created widget by the editor,
+  // and are always considerered up-to-date.
+  // Mostly, we'd rather not run upgrade functions on props that are
+  // not complete.
+  if (_.keys(newEditorOptions).length !== 0) {
+    // We loop through all the versions after the current version of
+    // the loaded widget, up to and including the latest version of the
+    // loaded widget, and run the upgrade function to bring our loaded
+    // widget's props up to that version.
+    // There is a little subtlety here in that we call
+    // upgradePropsMap[1] to upgrade *to* version 1,
+    // (not from version 1).
+    for (let nextVersion = initialVersion.major + 1; nextVersion <= latestVersion.major; nextVersion++) {
+      if (upgradePropsMap[String(nextVersion)]) {
+        newEditorOptions = upgradePropsMap[String(nextVersion)](newEditorOptions);
+      } else {
+        throw new PerseusError("No upgrade found for widget. Cannot render.", Errors.Internal, {
+          metadata: {
+            type,
+            fromMajorVersion: nextVersion - 1,
+            toMajorVersion: nextVersion,
+            oldWidgetInfo: JSON.stringify(oldWidgetInfo)
+          }
+        });
+      }
+    }
+  }
+
+  // Minor version upgrades (eg. new optional props) don't have
+  // transform functions. Instead, we fill in the new props with their
+  // defaults.
+  const defaultOptions = getDefaultWidgetOptions(type);
+  newEditorOptions = {
+    ...defaultOptions,
+    ...newEditorOptions
+  };
+  let alignment = oldWidgetInfo.alignment;
+
+  // Widgets that support multiple alignments will "lock in" the
+  // alignment to the alignment that would be listed first in the
+  // select box. If the widget only supports one alignment, the
+  // alignment value will likely just end up as "default".
+  if (alignment == null || alignment === "default") {
+    alignment = getSupportedAlignments(type)?.[0];
+    if (!alignment) {
+      throw new PerseusError("No default alignment found when upgrading widget", Errors.Internal, {
+        metadata: {
+          widgetType: type
+        }
+      });
+    }
+  }
+  let widgetStatic = oldWidgetInfo.static;
+  if (widgetStatic == null) {
+    widgetStatic = DEFAULT_STATIC;
+  }
+  return {
+    ...oldWidgetInfo,
+    // maintain other info, like type
+    // After upgrading we guarantee that the version is up-to-date
+    version: latestVersion,
+    // Default graded to true (so null/undefined becomes true):
+    graded: oldWidgetInfo.graded != null ? oldWidgetInfo.graded : true,
+    alignment: alignment,
+    static: widgetStatic,
+    options: newEditorOptions
+  };
+};
+function getUpgradedWidgetOptions(oldWidgetOptions) {
+  return mapObject(oldWidgetOptions, (widgetInfo, widgetId) => {
+    if (!widgetInfo.type || !widgetInfo.alignment) {
+      const newValues = {};
+      if (!widgetInfo.type) {
+        // TODO: why does widget have no type?
+        // We don't want to derive type from widget ID
+        // see: LEMS-1845
+        newValues.type = widgetId.split(" ")[0];
+      }
+      if (!widgetInfo.alignment) {
+        newValues.alignment = "default";
+      }
+      widgetInfo = {
+        ...widgetInfo,
+        ...newValues
+      };
+    }
+    return upgradeWidgetInfoToLatestVersion(widgetInfo);
+  });
+}
+
 /**
  * For details on the individual options, see the
  * PerseusOrdererWidgetOptions type
@@ -5231,6 +5500,10 @@ function getCategorizerPublicWidgetOptions(options) {
   };
 }
 
+function getCSProgramPublicWidgetOptions(options) {
+  return options;
+}
+
 /**
  * For details on the individual options, see the
  * PerseusExpressionWidgetOptions type
@@ -5251,6 +5524,183 @@ function getExpressionPublicWidgetOptions(options) {
   };
 }
 
+function getGrapherPublicWidgetOptions(options) {
+  const {
+    correct: _,
+    ...publicOptions
+  } = options;
+  return publicOptions;
+}
+
+function getInteractiveGraphPublicWidgetOptions(options) {
+  const {
+    correct: _,
+    ...publicOptions
+  } = options;
+  return publicOptions;
+}
+
+/**
+ * For details on the individual options, see the
+ * PerseusLabelImageWidgetOptions type
+ */
+
+function getLabelImagePublicWidgetOptions(options) {
+  return {
+    ...options,
+    markers: options.markers.map(getLabelImageMarkerPublicData)
+  };
+}
+function getLabelImageMarkerPublicData(marker) {
+  const {
+    answers: _,
+    ...publicData
+  } = marker;
+  return publicData;
+}
+
+/**
+ * For details on the individual options, see the
+ * PerseusSorterWidgetOptions type
+ */
+
+/**
+ * Given a PerseusSorterWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getSorterPublicWidgetOptions(options) {
+  return {
+    // Note(Tamara): This does not provide correct answer information any longer.
+    // To maintain compatibility with the original widget options, we are
+    // keeping the key the same. Represents initial state of the cards here.
+    correct: options.correct.slice().sort(),
+    padding: options.padding,
+    layout: options.layout
+  };
+}
+
+/**
+ * For details on the individual options, see the
+ * PerseusDropdownWidgetOptions type
+ */
+
+/**
+ * Given a PerseusDropdownWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getDropdownPublicWidgetOptions(options) {
+  return {
+    choices: options.choices.map(choice => ({
+      content: choice.content
+    })),
+    placeholder: options.placeholder,
+    static: options.static,
+    visibleLabel: options.visibleLabel,
+    ariaLabel: options.ariaLabel
+  };
+}
+
+/**
+ * For details on the individual options, see the
+ * PerseusNumericInputWidgetOptions type
+ */
+
+/**
+ * Given a PerseusNumericInputWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getNumericInputPublicWidgetOptions(options) {
+  const {
+    answers: _,
+    ...publicWidgetOptions
+  } = options;
+  return publicWidgetOptions;
+}
+
+function getNumberLinePublicWidgetOptions(options) {
+  const {
+    correctX: _,
+    correctRel: __,
+    ...publicOptions
+  } = options;
+  return publicOptions;
+}
+
+/**
+ * For details on the individual options, see the
+ * PerseusRadioWidgetOptions type
+ */
+
+/**
+ * Only the options from each Radio choice that should be exposed to the client.
+ */
+
+/**
+ * Given a PerseusRadioChoice object, return a new object with only the public
+ * data that should be included in the Radio public widget options.
+ */
+function getRadioChoicePublicData(choice) {
+  const {
+    content,
+    isNoneOfTheAbove,
+    widgets
+  } = choice;
+  return {
+    content,
+    isNoneOfTheAbove,
+    widgets
+  };
+}
+
+/**
+ * Given a PerseusRadioWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getRadioPublicWidgetOptions(options) {
+  return {
+    ...options,
+    choices: options.choices.map(getRadioChoicePublicData)
+  };
+}
+
+function getTablePublicWidgetOptions(options) {
+  const {
+    answers: _,
+    ...publicOptions
+  } = options;
+  return publicOptions;
+}
+
+function getIFramePublicWidgetOptions(options) {
+  return options;
+}
+
+function getMatrixPublicWidgetOptions(options) {
+  const {
+    answers: _,
+    ...publicOptions
+  } = options;
+  return publicOptions;
+}
+
+/**
+ * For details on the individual options, see the
+ * PerseusPlotterWidgetOptions type
+ */
+
+/**
+ * Given a PerseusPlotterWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getPlotterPublicWidgetOptions(options) {
+  const {
+    correct: _,
+    ...publicOptions
+  } = options;
+  return publicOptions;
+}
+
+exports.CoreWidgetRegistry = coreWidgetRegistry;
 exports.Errors = Errors;
 exports.GrapherUtil = grapherUtil;
 exports.ItemExtras = ItemExtras;
@@ -5267,16 +5717,31 @@ exports.definitionLogic = definitionWidgetLogic;
 exports.dropdownLogic = dropdownWidgetLogic;
 exports.explanationLogic = explanationWidgetLogic;
 exports.expressionLogic = expressionWidgetLogic;
+exports.getCSProgramPublicWidgetOptions = getCSProgramPublicWidgetOptions;
 exports.getCategorizerPublicWidgetOptions = getCategorizerPublicWidgetOptions;
 exports.getDecimalSeparator = getDecimalSeparator;
+exports.getDropdownPublicWidgetOptions = getDropdownPublicWidgetOptions;
 exports.getExpressionPublicWidgetOptions = getExpressionPublicWidgetOptions;
+exports.getGrapherPublicWidgetOptions = getGrapherPublicWidgetOptions;
+exports.getIFramePublicWidgetOptions = getIFramePublicWidgetOptions;
+exports.getInteractiveGraphPublicWidgetOptions = getInteractiveGraphPublicWidgetOptions;
+exports.getLabelImagePublicWidgetOptions = getLabelImagePublicWidgetOptions;
+exports.getMatrixPublicWidgetOptions = getMatrixPublicWidgetOptions;
 exports.getMatrixSize = getMatrixSize;
+exports.getNumberLinePublicWidgetOptions = getNumberLinePublicWidgetOptions;
+exports.getNumericInputPublicWidgetOptions = getNumericInputPublicWidgetOptions;
 exports.getOrdererPublicWidgetOptions = getOrdererPublicWidgetOptions;
+exports.getPlotterPublicWidgetOptions = getPlotterPublicWidgetOptions;
+exports.getRadioPublicWidgetOptions = getRadioPublicWidgetOptions;
+exports.getSorterPublicWidgetOptions = getSorterPublicWidgetOptions;
+exports.getTablePublicWidgetOptions = getTablePublicWidgetOptions;
+exports.getUpgradedWidgetOptions = getUpgradedWidgetOptions;
 exports.getWidgetIdsFromContent = getWidgetIdsFromContent;
 exports.getWidgetIdsFromContentByType = getWidgetIdsFromContentByType;
-exports.gradedGroupLogic = GradedGroupWidgetLogic;
-exports.gradedGroupSetLogic = GradedGroupSetWidgetLogic;
-exports.groupLogic = GroupWidgetLogic;
+exports.gradedGroupLogic = gradedGroupWidgetLogic;
+exports.gradedGroupSetLogic = gradedGroupSetWidgetLogic;
+exports.grapherLogic = grapherWidgetLogic;
+exports.groupLogic = groupWidgetLogic;
 exports.iframeLogic = iframeWidgetLogic;
 exports.imageLogic = imageWidgetLogic;
 exports.inputNumberLogic = inputNumberWidgetLogic;
@@ -5302,7 +5767,7 @@ exports.parsePerseusItem = parsePerseusItem;
 exports.passageLogic = passageWidgetLogic;
 exports.passageRefLogic = passageRefWidgetLogic;
 exports.passageRefTargetLogic = passageRefTargetWidgetLogic;
-exports.phetSimulationLogic = PhetSimulationWidgetLogic;
+exports.phetSimulationLogic = phetSimulationWidgetLogic;
 exports.plotterLogic = plotterWidgetLogic;
 exports.plotterPlotTypes = plotterPlotTypes;
 exports.pluck = pluck;
@@ -5310,5 +5775,6 @@ exports.pythonProgramLogic = pythonProgramWidgetLogic;
 exports.radioLogic = radioWidgetLogic;
 exports.sorterLogic = sorterWidgetLogic;
 exports.tableLogic = tableWidgetLogic;
+exports.upgradeWidgetInfoToLatestVersion = upgradeWidgetInfoToLatestVersion;
 exports.videoLogic = videoWidgetLogic;
 //# sourceMappingURL=index.js.map