@khanacademy/perseus 43.0.1 → 44.0.0

package/dist/util/parse-perseus-json/general-purpose-parsers/pipe-parsers.typetest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/parse-perseus-json/general-purpose-parsers/unknown.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare const unknown: Parser<unknown>;

package/dist/util/parse-perseus-json/perseus-parsers/graded-group-widget.d.ts

@@ -3,9 +3,9 @@ import type { Parser } from "../parser-types";
 export declare const parseGradedGroupWidgetOptions: Parser<{
     title: string;
     hasHint: boolean | null | undefined;
-    hint: import("../../../perseus-types").PerseusRenderer | null | undefined;
+    hint: import("../../..").PerseusRenderer | null | undefined;
     content: string;
-    widgets: import("../../../perseus-types").PerseusWidgetsMap;
+    widgets: import("../../..").PerseusWidgetsMap;
     widgetEnabled: boolean | null | undefined;
     immutableWidgets: boolean | null | undefined;
     images: Record<string, {

package/dist/util/parse-perseus-json/perseus-parsers/images-map.d.ts

@@ -0,0 +1,5 @@
+import type { PerseusImageDetail } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parseImages: Parser<{
+    [key: string]: PerseusImageDetail;
+}>;

package/dist/util/parse-perseus-json/perseus-parsers/widget.d.ts

@@ -1,3 +1,7 @@
 import type { WidgetOptions } from "../../../perseus-types";
 import type { Parser } from "../parser-types";
 export declare function parseWidget<Type extends string, Options>(parseType: Parser<Type>, parseOptions: Parser<Options>): Parser<WidgetOptions<Type, Options>>;
+export declare 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>>;

package/dist/validation.types.d.ts

@@ -27,15 +27,18 @@
  * } & Perseus<Widget>ValidationData;
  * ```
  */
-import type { GrapherAnswerTypes, PerseusDropdownChoice, PerseusExpressionAnswerForm, PerseusGradedGroupSetWidgetOptions, PerseusGradedGroupWidgetOptions, PerseusGraphType, PerseusGroupWidgetOptions, PerseusMatcherWidgetOptions, PerseusMatrixWidgetAnswers, PerseusNumberLineWidgetOptions, PerseusNumericInputAnswer, PerseusOrdererWidgetOptions, PerseusPlotterWidgetOptions, PerseusRadioChoice, PerseusGraphCorrectType } from "./perseus-types";
+import type { GrapherAnswerTypes, PerseusDropdownChoice, PerseusExpressionAnswerForm, PerseusGradedGroupSetWidgetOptions, PerseusGradedGroupWidgetOptions, PerseusGraphType, PerseusGroupWidgetOptions, PerseusMatcherWidgetOptions, PerseusMatrixWidgetAnswers, PerseusNumberLineWidgetOptions, PerseusNumericInputAnswer, PerseusOrdererWidgetOptions, PerseusRadioChoice, PerseusGraphCorrectType } from "./perseus-types";
 import type { InteractiveMarkerType } from "./widgets/label-image/types";
 import type { Relationship } from "./widgets/number-line/number-line";
 export type UserInputStatus = "correct" | "incorrect" | "incomplete";
-export type PerseusCategorizerRubric = {
+export type PerseusCategorizerScoringData = {
     values: ReadonlyArray<number>;
-};
+} & PerseusCategorizerValidationData;
 export type PerseusCategorizerUserInput = {
-    values: PerseusCategorizerRubric["values"];
+    values: PerseusCategorizerScoringData["values"];
+};
+export type PerseusCategorizerValidationData = {
+    items: ReadonlyArray<string>;
 };
 export type PerseusCSProgramRubric = Empty;
 export type PerseusCSProgramUserInput = {
@@ -117,7 +120,12 @@ export type PerseusOrdererRubric = PerseusOrdererWidgetOptions;
 export type PerseusOrdererUserInput = {
     current: ReadonlyArray<string>;
 };
-export type PerseusPlotterRubric = PerseusPlotterWidgetOptions;
+export type PerseusPlotterScoringData = {
+    correct: ReadonlyArray<number>;
+} & PerseusPlotterValidationData;
+export type PerseusPlotterValidationData = {
+    starting: ReadonlyArray<number>;
+};
 export type PerseusPlotterUserInput = ReadonlyArray<number>;
 export type PerseusRadioRubric = {
     choices: ReadonlyArray<PerseusRadioChoice>;
@@ -136,7 +144,7 @@ export type PerseusTableRubric = {
     answers: ReadonlyArray<ReadonlyArray<string>>;
 };
 export type PerseusTableUserInput = ReadonlyArray<ReadonlyArray<string>>;
-export type Rubric = PerseusCategorizerRubric | PerseusCSProgramRubric | PerseusDropdownRubric | PerseusExpressionRubric | PerseusGroupRubric | PerseusGradedGroupRubric | PerseusGradedGroupSetRubric | PerseusGrapherRubric | PerseusIFrameRubric | PerseusInputNumberRubric | PerseusInteractiveGraphRubric | PerseusLabelImageRubric | PerseusMatcherRubric | PerseusMatrixRubric | PerseusNumberLineRubric | PerseusNumericInputRubric | PerseusOrdererRubric | PerseusPlotterRubric | PerseusRadioRubric | PerseusSorterRubric | PerseusTableRubric;
+export type Rubric = PerseusCategorizerScoringData | PerseusCSProgramRubric | PerseusDropdownRubric | PerseusExpressionRubric | PerseusGroupRubric | PerseusGradedGroupRubric | PerseusGradedGroupSetRubric | PerseusGrapherRubric | PerseusIFrameRubric | PerseusInputNumberRubric | PerseusInteractiveGraphRubric | PerseusLabelImageRubric | PerseusMatcherRubric | PerseusMatrixRubric | PerseusNumberLineRubric | PerseusNumericInputRubric | PerseusOrdererRubric | PerseusPlotterScoringData | PerseusRadioRubric | PerseusSorterRubric | PerseusTableRubric;
 export type UserInput = PerseusCategorizerUserInput | PerseusCSProgramUserInput | PerseusDropdownUserInput | PerseusExpressionUserInput | PerseusGrapherUserInput | PerseusIFrameUserInput | PerseusInputNumberUserInput | PerseusInteractiveGraphUserInput | PerseusLabelImageUserInput | PerseusMatcherUserInput | PerseusMatrixUserInput | PerseusNumberLineUserInput | PerseusNumericInputUserInput | PerseusOrdererUserInput | PerseusPlotterUserInput | PerseusRadioUserInput | PerseusSorterUserInput | PerseusTableUserInput;
 export type UserInputMap = {
     [widgetId: string]: UserInput | UserInputMap;

package/dist/widgets/categorizer/categorizer.d.ts

@@ -3,9 +3,9 @@ import { PerseusI18nContext } from "../../components/i18n-context";
 import scoreCategorizer from "./score-categorizer";
 import type { PerseusCategorizerWidgetOptions } from "../../perseus-types";
 import type { Widget, WidgetProps } from "../../types";
-import type { PerseusCategorizerRubric, PerseusCategorizerUserInput } from "../../validation.types";
+import type { PerseusCategorizerScoringData, PerseusCategorizerUserInput } from "../../validation.types";
 import type { CategorizerPromptJSON } from "../../widget-ai-utils/categorizer/categorizer-ai-utils";
-type Props = WidgetProps<RenderProps, PerseusCategorizerRubric> & {
+type Props = WidgetProps<RenderProps, PerseusCategorizerScoringData> & {
     values: ReadonlyArray<string>;
 };
 type DefaultProps = {

package/dist/widgets/categorizer/score-categorizer.d.ts

@@ -1,5 +1,5 @@
 import type { PerseusStrings } from "../../strings";
 import type { PerseusScore } from "../../types";
-import type { PerseusCategorizerRubric, PerseusCategorizerUserInput } from "../../validation.types";
-declare function scoreCategorizer(userInput: PerseusCategorizerUserInput, rubric: PerseusCategorizerRubric, strings: PerseusStrings): PerseusScore;
+import type { PerseusCategorizerScoringData, PerseusCategorizerUserInput } from "../../validation.types";
+declare function scoreCategorizer(userInput: PerseusCategorizerUserInput, scoringData: PerseusCategorizerScoringData, strings: PerseusStrings): PerseusScore;
 export default scoreCategorizer;

package/dist/widgets/categorizer/validate-categorizer.d.ts

@@ -0,0 +1,15 @@
+import type { PerseusStrings } from "../../strings";
+import type { PerseusScore } from "../../types";
+import type { PerseusCategorizerUserInput, PerseusCategorizerValidationData } from "../../validation.types";
+/**
+ * Checks userInput from the categorizer widget to see if the user has selected
+ * a category for each item.
+ * @param userInput - The user's input corresponding to an array of indices that
+ * represent the selected category for each row/item.
+ * @param validationData - An array of strings corresponding to each row/item
+ * @param strings - Used to provide a validation message
+ */
+declare function validateCategorizer(userInput: PerseusCategorizerUserInput, validationData: PerseusCategorizerValidationData, strings: PerseusStrings): Extract<PerseusScore, {
+    type: "invalid";
+}> | null;
+export default validateCategorizer;

package/dist/widgets/definition/definition.d.ts

@@ -29,6 +29,6 @@ declare const _default: {
     defaultAlignment: "inline";
     widget: typeof Definition;
     transform: (x: any) => any;
-    scorer: () => import("../../types").PerseusScore;
+    scorer: () => import("../..").PerseusScore;
 };
 export default _default;

package/dist/widgets/deprecated-standin/deprecated-standin.d.ts

@@ -16,6 +16,6 @@ declare const _default: {
     displayName: string;
     widget: typeof DeprecatedStandin;
     hidden: true;
-    scorer: () => import("../../types").PerseusScore;
+    scorer: () => import("../..").PerseusScore;
 };
 export default _default;

package/dist/widgets/dropdown/dropdown.d.ts

@@ -1,4 +1,5 @@
 import * as React from "react";
+import { PerseusI18nContext } from "../../components/i18n-context";
 import scoreDropdown from "./score-dropdown";
 import type { PerseusDropdownWidgetOptions } from "../../perseus-types";
 import type { Widget, WidgetProps } from "../../types";
@@ -14,6 +15,11 @@ type DefaultProps = {
     apiOptions: Props["apiOptions"];
 };
 declare class Dropdown extends React.Component<Props> implements Widget {
+    static contextType: React.Context<{
+        strings: import("../../strings").PerseusStrings;
+        locale: string;
+    }>;
+    context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
     focus: () => boolean;
     _handleChangeEvent: (arg1: React.ChangeEvent<HTMLInputElement>) => void;
@@ -23,7 +29,9 @@ declare class Dropdown extends React.Component<Props> implements Widget {
     render(): React.ReactNode;
 }
 type RenderProps = {
-    placeholder: string;
+    placeholder: PerseusDropdownWidgetOptions["placeholder"];
+    visibleLabel: PerseusDropdownWidgetOptions["visibleLabel"];
+    ariaLabel: PerseusDropdownWidgetOptions["ariaLabel"];
     choices: ReadonlyArray<string>;
 };
 declare const _default: {

package/dist/widgets/dropdown/validate-dropdown.d.ts

@@ -0,0 +1,10 @@
+import type { PerseusScore } from "../../types";
+import type { PerseusDropdownUserInput } from "../../validation.types";
+/**
+ * Checks if the user has selected an item from the dropdown before scoring.
+ * This is shown with a userInput value / index other than 0.
+ */
+declare function validateDropdown(userInput: PerseusDropdownUserInput): Extract<PerseusScore, {
+    type: "invalid";
+}> | null;
+export default validateDropdown;

package/dist/widgets/explanation/explanation.d.ts

@@ -40,6 +40,6 @@ declare const _default: {
     widget: typeof Explanation;
     transform: <T>(value: T) => T;
     isLintable: true;
-    scorer: () => import("../../types").PerseusScore;
+    scorer: () => import("../..").PerseusScore;
 };
 export default _default;

package/dist/widgets/expression/expression.d.ts

@@ -99,264 +99,139 @@ declare const _default: {
         static: boolean | null | undefined;
         problemNum: number | null | undefined;
         apiOptions: Readonly<Readonly<{
-            isArticle?: boolean | undefined;
-            onFocusChange?: ((newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
-            GroupMetadataEditor?: React.ComponentType<any> | undefined;
-            showAlignmentOptions?: boolean | undefined;
-            readOnly?: boolean | undefined;
-            answerableCallback?: ((arg1: boolean) => unknown) | undefined;
-            getAnotherHint?: (() => unknown) | undefined;
-            interactionCallback?: ((widgetData: {
+            isArticle?: boolean;
+            onFocusChange?: (newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
+            GroupMetadataEditor?: React.ComponentType<any>;
+            showAlignmentOptions?: boolean;
+            readOnly?: boolean;
+            answerableCallback?: (arg1: boolean) => unknown;
+            getAnotherHint?: () => unknown;
+            interactionCallback?: (widgetData: {
                 [widgetId: string]: any;
-            }) => void) | undefined;
-            groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
+            }) => void;
+            groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
             imagePlaceholder?: React.ReactNode;
             widgetPlaceholder?: React.ReactNode;
             baseElements?: {
                 Link: React.ComponentType<any>;
-            } | undefined;
-            imagePreloader?: ((dimensions: import("../../types").Dimensions) => React.ReactNode) | undefined;
-            trackInteraction?: ((args: {
+            };
+            imagePreloader?: (dimensions: import("../../types").Dimensions) => React.ReactNode;
+            trackInteraction?: (args: {
                 type: string;
                 id: string;
-                correct?: boolean | undefined;
+                correct?: boolean;
             } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
                 visible: number;
-            }>) => void) | undefined;
-            customKeypad?: boolean | undefined;
-            nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
-            isMobile?: boolean | undefined;
-            setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
-            hintProgressColor?: string | undefined;
-            canScrollPage?: boolean | undefined;
-            crossOutEnabled?: boolean | undefined;
-            editorChangeDelay?: number | undefined;
+            }>) => void;
+            customKeypad?: boolean;
+            nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
+            isMobile?: boolean;
+            setDrawingAreaAvailable?: (arg1: boolean) => unknown;
+            hintProgressColor?: string;
+            canScrollPage?: boolean;
+            crossOutEnabled?: boolean;
+            editorChangeDelay?: number;
             flags?: {
-                mafs?: false | ({
-                    none?: boolean | undefined;
-                    linear?: boolean | undefined;
-                    circle?: boolean | undefined;
-                    polygon?: boolean | undefined;
-                    point?: boolean | undefined;
-                    quadratic?: boolean | undefined;
-                    sinusoid?: boolean | undefined;
-                    angle?: boolean | undefined;
-                    "linear-system"?: boolean | undefined;
-                    ray?: boolean | undefined;
-                    segment?: boolean | undefined;
-                    "unlimited-polygon"?: boolean | undefined;
-                    "unlimited-point"?: boolean | undefined;
-                } & {
-                    "interactive-graph-locked-features-labels"?: boolean | undefined;
-                    "locked-figures-aria"?: boolean | undefined;
-                    "locked-point-labels"?: boolean | undefined;
-                    "locked-line-labels"?: boolean | undefined;
-                    "locked-vector-labels"?: boolean | undefined;
-                    "locked-ellipse-labels"?: boolean | undefined;
-                    "locked-polygon-labels"?: boolean | undefined;
-                    "locked-function-labels"?: boolean | undefined;
-                }) | undefined;
-            } | undefined;
-            onWidgetStartProps?: ((widgets: import("../../perseus-types").PerseusWidgetsMap) => void) | undefined;
-        }> & {
-            GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
-            baseElements: {
-                Link: React.ComponentType<any>;
+                mafs?: false | ({ [Key in typeof import("../../types").MafsGraphTypeFlags[number]]?: boolean; } & { [Key in typeof import("../../types").InteractiveGraphLockedFeaturesFlags[number]]?: boolean; });
             };
-            canScrollPage: NonNullable<boolean | undefined>;
-            crossOutEnabled: NonNullable<boolean | undefined>;
-            editorChangeDelay: number;
-            groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
-            isArticle: NonNullable<boolean | undefined>;
-            isMobile: NonNullable<boolean | undefined>;
-            onFocusChange: (newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
-            readOnly: NonNullable<boolean | undefined>;
-            setDrawingAreaAvailable: (arg1: boolean) => unknown;
-            showAlignmentOptions: NonNullable<boolean | undefined>;
+            onWidgetStartProps?: (widgets: import("../..").PerseusWidgetsMap) => void;
+        }> & {
+            GroupMetadataEditor: NonNullable<import("../..").APIOptions["GroupMetadataEditor"]>;
+            baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
+            canScrollPage: NonNullable<import("../..").APIOptions["canScrollPage"]>;
+            crossOutEnabled: NonNullable<import("../..").APIOptions["crossOutEnabled"]>;
+            editorChangeDelay: NonNullable<import("../..").APIOptions["editorChangeDelay"]>;
+            groupAnnotator: NonNullable<import("../..").APIOptions["groupAnnotator"]>;
+            isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
+            isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
+            onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
+            readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
+            setDrawingAreaAvailable: NonNullable<import("../..").APIOptions["setDrawingAreaAvailable"]>;
+            showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
         }>;
         keypadElement?: any;
-        questionCompleted?: boolean | undefined;
+        questionCompleted?: boolean;
         onFocus: (blurPath: FocusPath) => void;
         onBlur: (blurPath: FocusPath) => void;
-        findWidgets: (criterion: import("../../types").FilterCriterion) => readonly Widget[];
+        findWidgets: (criterion: import("../../types").FilterCriterion) => ReadonlyArray<Widget>;
         reviewModeRubric?: PerseusExpressionRubric | null | undefined;
         reviewMode: boolean;
-        onChange: import("../../types").ChangeHandler;
+        onChange: import("../..").ChangeHandler;
         trackInteraction: (extraData?: Empty | undefined) => void;
         isLastUsedWidget: boolean;
         linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
         containerSizeClass: import("../../util/sizing-utils").SizeClass;
-    } & Partial<import("../../types").PerseusDependenciesV2> & {
-        apiOptions: Readonly<Readonly<{
-            isArticle?: boolean | undefined;
-            onFocusChange?: ((newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
-            GroupMetadataEditor?: React.ComponentType<any> | undefined;
-            showAlignmentOptions?: boolean | undefined;
-            readOnly?: boolean | undefined;
-            answerableCallback?: ((arg1: boolean) => unknown) | undefined;
-            getAnotherHint?: (() => unknown) | undefined;
-            interactionCallback?: ((widgetData: {
-                [widgetId: string]: any;
-            }) => void) | undefined;
-            groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
-            imagePlaceholder?: React.ReactNode;
-            widgetPlaceholder?: React.ReactNode;
-            baseElements?: {
-                Link: React.ComponentType<any>;
-            } | undefined;
-            imagePreloader?: ((dimensions: import("../../types").Dimensions) => React.ReactNode) | undefined;
-            trackInteraction?: ((args: {
-                type: string;
-                id: string;
-                correct?: boolean | undefined;
-            } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
-                visible: number;
-            }>) => void) | undefined;
-            customKeypad?: boolean | undefined;
-            nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
-            isMobile?: boolean | undefined;
-            setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
-            hintProgressColor?: string | undefined;
-            canScrollPage?: boolean | undefined;
-            crossOutEnabled?: boolean | undefined;
-            editorChangeDelay?: number | undefined;
-            flags?: {
-                mafs?: false | ({
-                    none?: boolean | undefined;
-                    linear?: boolean | undefined;
-                    circle?: boolean | undefined;
-                    polygon?: boolean | undefined;
-                    point?: boolean | undefined;
-                    quadratic?: boolean | undefined;
-                    sinusoid?: boolean | undefined;
-                    angle?: boolean | undefined;
-                    "linear-system"?: boolean | undefined;
-                    ray?: boolean | undefined;
-                    segment?: boolean | undefined;
-                    "unlimited-polygon"?: boolean | undefined;
-                    "unlimited-point"?: boolean | undefined;
-                } & {
-                    "interactive-graph-locked-features-labels"?: boolean | undefined;
-                    "locked-figures-aria"?: boolean | undefined;
-                    "locked-point-labels"?: boolean | undefined;
-                    "locked-line-labels"?: boolean | undefined;
-                    "locked-vector-labels"?: boolean | undefined;
-                    "locked-ellipse-labels"?: boolean | undefined;
-                    "locked-polygon-labels"?: boolean | undefined;
-                    "locked-function-labels"?: boolean | undefined;
-                }) | undefined;
-            } | undefined;
-            onWidgetStartProps?: ((widgets: import("../../perseus-types").PerseusWidgetsMap) => void) | undefined;
-        }> & {
-            GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
-            baseElements: {
-                Link: React.ComponentType<any>;
-            };
-            canScrollPage: NonNullable<boolean | undefined>;
-            crossOutEnabled: NonNullable<boolean | undefined>;
-            editorChangeDelay: number;
-            groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
-            isArticle: NonNullable<boolean | undefined>;
-            isMobile: NonNullable<boolean | undefined>;
-            onFocusChange: (newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
-            readOnly: NonNullable<boolean | undefined>;
-            setDrawingAreaAvailable: (arg1: boolean) => unknown;
-            showAlignmentOptions: NonNullable<boolean | undefined>;
-        }>;
-        buttonSets: import("../../perseus-types").LegacyButtonSets;
-        functions: readonly string[];
-        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
-        onBlur: (blurPath: FocusPath) => void;
-        onFocus: (blurPath: FocusPath) => void;
-        times: boolean;
-        visibleLabel: string | undefined;
-        ariaLabel: string | undefined;
+    } & Partial<import("../..").PerseusDependenciesV2> & {
+        apiOptions: NonNullable<ExternalProps["apiOptions"]>;
+        buttonSets: NonNullable<ExternalProps["buttonSets"]>;
+        functions: NonNullable<ExternalProps["functions"]>;
+        linterContext: NonNullable<ExternalProps["linterContext"]>;
+        onBlur: NonNullable<ExternalProps["onBlur"]>;
+        onFocus: NonNullable<ExternalProps["onFocus"]>;
+        times: NonNullable<ExternalProps["times"]>;
+        visibleLabel: PerseusExpressionWidgetOptions["visibleLabel"];
+        ariaLabel: PerseusExpressionWidgetOptions["ariaLabel"];
         value: string;
-    }, "ariaLabel" | "static" | "onChange" | "keypadElement" | "containerSizeClass" | "widgetId" | "problemNum" | "questionCompleted" | "findWidgets" | "trackInteraction" | "reviewMode" | keyof import("../../types").PerseusDependenciesV2 | "alignment" | "reviewModeRubric" | "isLastUsedWidget" | "buttonsVisible" | "visibleLabel" | "keypadConfiguration"> & {
+    }, "ariaLabel" | "static" | "onChange" | "keypadElement" | "containerSizeClass" | "widgetId" | "problemNum" | "questionCompleted" | "findWidgets" | "trackInteraction" | "reviewMode" | keyof import("../..").PerseusDependenciesV2 | "alignment" | "reviewModeRubric" | "isLastUsedWidget" | "visibleLabel" | "buttonsVisible" | "keypadConfiguration"> & {
         value?: string | undefined;
         onFocus?: ((blurPath: FocusPath) => void) | undefined;
         onBlur?: ((blurPath: FocusPath) => void) | undefined;
         apiOptions?: Readonly<Readonly<{
-            isArticle?: boolean | undefined;
-            onFocusChange?: ((newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown) | undefined;
-            GroupMetadataEditor?: React.ComponentType<any> | undefined;
-            showAlignmentOptions?: boolean | undefined;
-            readOnly?: boolean | undefined;
-            answerableCallback?: ((arg1: boolean) => unknown) | undefined;
-            getAnotherHint?: (() => unknown) | undefined;
-            interactionCallback?: ((widgetData: {
+            isArticle?: boolean;
+            onFocusChange?: (newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
+            GroupMetadataEditor?: React.ComponentType<any>;
+            showAlignmentOptions?: boolean;
+            readOnly?: boolean;
+            answerableCallback?: (arg1: boolean) => unknown;
+            getAnotherHint?: () => unknown;
+            interactionCallback?: (widgetData: {
                 [widgetId: string]: any;
-            }) => void) | undefined;
-            groupAnnotator?: ((groupNumber: number, widgetId: string) => React.ReactNode) | undefined;
+            }) => void;
+            groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
             imagePlaceholder?: React.ReactNode;
             widgetPlaceholder?: React.ReactNode;
             baseElements?: {
                 Link: React.ComponentType<any>;
-            } | undefined;
-            imagePreloader?: ((dimensions: import("../../types").Dimensions) => React.ReactNode) | undefined;
-            trackInteraction?: ((args: {
+            };
+            imagePreloader?: (dimensions: import("../../types").Dimensions) => React.ReactNode;
+            trackInteraction?: (args: {
                 type: string;
                 id: string;
-                correct?: boolean | undefined;
+                correct?: boolean;
             } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
                 visible: number;
-            }>) => void) | undefined;
-            customKeypad?: boolean | undefined;
-            nativeKeypadProxy?: ((blur: () => void) => import("@khanacademy/math-input").KeypadAPI) | undefined;
-            isMobile?: boolean | undefined;
-            setDrawingAreaAvailable?: ((arg1: boolean) => unknown) | undefined;
-            hintProgressColor?: string | undefined;
-            canScrollPage?: boolean | undefined;
-            crossOutEnabled?: boolean | undefined;
-            editorChangeDelay?: number | undefined;
+            }>) => void;
+            customKeypad?: boolean;
+            nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
+            isMobile?: boolean;
+            setDrawingAreaAvailable?: (arg1: boolean) => unknown;
+            hintProgressColor?: string;
+            canScrollPage?: boolean;
+            crossOutEnabled?: boolean;
+            editorChangeDelay?: number;
             flags?: {
-                mafs?: false | ({
-                    none?: boolean | undefined;
-                    linear?: boolean | undefined;
-                    circle?: boolean | undefined;
-                    polygon?: boolean | undefined;
-                    point?: boolean | undefined;
-                    quadratic?: boolean | undefined;
-                    sinusoid?: boolean | undefined;
-                    angle?: boolean | undefined;
-                    "linear-system"?: boolean | undefined;
-                    ray?: boolean | undefined;
-                    segment?: boolean | undefined;
-                    "unlimited-polygon"?: boolean | undefined;
-                    "unlimited-point"?: boolean | undefined;
-                } & {
-                    "interactive-graph-locked-features-labels"?: boolean | undefined;
-                    "locked-figures-aria"?: boolean | undefined;
-                    "locked-point-labels"?: boolean | undefined;
-                    "locked-line-labels"?: boolean | undefined;
-                    "locked-vector-labels"?: boolean | undefined;
-                    "locked-ellipse-labels"?: boolean | undefined;
-                    "locked-polygon-labels"?: boolean | undefined;
-                    "locked-function-labels"?: boolean | undefined;
-                }) | undefined;
-            } | undefined;
-            onWidgetStartProps?: ((widgets: import("../../perseus-types").PerseusWidgetsMap) => void) | undefined;
-        }> & {
-            GroupMetadataEditor: NonNullable<React.ComponentType<any> | undefined>;
-            baseElements: {
-                Link: React.ComponentType<any>;
+                mafs?: false | ({ [Key in typeof import("../../types").MafsGraphTypeFlags[number]]?: boolean; } & { [Key in typeof import("../../types").InteractiveGraphLockedFeaturesFlags[number]]?: boolean; });
             };
-            canScrollPage: NonNullable<boolean | undefined>;
-            crossOutEnabled: NonNullable<boolean | undefined>;
-            editorChangeDelay: number;
-            groupAnnotator: (groupNumber: number, widgetId: string) => React.ReactNode;
-            isArticle: NonNullable<boolean | undefined>;
-            isMobile: NonNullable<boolean | undefined>;
-            onFocusChange: (newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadHeight?: number | undefined, focusedElement?: HTMLElement | undefined) => unknown;
-            readOnly: NonNullable<boolean | undefined>;
-            setDrawingAreaAvailable: (arg1: boolean) => unknown;
-            showAlignmentOptions: NonNullable<boolean | undefined>;
+            onWidgetStartProps?: (widgets: import("../..").PerseusWidgetsMap) => void;
+        }> & {
+            GroupMetadataEditor: NonNullable<import("../..").APIOptions["GroupMetadataEditor"]>;
+            baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
+            canScrollPage: NonNullable<import("../..").APIOptions["canScrollPage"]>;
+            crossOutEnabled: NonNullable<import("../..").APIOptions["crossOutEnabled"]>;
+            editorChangeDelay: NonNullable<import("../..").APIOptions["editorChangeDelay"]>;
+            groupAnnotator: NonNullable<import("../..").APIOptions["groupAnnotator"]>;
+            isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
+            isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
+            onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
+            readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
+            setDrawingAreaAvailable: NonNullable<import("../..").APIOptions["setDrawingAreaAvailable"]>;
+            showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
         }> | undefined;
         linterContext?: import("@khanacademy/perseus-linter").LinterContextProps | undefined;
-        buttonSets?: import("../../perseus-types").LegacyButtonSets | undefined;
+        buttonSets?: import("../..").LegacyButtonSets | undefined;
         functions?: readonly string[] | undefined;
         times?: boolean | undefined;
-    } & {}, keyof import("../../types").PerseusDependenciesV2> & React.RefAttributes<Expression>>;
+    } & {}, keyof import("../..").PerseusDependenciesV2> & React.RefAttributes<Expression>>;
     transform: (widgetOptions: PerseusExpressionWidgetOptions) => RenderProps;
     version: {
         major: number;

package/dist/widgets/image/image.d.ts

@@ -47,6 +47,6 @@ declare const _default: {
     displayName: string;
     widget: typeof ImageWidget;
     isLintable: true;
-    scorer: () => import("../../types").PerseusScore;
+    scorer: () => import("../..").PerseusScore;
 };
 export default _default;

package/dist/widgets/interaction/interaction.d.ts

@@ -33,6 +33,6 @@ declare const _default: {
     widget: typeof Interaction;
     transform: <T>(value: T) => T;
     hidden: true;
-    scorer: () => import("../../types").PerseusScore;
+    scorer: () => import("../..").PerseusScore;
 };
 export default _default;

package/dist/widgets/interactive-graphs/graphs/components/movable-point.d.ts

@@ -1,9 +1,16 @@
 import * as React from "react";
 import type { CSSCursor } from "./css-cursor";
+import type { AriaLive } from "../../types";
 import type { KeyboardMovementConstraint } from "../use-draggable";
 import type { vec } from "mafs";
 type Props = {
     point: vec.Vector2;
+    ariaDescribedBy?: string;
+    ariaLabel?: string;
+    ariaLive?: AriaLive;
+    color?: string;
+    constrain?: KeyboardMovementConstraint;
+    cursor?: CSSCursor | undefined;
     /**
      * Represents where this point stands in the overall point sequence.
      * This is used to provide screen readers with context about the point.
@@ -12,14 +19,11 @@ type Props = {
      * Note: This number is 1-indexed, and should restart from 1 for each
      * interactive figure on the graph.
      */
-    sequenceNumber: number;
-    onMove?: (newPoint: vec.Vector2) => unknown;
+    sequenceNumber?: number;
+    onBlur?: (event: React.FocusEvent) => unknown;
     onClick?: () => unknown;
-    color?: string;
-    cursor?: CSSCursor | undefined;
-    constrain?: KeyboardMovementConstraint;
-    onFocus?: ((event: React.FocusEvent) => unknown) | undefined;
-    onBlur?: ((event: React.FocusEvent) => unknown) | undefined;
+    onFocus?: (event: React.FocusEvent) => unknown;
+    onMove?: (newPoint: vec.Vector2) => unknown;
 };
 export declare const MovablePoint: React.ForwardRefExoticComponent<Props & React.RefAttributes<SVGGElement | null>>;
 export {};