@khanacademy/perseus 3.0.0 → 4.0.0

package/src/widgets/__testdata__/radio_testdata.js

@@ -1,262 +0,0 @@
-// @flow
-import type {
-    PerseusRenderer,
-    RadioWidget,
-    PassageWidget,
-} from "../../perseus-types.js";
-
-export const question: PerseusRenderer = {
-    content:
-        "Which of the following values of $x$ satisfies the equation $\\sqrt{64}=x$ ?\n\n[[\u2603 radio 1]]\n\n",
-    images: {},
-    widgets: {
-        "radio 1": ({
-            graded: true,
-            version: {
-                major: 1,
-                minor: 0,
-            },
-            static: false,
-            type: "radio",
-            options: {
-                displayCount: null,
-                onePerLine: false,
-                choices: [
-                    {
-                        content: "$-8$ and $8$",
-                        correct: false,
-                        clue: "The square root operation ($\\sqrt{\\phantom{x}}$) calculates *only* the positive square root when performed on a number, so $x$ is equal to *only* $8$.",
-                    },
-                    {
-                        content: "$-8$",
-                        correct: false,
-                        clue: "While $(-8)^2=64$, the square root operation ($\\sqrt{\\phantom{x}}$) calculates *only* the positive square root when performed on a number.",
-                    },
-                    {
-                        content: "$8$",
-                        correct: true,
-                        isNoneOfTheAbove: false,
-                        clue: "$8$ is the positive square root of $64$.",
-                    },
-                    {
-                        content: "No value of $x$ satisfies the equation.",
-                        correct: false,
-                        isNoneOfTheAbove: false,
-                        clue: "$8$ satisfies the equation.",
-                    },
-                ],
-                countChoices: false,
-                hasNoneOfTheAbove: false,
-                multipleSelect: false,
-                randomize: false,
-                deselectEnabled: false,
-            },
-            alignment: "default",
-        }: RadioWidget),
-    },
-};
-
-export const questionAndAnswer: [
-    PerseusRenderer,
-    number,
-    $ReadOnlyArray<number>,
-] = [question, 2, [0, 1, 3]];
-
-export const passageWidget: PassageWidget = {
-    alignment: "default",
-    graded: true,
-    options: {
-        footnotes: "",
-        passageText: "Line 1 {{Reference 1 \n\nis here.}}\n\n{{Another ref}}",
-        passageTitle: "",
-        showLineNumbers: true,
-        static: false,
-    },
-    static: false,
-    type: "passage",
-    version: {major: 0, minor: 0},
-};
-
-export const questionWithPassage: PerseusRenderer = {
-    content:
-        "Read the following passage:\n\n[[\u2603 passage 1]]\n\nWhich of the following values of $x$ satisfies the equation $\\sqrt{64}=x$ ?\n\n[[\u2603 radio 1]]\n\n",
-    images: {},
-    widgets: {
-        "radio 1": ({
-            graded: true,
-            version: {
-                major: 1,
-                minor: 0,
-            },
-            static: false,
-            type: "radio",
-            options: {
-                displayCount: null,
-                choices: [
-                    {
-                        content: "$-8$ and $8$",
-                        correct: false,
-                        clue: "The square root operation ($\\sqrt{\\phantom{x}}$) calculates *only* the positive square root when performed on a number, so $x$ is equal to *only* $8$.",
-                    },
-                    {
-                        content: "$-8$",
-                        correct: false,
-                        clue: "While $(-8)^2=64$, the square root operation ($\\sqrt{\\phantom{x}}$) calculates *only* the positive square root when performed on a number.",
-                    },
-                    {
-                        content: "$8$ {{passage-ref 1 1}}\n\n",
-                        correct: true,
-                        isNoneOfTheAbove: false,
-                        clue: "$8$ is the positive square root of $64$.",
-                    },
-                    {
-                        content: "No value of $x$ satisfies the equation.",
-                        correct: false,
-                        isNoneOfTheAbove: false,
-                        clue: "$8$ satisfies the equation.",
-                    },
-                ],
-                countChoices: false,
-                hasNoneOfTheAbove: false,
-                multipleSelect: false,
-                randomize: false,
-                deselectEnabled: false,
-            },
-            alignment: "default",
-        }: RadioWidget),
-        "passage 1": ({
-            alignment: "default",
-            graded: true,
-            options: {
-                footnotes: "",
-                passageText:
-                    "Here's a passage about the positive square root. It contains a {{reference to something}}.",
-                passageTitle: "",
-                showLineNumbers: true,
-                static: false,
-            },
-            static: false,
-            type: "passage",
-            version: {major: 0, minor: 0},
-        }: PassageWidget),
-    },
-};
-
-export const multiChoiceQuestion: PerseusRenderer = {
-    content:
-        "**Select all input values for which $g(x)=2$.**\n\n[[\u2603 radio 1]]\n\n ![](web+graphie://ka-perseus-graphie.s3.amazonaws.com/4613e0d9c906b3053fb5523eed83d4f779fdf6bb)",
-    images: {
-        "web+graphie://ka-perseus-graphie.s3.amazonaws.com/4613e0d9c906b3053fb5523eed83d4f779fdf6bb":
-            {
-                width: 428,
-                height: 428,
-            },
-    },
-    widgets: {
-        "radio 1": ({
-            graded: true,
-            version: {
-                major: 1,
-                minor: 0,
-            },
-            static: false,
-            type: "radio",
-            options: {
-                onePerLine: true,
-                displayCount: null,
-                choices: [
-                    {
-                        content: "$x=-6$",
-                        correct: false,
-                    },
-                    {
-                        content: "$x=4$",
-                        correct: false,
-                    },
-                    {
-                        content: "$x=7$",
-                        isNoneOfTheAbove: false,
-                        correct: false,
-                    },
-                    {
-                        content: "There is no such input value.",
-                        isNoneOfTheAbove: true,
-                        correct: true,
-                    },
-                ],
-                hasNoneOfTheAbove: true,
-                multipleSelect: true,
-                randomize: false,
-                deselectEnabled: false,
-            },
-            alignment: "default",
-        }: RadioWidget),
-    },
-};
-
-export const multiChoiceQuestionSimple: PerseusRenderer = {
-    content: "What are some ways to say hello?\n\n[[\u2603 radio 1]]",
-    images: {},
-    widgets: {
-        "radio 1": ({
-            graded: true,
-            version: {
-                major: 1,
-                minor: 0,
-            },
-            static: false,
-            type: "radio",
-            options: {
-                onePerLine: true,
-                displayCount: null,
-                choices: [
-                    {
-                        content: "Hola",
-                        isNoneOfTheAbove: false,
-                        correct: true,
-                    },
-                    {
-                        content: "Hey",
-                        isNoneOfTheAbove: false,
-                        correct: true,
-                    },
-                    {
-                        content: "Hi",
-                        isNoneOfTheAbove: false,
-                        correct: true,
-                    },
-                    {
-                        content: "Goodbye",
-                        isNoneOfTheAbove: false,
-                        correct: false,
-                    },
-                    {
-                        content: "None of these",
-                        isNoneOfTheAbove: true,
-                        correct: false,
-                    },
-                ],
-                hasNoneOfTheAbove: true,
-                multipleSelect: true,
-                randomize: false,
-                deselectEnabled: false,
-            },
-            alignment: "default",
-        }: RadioWidget),
-    },
-};
-
-export const multiChoiceQuestionAndAnswer: [
-    PerseusRenderer,
-    $ReadOnlyArray<number>,
-    $ReadOnlyArray<$ReadOnlyArray<number>>,
-    $ReadOnlyArray<$ReadOnlyArray<number>>,
-] = [
-    multiChoiceQuestion,
-    [3],
-    [[0], [1], [2], [0, 1], [0, 2], [0, 1, 2], [1, 2]],
-    [
-        [0, 3],
-        [0, 1, 2, 3],
-    ],
-];

