@khanacademy/perseus 84.0.1 → 84.1.0

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

@@ -1,68 +1,8 @@
 import * as React from "react";
-import type { Widget, WidgetProps, FocusPath } from "../../types";
+import type { Widget, WidgetProps } from "../../types";
 import type { PerseusExpressionRubric, PerseusExpressionUserInput, PerseusExpressionWidgetOptions } from "@khanacademy/perseus-core";
-type ExternalProps = WidgetProps<PerseusExpressionWidgetOptions, PerseusExpressionUserInput>;
-export declare const Expression: React.ForwardRefExoticComponent<PerseusExpressionWidgetOptions & {
-    trackInteraction: (extraData?: Empty | undefined) => void;
-    widgetId: string;
-    widgetIndex: number;
-    alignment: string | null | undefined;
-    static: boolean | null | undefined;
-    graded?: boolean | null;
-    problemNum: number | null | undefined;
-    apiOptions: Readonly<Readonly<{
-        isArticle?: boolean;
-        onFocusChange?: (newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
-        showAlignmentOptions?: boolean;
-        readOnly?: boolean;
-        editingDisabled?: boolean;
-        answerableCallback?: (arg1: boolean) => unknown;
-        getAnotherHint?: () => unknown;
-        interactionCallback?: (widgetData: {
-            [widgetId: string]: any;
-        }) => void;
-        imagePlaceholder?: React.ReactNode;
-        widgetPlaceholder?: React.ReactNode;
-        baseElements?: {
-            Link: React.ComponentType<any>;
-        };
-        trackInteraction?: (args: {
-            type: string;
-            id: string;
-            correct?: boolean;
-        } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
-            visible: number;
-        }>) => void;
-        customKeypad?: boolean;
-        isMobile?: boolean;
-        isMobileApp?: boolean;
-        hintProgressColor?: string;
-        flags?: Record<"perseus-renderer-upgrade" | "desmos-calculator", boolean>;
-    }> & {
-        baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
-        isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
-        isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
-        isMobileApp: NonNullable<import("../..").APIOptions["isMobileApp"]>;
-        editingDisabled: NonNullable<import("../..").APIOptions["editingDisabled"]>;
-        onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
-        readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
-        showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
-    }>;
-    keypadElement?: any;
-    onFocus: (blurPath: FocusPath) => void;
-    onBlur: (blurPath: FocusPath) => void;
-    findWidgets: import("../../types").FindWidgetsFunction;
-    reviewMode: boolean;
-    showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
-    handleUserInput: (newUserInput: string, cb?: () => void, silent?: boolean) => void;
-    userInput: string;
-    linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
-    containerSizeClass: import("../../util/sizing-utils").SizeClass;
-} & {
-    buttonSets: NonNullable<ExternalProps["buttonSets"]>;
-    functions: NonNullable<ExternalProps["functions"]>;
-    times: NonNullable<ExternalProps["times"]>;
-} & React.RefAttributes<Widget>>;
+type Props = WidgetProps<PerseusExpressionWidgetOptions, PerseusExpressionUserInput>;
+export declare const Expression: React.ForwardRefExoticComponent<Props & React.RefAttributes<Widget>>;
 /**
  * @deprecated and likely a very broken API
  * [LEMS-3185] do not trust serializedState
@@ -74,67 +14,7 @@ declare function getCorrectUserInput(options: PerseusExpressionWidgetOptions): P
 declare const _default: {
     name: string;
     displayName: string;
-    widget: React.ForwardRefExoticComponent<PerseusExpressionWidgetOptions & {
-        trackInteraction: (extraData?: Empty | undefined) => void;
-        widgetId: string;
-        widgetIndex: number;
-        alignment: string | null | undefined;
-        static: boolean | null | undefined;
-        graded?: boolean | null;
-        problemNum: number | null | undefined;
-        apiOptions: Readonly<Readonly<{
-            isArticle?: boolean;
-            onFocusChange?: (newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
-            showAlignmentOptions?: boolean;
-            readOnly?: boolean;
-            editingDisabled?: boolean;
-            answerableCallback?: (arg1: boolean) => unknown;
-            getAnotherHint?: () => unknown;
-            interactionCallback?: (widgetData: {
-                [widgetId: string]: any;
-            }) => void;
-            imagePlaceholder?: React.ReactNode;
-            widgetPlaceholder?: React.ReactNode;
-            baseElements?: {
-                Link: React.ComponentType<any>;
-            };
-            trackInteraction?: (args: {
-                type: string;
-                id: string;
-                correct?: boolean;
-            } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
-                visible: number;
-            }>) => void;
-            customKeypad?: boolean;
-            isMobile?: boolean;
-            isMobileApp?: boolean;
-            hintProgressColor?: string;
-            flags?: Record<"perseus-renderer-upgrade" | "desmos-calculator", boolean>;
-        }> & {
-            baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
-            isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
-            isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
-            isMobileApp: NonNullable<import("../..").APIOptions["isMobileApp"]>;
-            editingDisabled: NonNullable<import("../..").APIOptions["editingDisabled"]>;
-            onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
-            readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
-            showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
-        }>;
-        keypadElement?: any;
-        onFocus: (blurPath: FocusPath) => void;
-        onBlur: (blurPath: FocusPath) => void;
-        findWidgets: import("../../types").FindWidgetsFunction;
-        reviewMode: boolean;
-        showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
-        handleUserInput: (newUserInput: string, cb?: () => void, silent?: boolean) => void;
-        userInput: string;
-        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
-        containerSizeClass: import("../../util/sizing-utils").SizeClass;
-    } & {
-        buttonSets: NonNullable<ExternalProps["buttonSets"]>;
-        functions: NonNullable<ExternalProps["functions"]>;
-        times: NonNullable<ExternalProps["times"]>;
-    } & React.RefAttributes<Widget>>;
+    widget: React.ForwardRefExoticComponent<Props & React.RefAttributes<Widget>>;
     isLintable: true;
     getOneCorrectAnswerFromRubric: typeof getOneCorrectAnswerFromRubric;
     getStartUserInput: typeof getStartUserInput;

package/dist/widgets/iframe/iframe.d.ts

@@ -13,8 +13,6 @@ import type { UnsupportedWidgetPromptJSON } from "../../widget-ai-utils/unsuppor
 import type { PerseusIFrameUserInput, PerseusIFrameWidgetOptions } from "@khanacademy/perseus-core";
 type Props = WidgetProps<PerseusIFrameWidgetOptions, PerseusIFrameUserInput>;
 type DefaultProps = {
-    allowFullScreen: Props["allowFullScreen"];
-    allowTopNavigation: Props["allowTopNavigation"];
     userInput: Props["userInput"];
 };
 declare class Iframe extends React.Component<Props> implements Widget {

package/dist/widgets/image/components/common-image-props.d.ts

@@ -0,0 +1,11 @@
+import type { APIOptions } from "../../../types";
+import type { PerseusImageWidgetOptions } from "@khanacademy/perseus-core";
+import type { LinterContextProps } from "@khanacademy/perseus-linter";
+export interface CommonImageProps {
+    options: PerseusImageWidgetOptions;
+    linterContext: LinterContextProps;
+    apiOptions: APIOptions;
+    widgetId: string;
+    isGifPlaying: boolean;
+    setIsGifPlaying: (isPlaying: boolean) => void;
+}

package/dist/widgets/image/components/explore-image-modal-content.d.ts

@@ -1,8 +1,8 @@
 import * as React from "react";
-import type { CommonImageProps, GifProps } from "./image-info-area";
-type Props = CommonImageProps & GifProps & {
+import type { CommonImageProps } from "./common-image-props";
+interface Props extends CommonImageProps {
     captionId: string;
     longDescId: string;
-};
-export default function ExploreImageModalContent({ backgroundImage, scale: contentScale, caption, alt, longDescription, linterContext, apiOptions, box, labels, range, captionId, longDescId, }: Props): React.JSX.Element | null;
+}
+export default function ExploreImageModalContent({ options, linterContext, apiOptions, captionId, longDescId, }: Props): React.JSX.Element | null;
 export {};

package/dist/widgets/image/components/explore-image-modal.d.ts

@@ -1,5 +1,3 @@
 import React from "react";
-import type { CommonImageProps, GifProps } from "./image-info-area";
-type Props = CommonImageProps & GifProps;
-export declare const ExploreImageModal: (props: Props) => React.JSX.Element;
-export {};
+import type { CommonImageProps } from "./common-image-props";
+export declare const ExploreImageModal: (props: CommonImageProps) => React.JSX.Element;

package/dist/widgets/image/components/image-info-area.d.ts

@@ -1,28 +1,8 @@
-import { type Interval, type PerseusImageBackground, type PerseusImageLabel, type Size } from "@khanacademy/perseus-core";
 import * as React from "react";
-import type { APIOptions } from "../../../types";
-import type { LinterContextProps } from "@khanacademy/perseus-linter";
-export interface GifProps {
-    isGifPlaying: boolean;
-    setIsGifPlaying: (isPaused: boolean) => void;
-}
-export interface CommonImageProps {
-    backgroundImage: PerseusImageBackground;
-    scale: number;
-    title: string;
-    caption: string;
-    alt: string;
-    longDescription: string;
-    box: Size;
-    labels: Array<PerseusImageLabel>;
-    range: [Interval, Interval];
-    linterContext: LinterContextProps;
-    apiOptions: APIOptions;
-    widgetId: string;
-}
-type Props = GifProps & CommonImageProps & {
+import type { CommonImageProps } from "./common-image-props";
+interface Props extends CommonImageProps {
     isAnimatedGif: boolean;
-};
+}
 /**
  * The ImageInfoArea component includes the GIF controls, description modal
  * launcher, and caption for the image. This is displayed underneath the image

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

@@ -1,66 +1,11 @@
 import React from "react";
-import type { Widget } from "../../types";
+import type { Widget, WidgetProps } from "../../types";
 import type { PerseusImageWidgetOptions } from "@khanacademy/perseus-core";
+type ImageWidgetProps = WidgetProps<PerseusImageWidgetOptions>;
 declare const _default: {
     name: string;
     displayName: string;
-    widget: React.ForwardRefExoticComponent<PerseusImageWidgetOptions & {
-        trackInteraction: (extraData?: Empty | undefined) => void;
-        widgetId: string;
-        widgetIndex: number;
-        alignment: string | null | undefined;
-        static: boolean | null | undefined;
-        graded?: boolean | null;
-        problemNum: number | null | undefined;
-        apiOptions: Readonly<Readonly<{
-            isArticle?: boolean;
-            onFocusChange?: (newFocusPath: import("../..").FocusPath, oldFocusPath: import("../..").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
-            showAlignmentOptions?: boolean;
-            readOnly?: boolean;
-            editingDisabled?: boolean;
-            answerableCallback?: (arg1: boolean) => unknown;
-            getAnotherHint?: () => unknown;
-            interactionCallback?: (widgetData: {
-                [widgetId: string]: any;
-            }) => void;
-            imagePlaceholder?: React.ReactNode;
-            widgetPlaceholder?: React.ReactNode;
-            baseElements?: {
-                Link: React.ComponentType<any>;
-            };
-            trackInteraction?: (args: {
-                type: string;
-                id: string;
-                correct?: boolean;
-            } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
-                visible: number;
-            }>) => void;
-            customKeypad?: boolean;
-            isMobile?: boolean;
-            isMobileApp?: boolean;
-            hintProgressColor?: string;
-            flags?: Record<"perseus-renderer-upgrade" | "desmos-calculator", boolean>;
-        }> & {
-            baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
-            isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
-            isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
-            isMobileApp: NonNullable<import("../..").APIOptions["isMobileApp"]>;
-            editingDisabled: NonNullable<import("../..").APIOptions["editingDisabled"]>;
-            onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
-            readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
-            showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
-        }>;
-        keypadElement?: any;
-        onFocus: (blurPath: import("../..").FocusPath) => void;
-        onBlur: (blurPath: import("../..").FocusPath) => void;
-        findWidgets: import("../../types").FindWidgetsFunction;
-        reviewMode: boolean;
-        showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
-        handleUserInput: (newUserInput: Empty, cb?: () => void, silent?: boolean) => void;
-        userInput: Empty;
-        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
-        containerSizeClass: import("../../util/sizing-utils").SizeClass;
-    } & React.RefAttributes<Widget>>;
+    widget: React.ForwardRefExoticComponent<ImageWidgetProps & React.RefAttributes<Widget>>;
     isLintable: true;
 };
 export default _default;

package/dist/widgets/input-number/input-number.d.ts

@@ -8,11 +8,12 @@ declare const _default: {
     name: string;
     displayName: string;
     hidden: true;
-    widget: import("react").ForwardRefExoticComponent<import("@khanacademy/perseus-core").PerseusNumericInputWidgetOptions & {
+    widget: import("react").ForwardRefExoticComponent<{
+        options: import("@khanacademy/perseus-core").PerseusNumericInputWidgetOptions;
         trackInteraction: (extraData?: Empty | undefined) => void;
         widgetId: string;
         widgetIndex: number;
-        alignment: string | null | undefined;
+        alignment: import("@khanacademy/perseus-core").Alignment | null | undefined;
         static: boolean | null | undefined;
         graded?: boolean | null;
         problemNum: number | null | undefined;

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

@@ -4,16 +4,11 @@ import type { Widget, WidgetProps } from "../../types";
 import type { UnsupportedWidgetPromptJSON } from "../../widget-ai-utils/unsupported-widget";
 import type { PerseusInteractionWidgetOptions } from "@khanacademy/perseus-core";
 type Props = WidgetProps<PerseusInteractionWidgetOptions>;
-type DefaultProps = {
-    graph: Props["graph"];
-    elements: Props["elements"];
-};
 type State = {
     variables: any;
     functions: any;
 };
 declare class Interaction extends React.Component<Props, State> implements Widget {
-    static defaultProps: DefaultProps;
     isWidget: true;
     state: State;
     UNSAFE_componentWillReceiveProps(nextProps: Props): void;

package/dist/widgets/interactive-graphs/graphs/polygon.d.ts

@@ -1,9 +1,10 @@
 import { vec } from "mafs";
 import { type I18nContextType } from "../../../components/i18n-context";
 import type { Coord } from "../../../interactive2/types";
-import type { Dispatch, InteractiveGraphElementSuite, InteractiveGraphProps, PolygonGraphState } from "../types";
+import type { Dispatch, InteractiveGraphElementSuite, PolygonGraphState } from "../types";
+import type { PerseusInteractiveGraphWidgetOptions } from "@khanacademy/perseus-core";
 import type { Interval } from "mafs";
-export declare function renderPolygonGraph(state: PolygonGraphState, dispatch: Dispatch, i18n: I18nContextType, markings: InteractiveGraphProps["markings"]): InteractiveGraphElementSuite;
+export declare function renderPolygonGraph(state: PolygonGraphState, dispatch: Dispatch, i18n: I18nContextType, markings: PerseusInteractiveGraphWidgetOptions["markings"]): InteractiveGraphElementSuite;
 export declare const hasFocusVisible: (element: Element | null | undefined) => boolean;
 export declare function getSideSnapConstraint(points: ReadonlyArray<Coord>, index: number, range: [Interval, Interval]): {
     up: vec.Vector2;

package/dist/widgets/interactive-graphs/graphs/strings/polygon.d.ts

@@ -1,6 +1,7 @@
 import type { I18nContextType } from "../../../../components/i18n-context";
-import type { InteractiveGraphProps, PolygonGraphState } from "../../types";
+import type { PolygonGraphState } from "../../types";
 import type { PerseusStrings } from "@khanacademy/perseus/strings";
+import type { PerseusInteractiveGraphWidgetOptions } from "@khanacademy/perseus-core";
 export declare function srPolygonLabel(coords: ReadonlyArray<readonly [number, number]>, pointLabels: ReadonlyArray<string> | undefined, strings: PerseusStrings, locale: string): string;
 type PolygonGraphDescriptionStrings = {
     srPolygonGraph: string;
@@ -9,5 +10,5 @@ type PolygonGraphDescriptionStrings = {
     srPolygonElementsNum: string;
     srPolygonInteractiveElements: string | null;
 };
-export declare function describePolygonGraph(state: PolygonGraphState, i18n: I18nContextType, markings: InteractiveGraphProps["markings"]): PolygonGraphDescriptionStrings;
+export declare function describePolygonGraph(state: PolygonGraphState, i18n: I18nContextType, markings: PerseusInteractiveGraphWidgetOptions["markings"]): PolygonGraphDescriptionStrings;
 export {};

package/dist/widgets/interactive-graphs/interactive-graph.d.ts

@@ -19,29 +19,10 @@ declare class InteractiveGraph extends React.Component<Props> {
      */
     getSerializedState(): {
         graph: PerseusGraphType;
-        step: [number, number];
-        gridStep?: [x: number, y: number];
-        snapStep?: [x: number, y: number];
-        backgroundImage: import("@khanacademy/perseus-core").PerseusImageBackground;
-        markings: import("@khanacademy/perseus-core").MarkingsType;
-        labels: string[];
-        labelLocation: import("@khanacademy/perseus-core").AxisLabelLocation;
-        showAxisArrows: import("@khanacademy/perseus-core").ShowAxisArrows;
-        showAxisTicks: import("@khanacademy/perseus-core").ShowAxisTicks;
-        showProtractor: boolean;
-        showRuler?: boolean;
-        showTooltips: boolean;
-        rulerLabel?: string;
-        rulerTicks?: number;
-        range: import("@khanacademy/perseus-core").GraphRange;
-        correct: PerseusGraphType;
-        lockedFigures: import("@khanacademy/perseus-core").LockedFigure[];
-        fullGraphAriaLabel?: string;
-        fullGraphAriaDescription?: string;
         trackInteraction: (extraData?: Empty | undefined) => void;
         widgetId: string;
         widgetIndex: number;
-        alignment: string | null | undefined;
+        alignment: import("@khanacademy/perseus-core").Alignment | null | undefined;
         static: boolean | null | undefined;
         graded?: boolean | null;
         problemNum: number | null | undefined;
@@ -92,6 +73,25 @@ declare class InteractiveGraph extends React.Component<Props> {
         handleUserInput: (newUserInput: PerseusGraphType, cb?: () => void, silent?: boolean) => void;
         linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
         containerSizeClass: import("../../util/sizing-utils").SizeClass;
+        step: [number, number];
+        gridStep?: [x: number, y: number];
+        snapStep?: [x: number, y: number];
+        backgroundImage: import("@khanacademy/perseus-core").PerseusImageBackground;
+        markings: import("@khanacademy/perseus-core").MarkingsType;
+        labels: string[];
+        labelLocation: import("@khanacademy/perseus-core").AxisLabelLocation;
+        showAxisArrows: import("@khanacademy/perseus-core").ShowAxisArrows;
+        showAxisTicks: import("@khanacademy/perseus-core").ShowAxisTicks;
+        showProtractor: boolean;
+        showRuler?: boolean;
+        showTooltips: boolean;
+        rulerLabel?: string;
+        rulerTicks?: number;
+        range: import("@khanacademy/perseus-core").GraphRange;
+        correct: PerseusGraphType;
+        lockedFigures: import("@khanacademy/perseus-core").LockedFigure[];
+        fullGraphAriaLabel?: string;
+        fullGraphAriaDescription?: string;
     };
     render(): React.JSX.Element;
 }

