POC: migrate expression widget to latest version in PerseusItem parser

packages/perseus/src/util/parse-perseus-json/perseus-parsers/expression-widget.test.ts

@@ -0,0 +1,65 @@
+import {parseExpressionWidget} from "./expression-widget";
+import {parse} from "../parse";
+import {success} from "../result";
+
+describe("parseExpressionWidget", () => {
+    it("migrates v0 options to v1", () => {
+        const widget = {
+            "type": "expression",
+            "graded": true,
+            "options": {
+                "value": "the value",
+                "form": false,
+                "simplify": false,
+                "times": false,
+                "buttonsVisible": "never",
+                "buttonSets": [
+                    "basic"
+                ],
+                "functions": [
+                    "f",
+                    "g",
+                    "h"
+                ],
+            },
+            "version": {
+                "major": 0,
+                "minor": 1
+            }
+        }
+
+        expect(parse(widget, parseExpressionWidget)).toEqual(success({
+            "type": "expression",
+            "graded": true,
+            static: undefined,
+            key: undefined,
+            "alignment": undefined,
+            "options": {
+                "times": false,
+                ariaLabel: undefined,
+                visibleLabel: undefined,
+                "buttonsVisible": "never",
+                "buttonSets": [
+                    "basic"
+                ],
+                "functions": [
+                    "f",
+                    "g",
+                    "h"
+                ],
+                "answerForms": [
+                    {
+                        considered: "correct",
+                        form: false,
+                        simplify: false,
+                        value: "the value",
+                    },
+                ],
+            },
+            "version": {
+                "major": 1,
+                "minor": 0
+            }
+        }))
+    })
+})

packages/perseus/src/util/parse-perseus-json/perseus-parsers/expression-widget.ts

@@ -11,13 +11,20 @@ import {
     union,
 } from "../general-purpose-parsers";
 
-import {parseWidget} from "./widget";
+import {parseWidgetWithVersion, parseWidget} from "./widget";
+
+import Expression from "../../../widgets/expression/expression"
 
 import type {
     ExpressionWidget,
     PerseusExpressionAnswerForm,
 } from "../../../perseus-types";
-import type {Parser} from "../parser-types";
+import type {
+    ParseContext,
+    ParsedValue,
+    Parser,
+    ParseResult
+} from "../parser-types";
 
 const parseAnswerForm: Parser<PerseusExpressionAnswerForm> = object({
     value: string,
@@ -29,7 +36,7 @@ const parseAnswerForm: Parser<PerseusExpressionAnswerForm> = object({
     ).parser,
 });
 
-export const parseExpressionWidget: Parser<ExpressionWidget> = parseWidget(
+const parseExpressionWidgetLatest: Parser<ExpressionWidget> = parseWidget(
     constant("expression"),
     object({
         answerForms: array(parseAnswerForm),
@@ -51,3 +58,58 @@ export const parseExpressionWidget: Parser<ExpressionWidget> = parseWidget(
         buttonsVisible: optional(enumeration("always", "never", "focused")),
     }),
 );
+
+const parseExpressionWidgetV0 = parseWidgetWithVersion(
+    optional(object({major: constant(0), minor: number})),
+    constant("expression"),
+    object({
+        functions: array(string),
+        times: boolean,
+        visibleLabel: optional(string),
+        ariaLabel: optional(string),
+        form: boolean,
+        simplify: boolean,
+        value: string,
+        buttonSets: array(
+            enumeration(
+                "basic",
+                "basic+div",
+                "trig",
+                "prealgebra",
+                "logarithms",
+                "basic relations",
+                "advanced relations",
+            ),
+        ),
+        buttonsVisible: optional(enumeration("always", "never", "focused")),
+    }),
+);
+
+function migrateV0ToLatest(widget: ParsedValue<typeof parseExpressionWidgetV0>, ctx: ParseContext): ParseResult<ExpressionWidget> {
+    const {options} = widget;
+    return ctx.success({
+        ...widget,
+        version: Expression.version,
+        options: {
+            times: options.times,
+            buttonSets: options.buttonSets,
+            functions: options.functions,
+            buttonsVisible: options.buttonsVisible,
+            visibleLabel: options.visibleLabel,
+            ariaLabel: options.ariaLabel,
+
+            answerForms: [
+                {
+                    considered: "correct",
+                    form: options.form,
+                    simplify: options.simplify,
+                    value: options.value,
+                },
+            ],
+        },
+    })
+}
+
+export const parseExpressionWidget: Parser<ExpressionWidget> =
+    union(pipeParsers(parseExpressionWidgetV0).then(migrateV0ToLatest).parser)
+        .or(parseExpressionWidgetLatest).parser

packages/perseus/src/util/parse-perseus-json/perseus-parsers/widget.ts

@@ -28,3 +28,19 @@ export function parseWidget<Type extends string, Options>(
         ),
     });
 }
+
+export function parseWidgetWithVersion<Version extends {major: number, minor: number} | undefined, Type extends string, Options>(
+    parseVersion: Parser<Version>,
+    parseType: Parser<Type>,
+    parseOptions: Parser<Options>,
+): Parser<WidgetOptions<Type, Options>> {
+    return object({
+        type: parseType,
+        static: optional(boolean),
+        graded: optional(boolean),
+        alignment: optional(string),
+        options: parseOptions,
+        key: optional(number),
+        version: parseVersion,
+    });
+}