package/src/widgets/__testdata__/sorter_testdata.js

@@ -1,20 +0,0 @@
-// @flow
-import type {PerseusRenderer} from "../../perseus-types.js";
-
-export const question1: PerseusRenderer = {
-    content:
-        "**Arrange the following measurements in order from smallest to largest.**\n\n[[\u2603 sorter 1]]",
-    images: {},
-    widgets: {
-        "sorter 1": {
-            version: {major: 0, minor: 0},
-            type: "sorter",
-            graded: true,
-            options: {
-                padding: true,
-                layout: "horizontal",
-                correct: ["$0.005$ kilograms", "$15$ grams", "$55$ grams"],
-            },
-        },
-    },
-};

package/src/widgets/__testdata__/transformer_testdata.js

@@ -1,109 +0,0 @@
-// @flow
-import type {PerseusRenderer, TransformerWidget} from "../../perseus-types.js";
-
-export const question: PerseusRenderer = {
-    content:
-        "$\\overleftrightarrow{MN}$ is the perpendicular bisector of segment $\\overline{JL}$.  \n\n**Perform a reflection that proves $M$ must be equidistant from $J$ and $L$ and select the option which explains the proof.**  \nThe statement must be true for any point $M$ which lies on the perpendicular bisector.  \n\n[[☃ transformer 1]]  \n\n",
-    images: {
-        "https://ka-perseus-images.s3.amazonaws.com/6cf0d9f007084e9d06e3ce0e241416dde920ec9c.png":
-            {height: 503, width: 504},
-    },
-    widgets: {
-        "transformer 1": ({
-            graded: true,
-            options: {
-                correct: {
-                    shape: {
-                        coords: [
-                            [-1.1546319456101628e-14, -1.199040866595169e-14],
-                            [6.999999999999989, 6.999999999999986],
-                            [-7.000000000000007, 6.999999999999989],
-                        ],
-                        options: [{}],
-                        type: ["polygon-3"],
-                    },
-                    transformations: [
-                        {
-                            line: [
-                                [1.499999999999988, -1.5000000000000002],
-                                [-1.4999999999999996, 1.4999999999999882],
-                            ],
-                            type: "reflection",
-                        },
-                    ],
-                },
-                drawSolutionShape: false,
-                gradeEmpty: false,
-                graph: {
-                    backgroundImage: {
-                        bottom: 0,
-                        height: 400,
-                        left: 0,
-                        scale: 1,
-                        url: "https://ka-perseus-graphie.s3.amazonaws.com/778924d189c73077f3338098cb4e48fe79695f93.png",
-                        width: 400,
-                    },
-                    gridStep: [1, 1],
-                    labels: ["x", "y"],
-                    markings: "none",
-                    range: [
-                        [-10, 10],
-                        [-10, 10],
-                    ],
-                    rulerLabel: "",
-                    rulerTicks: 10,
-                    showProtractor: false,
-                    showRuler: false,
-                    snapStep: [0.5, 0.5],
-                    step: [1, 1],
-                },
-                graphMode: "interactive",
-                listMode: "static",
-                starting: {
-                    // $FlowFixMe[speculation-ambiguous]
-                    shape: {
-                        coords: [
-                            [0, 0],
-                            [-7, -7],
-                            [-7, 7],
-                        ],
-                        options: [{}],
-                        type: ["polygon-3"],
-                    },
-                    transformations: [],
-                },
-                tools: {
-                    dilation: {
-                        constraints: {fixed: false},
-                        coord: [6, 6],
-                        enabled: true,
-                        required: false,
-                    },
-                    reflection: {
-                        constraints: {fixed: false},
-                        coords: [
-                            [8, -1.5],
-                            [8, 2.5],
-                        ],
-                        enabled: true,
-                        required: false,
-                    },
-                    rotation: {
-                        constraints: {fixed: false},
-                        coord: [1, 6],
-                        enabled: true,
-                        required: false,
-                    },
-                    translation: {
-                        constraints: {},
-                        enabled: true,
-                        required: false,
-                    },
-                },
-                version: 1.2,
-            },
-            type: "transformer",
-            version: {major: 0, minor: 0},
-        }: TransformerWidget),
-    },
-};