package/dist/widgets/interactive-graphs/mafs-graph.d.ts

@@ -1,24 +1,25 @@
 import * as React from "react";
 import type { InteractiveGraphAction } from "./reducer/interactive-graph-action";
 import type { InteractiveGraphState, InteractiveGraphProps } from "./types";
+import type { PerseusInteractiveGraphWidgetOptions } from "@khanacademy/perseus-core";
 import "mafs/core.css";
 import "./mafs-styles.css";
 export type MafsGraphProps = {
     box: [number, number];
-    backgroundImage?: InteractiveGraphProps["backgroundImage"];
-    lockedFigures: InteractiveGraphProps["lockedFigures"];
-    step: InteractiveGraphProps["step"];
+    backgroundImage?: PerseusInteractiveGraphWidgetOptions["backgroundImage"];
+    lockedFigures: PerseusInteractiveGraphWidgetOptions["lockedFigures"];
+    step: PerseusInteractiveGraphWidgetOptions["step"];
     gridStep: [x: number, y: number];
     containerSizeClass: InteractiveGraphProps["containerSizeClass"];
-    markings: InteractiveGraphProps["markings"];
-    showTooltips: Required<InteractiveGraphProps["showTooltips"]>;
+    markings: PerseusInteractiveGraphWidgetOptions["markings"];
+    showTooltips: Required<PerseusInteractiveGraphWidgetOptions["showTooltips"]>;
     showProtractor: boolean;
     labels: ReadonlyArray<string>;
-    labelLocation?: InteractiveGraphProps["labelLocation"];
-    showAxisArrows: InteractiveGraphProps["showAxisArrows"];
-    showAxisTicks: InteractiveGraphProps["showAxisTicks"];
-    fullGraphAriaLabel?: InteractiveGraphProps["fullGraphAriaLabel"];
-    fullGraphAriaDescription?: InteractiveGraphProps["fullGraphAriaDescription"];
+    labelLocation?: PerseusInteractiveGraphWidgetOptions["labelLocation"];
+    showAxisArrows: PerseusInteractiveGraphWidgetOptions["showAxisArrows"];
+    showAxisTicks: PerseusInteractiveGraphWidgetOptions["showAxisTicks"];
+    fullGraphAriaLabel?: PerseusInteractiveGraphWidgetOptions["fullGraphAriaLabel"];
+    fullGraphAriaDescription?: PerseusInteractiveGraphWidgetOptions["fullGraphAriaDescription"];
     state: InteractiveGraphState;
     dispatch: React.Dispatch<InteractiveGraphAction>;
     readOnly: boolean;

package/dist/widgets/interactive-graphs/stateful-mafs-graph.d.ts

@@ -1,32 +1,32 @@
 import * as React from "react";
 import type { InteractiveGraphProps } from "./types";
-import type { PerseusGraphType, PerseusInteractiveGraphUserInput } from "@khanacademy/perseus-core";
+import type { PerseusGraphType, PerseusInteractiveGraphUserInput, PerseusInteractiveGraphWidgetOptions } from "@khanacademy/perseus-core";
 export type StatefulMafsGraphProps = {
     box: [number, number];
-    backgroundImage?: InteractiveGraphProps["backgroundImage"];
+    backgroundImage?: PerseusInteractiveGraphWidgetOptions["backgroundImage"];
     graph: PerseusGraphType;
     /**
      * The correct answer for this widget.
      */
     correct?: PerseusGraphType;
-    lockedFigures: InteractiveGraphProps["lockedFigures"];
-    range: InteractiveGraphProps["range"];
+    lockedFigures: PerseusInteractiveGraphWidgetOptions["lockedFigures"];
+    range: PerseusInteractiveGraphWidgetOptions["range"];
     snapStep: [x: number, y: number];
-    step: InteractiveGraphProps["step"];
+    step: PerseusInteractiveGraphWidgetOptions["step"];
     gridStep: [x: number, y: number];
     containerSizeClass: InteractiveGraphProps["containerSizeClass"];
-    markings: InteractiveGraphProps["markings"];
+    markings: PerseusInteractiveGraphWidgetOptions["markings"];
     onChange: (userInput: PerseusGraphType) => void;
-    showTooltips: Required<InteractiveGraphProps["showTooltips"]>;
+    showTooltips: Required<PerseusInteractiveGraphWidgetOptions["showTooltips"]>;
     showProtractor: boolean;
     labels: ReadonlyArray<string>;
-    labelLocation?: InteractiveGraphProps["labelLocation"];
-    fullGraphAriaLabel?: InteractiveGraphProps["fullGraphAriaLabel"];
-    fullGraphAriaDescription?: InteractiveGraphProps["fullGraphAriaDescription"];
+    labelLocation?: PerseusInteractiveGraphWidgetOptions["labelLocation"];
+    fullGraphAriaLabel?: PerseusInteractiveGraphWidgetOptions["fullGraphAriaLabel"];
+    fullGraphAriaDescription?: PerseusInteractiveGraphWidgetOptions["fullGraphAriaDescription"];
     readOnly: boolean;
     static: InteractiveGraphProps["static"];
-    showAxisArrows: InteractiveGraphProps["showAxisArrows"];
-    showAxisTicks: InteractiveGraphProps["showAxisTicks"];
+    showAxisArrows: PerseusInteractiveGraphWidgetOptions["showAxisArrows"];
+    showAxisTicks: PerseusInteractiveGraphWidgetOptions["showAxisTicks"];
     widgetId: string;
     graded?: boolean | null;
     ungradedDescriptionId?: string;

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

@@ -36,10 +36,10 @@ export type OptionalAnswersMarkerType = Omit<InteractiveMarkerType, "answers"> &
 };
 type Options = Omit<PerseusLabelImageWidgetOptions, "markers"> & {
     markers: ReadonlyArray<OptionalAnswersMarkerType>;
+    preferredPopoverDirection?: PreferredPopoverDirection;
 };
 type Props = WidgetProps<Options, PerseusLabelImageUserInput> & {
     analytics: DependencyProps["analytics"];
-    preferredPopoverDirection?: PreferredPopoverDirection;
 };
 type LabelImageState = {
     activeMarkerIndex: number;
@@ -109,67 +109,8 @@ declare function getCorrectUserInput(options: PerseusLabelImageWidgetOptions): P
 declare const _default: {
     name: string;
     displayName: string;
-    widget: React.ForwardRefExoticComponent<Omit<Omit<PerseusLabelImageWidgetOptions, "markers"> & {
-        markers: ReadonlyArray<OptionalAnswersMarkerType>;
-    } & {
-        trackInteraction: (extraData?: Empty | undefined) => void;
-        widgetId: string;
-        widgetIndex: number;
-        alignment: string | null | undefined;
-        static: boolean | null | undefined;
-        graded?: boolean | null;
-        problemNum: number | null | undefined;
-        apiOptions: Readonly<Readonly<{
-            isArticle?: boolean;
-            onFocusChange?: (newFocusPath: import("../..").FocusPath, oldFocusPath: import("../..").FocusPath, keypadHeight?: number, focusedElement?: HTMLElement) => unknown;
-            showAlignmentOptions?: boolean;
-            readOnly?: boolean;
-            editingDisabled?: boolean;
-            answerableCallback?: (arg1: boolean) => unknown;
-            getAnotherHint?: () => unknown;
-            interactionCallback?: (widgetData: {
-                [widgetId: string]: any;
-            }) => void;
-            imagePlaceholder?: React.ReactNode;
-            widgetPlaceholder?: React.ReactNode;
-            baseElements?: {
-                Link: React.ComponentType<any>;
-            };
-            trackInteraction?: (args: {
-                type: string;
-                id: string;
-                correct?: boolean;
-            } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
-                visible: number;
-            }>) => void;
-            customKeypad?: boolean;
-            isMobile?: boolean;
-            isMobileApp?: boolean;
-            hintProgressColor?: string;
-            flags?: Record<"perseus-renderer-upgrade" | "desmos-calculator", boolean>;
-        }> & {
-            baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
-            isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
-            isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
-            isMobileApp: NonNullable<import("../..").APIOptions["isMobileApp"]>;
-            editingDisabled: NonNullable<import("../..").APIOptions["editingDisabled"]>;
-            onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
-            readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
-            showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
-        }>;
-        keypadElement?: any;
-        onFocus: (blurPath: import("../..").FocusPath) => void;
-        onBlur: (blurPath: import("../..").FocusPath) => void;
-        findWidgets: import("../../types").FindWidgetsFunction;
-        reviewMode: boolean;
-        showSolutions?: ShowSolutions;
-        handleUserInput: (newUserInput: PerseusLabelImageUserInput, cb?: () => void, silent?: boolean) => void;
-        userInput: PerseusLabelImageUserInput;
-        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
-        containerSizeClass: import("../../util/sizing-utils").SizeClass;
-    } & {
+    widget: React.ForwardRefExoticComponent<Omit<WidgetProps<Options, PerseusLabelImageUserInput> & {
         analytics: DependencyProps["analytics"];
-        preferredPopoverDirection?: PreferredPopoverDirection;
     }, keyof import("../..").PerseusDependenciesV2> & React.RefAttributes<LabelImage>>;
     isLintable: true;
     getStartUserInput: typeof getStartUserInput;