package/src/widgets/__testdata__/video_testdata.js

@@ -1,22 +0,0 @@
-// @flow
-import type {PerseusRenderer} from "../../perseus-types.js";
-
-export const question1: PerseusRenderer = {
-    content:
-        "Watch the Biogeography: Where Life Lives video to find the answer.\n\n[[\u2603 video 1]]\n\n",
-    images: {},
-    widgets: {
-        "video 1": {
-            graded: true,
-            version: {major: 0, minor: 0},
-            static: false,
-            type: "video",
-            options: {
-                static: false,
-                location: "biogeography-where-life-lives",
-            },
-            alignment: "block",
-        },
-    },
-    replace: false,
-};

package/src/widgets/__tests__/categorizer_test.jsx

@@ -1,205 +0,0 @@
-// @flow
-
-import {screen} from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import "@testing-library/jest-dom";
-
-import {testDependencies} from "../../../../../testing/test-dependencies.js";
-import * as Dependencies from "../../dependencies.js";
-import {question1} from "../__testdata__/categorizer_testdata.js";
-import {Categorizer} from "../categorizer.jsx";
-
-import {renderQuestion} from "./renderQuestion.jsx";
-
-import type {APIOptions} from "../../types.js";
-import type {Rubric} from "../categorizer.jsx";
-
-describe("categorizer widget", () => {
-    beforeEach(() => {
-        jest.spyOn(Dependencies, "getDependencies").mockReturnValue(
-            testDependencies,
-        );
-    });
-
-    it("should snapshot", () => {
-        // Arrange
-        const apiOptions: APIOptions = {
-            isMobile: false,
-        };
-
-        // Act
-        const {container} = renderQuestion(question1, apiOptions);
-
-        // Assert
-        expect(container).toMatchSnapshot("first render");
-    });
-
-    it("should snapshot on mobile", () => {
-        // Arrange
-        const apiOptions: APIOptions = {
-            isMobile: true,
-        };
-
-        // Act
-        const {container} = renderQuestion(question1, apiOptions);
-
-        // Assert
-        expect(container).toMatchSnapshot("first mobile render");
-    });
-
-    it("is incorrect when blank", () => {
-        // Arrange
-        const apiOptions: APIOptions = {
-            isMobile: false,
-        };
-        const {renderer} = renderQuestion(question1, apiOptions);
-
-        // Act
-        const [_, score] = renderer.guessAndScore();
-
-        // Assert
-        expect(score).toMatchInlineSnapshot(`
-            {
-              "message": "Make sure you select something for every row.",
-              "type": "invalid",
-            }
-        `);
-    });
-
-    it("can be answered incorrectly", () => {
-        // arrange
-        const {renderer} = renderQuestion(question1);
-
-        const firstItem = screen.getAllByRole("row")[0];
-        userEvent.click(firstItem);
-
-        // act
-        const [_, score] = renderer.guessAndScore();
-
-        // assert
-        expect(score).toMatchInlineSnapshot(`
-            {
-              "message": "Make sure you select something for every row.",
-              "type": "invalid",
-            }
-        `);
-    });
-
-    it("can be answered correctly", () => {
-        // arrange
-        const {renderer} = renderQuestion(question1);
-
-        // act
-        userEvent.click(
-            screen.getAllByRole("button", {name: "No relationship"})[0],
-        );
-        userEvent.click(
-            screen.getAllByRole("button", {
-                name: "Positive linear relationship",
-            })[0],
-        );
-        userEvent.click(
-            screen.getAllByRole("button", {
-                name: "Negative linear relationship",
-            })[1],
-        );
-        userEvent.click(
-            screen.getAllByRole("button", {name: "Nonlinear relationship"})[1],
-        );
-
-        jest.runOnlyPendingTimers();
-        renderer.guessAndScore();
-
-        // assert
-        expect(renderer).toHaveBeenAnsweredCorrectly();
-    });
-});
-
-describe("validating answers", () => {
-    it("gives points when the answer is correct", () => {
-        const rubric: Rubric = {
-            items: ["Graph $1$", "Graph $2$"],
-            values: [1, 3],
-            randomizeItems: false,
-            categories: [
-                "No relationship",
-                "Positive linear relationship",
-                "Negative linear relationship",
-                "Nonlinear relationship",
-            ],
-            highlightLint: false,
-            static: false,
-        };
-
-        const useInput = {
-            values: [1, 3],
-        };
-        const score = Categorizer.validate(useInput, rubric);
-
-        expect(score).toMatchInlineSnapshot(`
-            {
-              "earned": 1,
-              "message": null,
-              "total": 1,
-              "type": "points",
-            }
-        `);
-    });
-
-    it("does not give points when incorrectly answered", () => {
-        const rubric: Rubric = {
-            items: ["Graph $1$", "Graph $2$"],
-            values: [1, 3],
-            randomizeItems: false,
-            categories: [
-                "No relationship",
-                "Positive linear relationship",
-                "Negative linear relationship",
-                "Nonlinear relationship",
-            ],
-            highlightLint: false,
-            static: false,
-        };
-
-        const useInput = {
-            values: [2, 3],
-        };
-        const score = Categorizer.validate(useInput, rubric);
-
-        expect(score).toMatchInlineSnapshot(`
-            {
-              "earned": 0,
-              "message": null,
-              "total": 1,
-              "type": "points",
-            }
-        `);
-    });
-    it("tells the learner its not complete if not selected", () => {
-        const rubric: Rubric = {
-            items: ["Graph $1$", "Graph $2$"],
-            values: [1, 3],
-            randomizeItems: false,
-            categories: [
-                "No relationship",
-                "Positive linear relationship",
-                "Negative linear relationship",
-                "Nonlinear relationship",
-            ],
-            highlightLint: false,
-            static: false,
-        };
-
-        const useInput = {
-            values: [2],
-        };
-        const score = Categorizer.validate(useInput, rubric);
-
-        expect(score).toMatchInlineSnapshot(`
-            {
-              "message": "Make sure you select something for every row.",
-              "type": "invalid",
-            }
-        `);
-    });
-});

package/src/widgets/__tests__/cs-program_test.jsx

@@ -1,45 +0,0 @@
-// @flow
-
-import "@testing-library/jest-dom";
-
-import {testDependencies} from "../../../../../testing/test-dependencies.js";
-import * as Dependencies from "../../dependencies.js";
-import {question1} from "../__testdata__/cs-program_testdata.js";
-
-import {renderQuestion} from "./renderQuestion.jsx";
-
-describe("cs-program widget", () => {
-    beforeEach(() => {
-        jest.spyOn(Dependencies, "getDependencies").mockReturnValue(
-            testDependencies,
-        );
-    });
-
-    it("should snapshot", () => {
-        // Arrange
-        const apiOptions = {
-            isMobile: false,
-        };
-
-        // Act
-        const {container} = renderQuestion(question1, apiOptions);
-
-        // Assert
-        expect(container).toMatchSnapshot("first render");
-    });
-
-    it("should snapshot on mobile", () => {
-        // Arrange
-        const apiOptions = {
-            isMobile: true,
-        };
-
-        // Act
-        const {container} = renderQuestion(question1, apiOptions);
-
-        // Assert
-        expect(container).toMatchSnapshot("first mobile render");
-    });
-
-    // This widget doesn't have any direct behavior, it just renders an iframe
-});