@khanacademy/perseus 65.3.6 → 65.4.0

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

@@ -14,7 +14,7 @@ type RenderProps = {
     ariaLabel: PerseusExpressionWidgetOptions["ariaLabel"];
     keypadConfiguration: KeypadConfiguration;
 };
-type ExternalProps = WidgetProps<RenderProps>;
+type ExternalProps = WidgetProps<RenderProps, PerseusExpressionUserInput>;
 type Props = ExternalProps & Partial<React.ContextType<typeof DependenciesContext>> & {
     apiOptions: NonNullable<ExternalProps["apiOptions"]>;
     buttonSets: NonNullable<ExternalProps["buttonSets"]>;
@@ -25,7 +25,6 @@ type Props = ExternalProps & Partial<React.ContextType<typeof DependenciesContex
     times: NonNullable<ExternalProps["times"]>;
     visibleLabel: PerseusExpressionWidgetOptions["visibleLabel"];
     ariaLabel: PerseusExpressionWidgetOptions["ariaLabel"];
-    value: string;
 };
 type ExpressionState = {
     invalid: boolean;
@@ -40,14 +39,13 @@ type DefaultProps = {
     onBlur: Props["onBlur"];
     onFocus: Props["onFocus"];
     times: Props["times"];
-    value: Props["value"];
+    userInput: Props["userInput"];
 };
 export declare class Expression extends React.Component<Props, ExpressionState> implements Widget {
     static contextType: React.Context<import("../../components/i18n-context").I18nContextType>;
     context: React.ContextType<typeof PerseusI18nContext>;
     _textareaId: string;
     _isMounted: boolean;
-    static getUserInputFromProps(props: Props): PerseusExpressionUserInput;
     static defaultProps: DefaultProps;
     displayName: string;
     state: ExpressionState;
@@ -55,11 +53,14 @@ export declare class Expression extends React.Component<Props, ExpressionState>
     componentDidUpdate: (prevProps: Props) => void;
     componentWillUnmount: () => void;
     _handleMouseDown: () => void;
+    /**
+     * TODO: remove this when everything is pulling from Renderer state
+     * @deprecated get user input from Renderer state
+     */
     getUserInput(): PerseusExpressionUserInput;
     getPromptJSON(): ExpressionPromptJSON;
-    change: (...args: any) => any | undefined;
     parse: (value: string, props: Props) => any;
-    changeAndTrack: (e: any, cb: () => void) => void;
+    changeAndTrack: (userInput: string, cb: () => void) => void;
     _handleFocus: () => void;
     _handleBlur: () => void;
     focus: () => boolean;
@@ -67,13 +68,108 @@ export declare class Expression extends React.Component<Props, ExpressionState>
     blurInputPath(inputPath: InputPath): void;
     insert(keyPressed: KeypadKey): void;
     getInputPaths: () => ReadonlyArray<ReadonlyArray<any>>;
-    setInputValue(path: FocusPath, newValue: string, cb?: () => void): void;
+    /**
+     * TODO: remove this when everything is pulling from Renderer state
+     * @deprecated set user input in a parent component
+     */
+    setInputValue(path: FocusPath, newValue: string, cb?: any): void;
+    /**
+     * @deprecated and likely very broken API
+     * [LEMS-3185] do not trust serializedState/restoreSerializedState
+     */
+    getSerializedState(): {
+        value: string;
+        buttonSets: PerseusExpressionWidgetOptions["buttonSets"];
+        buttonsVisible?: PerseusExpressionWidgetOptions["buttonsVisible"];
+        functions: PerseusExpressionWidgetOptions["functions"];
+        times: PerseusExpressionWidgetOptions["times"];
+        visibleLabel: PerseusExpressionWidgetOptions["visibleLabel"];
+        ariaLabel: PerseusExpressionWidgetOptions["ariaLabel"];
+        keypadConfiguration: KeypadConfiguration;
+        reviewModeRubric?: Empty | null | undefined;
+        trackInteraction: (extraData?: Empty | undefined) => void;
+        widgetId: string;
+        alignment: string | null | undefined;
+        static: boolean | null | undefined;
+        problemNum: number | null | undefined;
+        apiOptions: Readonly<Readonly<{
+            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;
+            groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            };
+            imagePreloader?: (dimensions: import("../../types").Dimensions) => React.ReactNode;
+            trackInteraction?: (args: {
+                type: string;
+                id: string;
+                correct?: boolean;
+            } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
+                visible: number;
+            }>) => void;
+            customKeypad?: boolean;
+            nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
+            isMobile?: boolean;
+            isMobileApp?: boolean;
+            setDrawingAreaAvailable?: (arg1: boolean) => unknown;
+            hintProgressColor?: string;
+            canScrollPage?: boolean;
+            editorChangeDelay?: number;
+            flags?: Record<"new-radio-widget", boolean>;
+            onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
+        }> & {
+            baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
+            canScrollPage: NonNullable<import("../..").APIOptions["canScrollPage"]>;
+            editorChangeDelay: NonNullable<import("../..").APIOptions["editorChangeDelay"]>;
+            groupAnnotator: NonNullable<import("../..").APIOptions["groupAnnotator"]>;
+            isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
+            isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
+            isMobileApp: NonNullable<import("../..").APIOptions["isMobileApp"]>;
+            onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
+            readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
+            setDrawingAreaAvailable: NonNullable<import("../..").APIOptions["setDrawingAreaAvailable"]>;
+            showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
+        }>;
+        keypadElement?: any;
+        questionCompleted?: boolean;
+        onFocus: (blurPath: FocusPath) => void;
+        onBlur: (blurPath: FocusPath) => void;
+        findWidgets: (criterion: import("../../types").FilterCriterion) => ReadonlyArray<Widget>;
+        reviewMode: boolean;
+        showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
+        onChange: import("../..").ChangeHandler;
+        handleUserInput: (newUserInput: string, cb?: () => void, silent?: boolean) => void;
+        isLastUsedWidget: boolean;
+        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
+        containerSizeClass: import("../../util/sizing-utils").SizeClass;
+        analytics?: {
+            onAnalyticsEvent: import("@khanacademy/perseus-core").AnalyticsEventHandlerFn;
+        } | undefined;
+        useVideo?: ((id: string, kind: import("../..").VideoKind) => import("@khanacademy/wonder-blocks-data").Result<{
+            video: import("../..").VideoData | null | undefined;
+        }>) | undefined;
+    };
     render(): React.JSX.Element;
 }
+/**
+ * @deprecated and likely a very broken API
+ * [LEMS-3185] do not trust serializedState/restoreSerializedState
+ */
+declare function getUserInputFromSerializedState(serializedState: any): PerseusExpressionUserInput;
 declare const _default: {
     name: string;
     displayName: string;
-    widget: React.ForwardRefExoticComponent<Omit<Pick<RenderProps & import("../../types").UniversalWidgetProps<Empty, Empty> & Partial<import("../..").PerseusDependenciesV2> & {
+    widget: React.ForwardRefExoticComponent<Omit<Pick<RenderProps & import("../../types").UniversalWidgetProps<Empty, string, Empty> & Partial<import("../..").PerseusDependenciesV2> & {
         apiOptions: NonNullable<ExternalProps["apiOptions"]>;
         buttonSets: NonNullable<ExternalProps["buttonSets"]>;
         functions: NonNullable<ExternalProps["functions"]>;
@@ -83,9 +179,7 @@ declare const _default: {
         times: NonNullable<ExternalProps["times"]>;
         visibleLabel: PerseusExpressionWidgetOptions["visibleLabel"];
         ariaLabel: PerseusExpressionWidgetOptions["ariaLabel"];
-        value: string;
-    }, "static" | "onChange" | "ariaLabel" | "buttonsVisible" | "containerSizeClass" | "widgetId" | "problemNum" | "questionCompleted" | "findWidgets" | "trackInteraction" | "keypadElement" | "showSolutions" | "reviewMode" | keyof import("../..").PerseusDependenciesV2 | "reviewModeRubric" | "alignment" | "isLastUsedWidget" | "visibleLabel" | "keypadConfiguration"> & {
-        value?: string | undefined;
+    }, "static" | "onChange" | "ariaLabel" | "buttonsVisible" | "trackInteraction" | "containerSizeClass" | "widgetId" | "problemNum" | "questionCompleted" | "findWidgets" | "keypadElement" | "isLastUsedWidget" | "handleUserInput" | "showSolutions" | "reviewMode" | "reviewModeRubric" | keyof import("../..").PerseusDependenciesV2 | "alignment" | "visibleLabel" | "keypadConfiguration"> & {
         buttonSets?: import("@khanacademy/perseus-core").LegacyButtonSets | undefined;
         onFocus?: ((blurPath: FocusPath) => void) | undefined;
         onBlur?: ((blurPath: FocusPath) => void) | undefined;
@@ -138,6 +232,7 @@ declare const _default: {
             showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
         }> | undefined;
         linterContext?: import("@khanacademy/perseus-linter").LinterContextProps | undefined;
+        userInput?: string | undefined;
         functions?: string[] | undefined;
         times?: boolean | undefined;
     } & {}, keyof import("../..").PerseusDependenciesV2> & React.RefAttributes<Expression>>;
@@ -145,5 +240,6 @@ declare const _default: {
     version: import("@khanacademy/perseus-core").Version | undefined;
     isLintable: true;
     getOneCorrectAnswerFromRubric(rubric: PerseusExpressionRubric): string | null | undefined;
+    getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
 };
 export default _default;

package/dist/widgets/free-response/free-response.d.ts

@@ -9,17 +9,19 @@ import { PerseusI18nContext } from "../../components/i18n-context";
 import type { Widget, WidgetExports, WidgetProps } from "../../types";
 import type { PerseusFreeResponseUserInput, PerseusFreeResponseWidgetOptions } from "@khanacademy/perseus-core";
 type RenderProps = Pick<PerseusFreeResponseWidgetOptions, "allowUnlimitedCharacters" | "characterLimit" | "placeholder" | "question">;
-type Props = WidgetProps<RenderProps>;
-type State = {
-    currentValue: string;
-};
-export declare class FreeResponse extends React.Component<Props, State> implements Widget {
+type Props = WidgetProps<RenderProps, PerseusFreeResponseUserInput>;
+type DefaultProps = Pick<Props, "userInput">;
+export declare class FreeResponse extends React.Component<Props> implements Widget {
     static contextType: React.Context<import("../../components/i18n-context").I18nContextType>;
     context: React.ContextType<typeof PerseusI18nContext>;
-    state: State;
+    static defaultProps: DefaultProps;
     characterCount: () => number;
+    /**
+     * TODO: remove this when everything is pulling from Renderer state
+     * @deprecated get user input from Renderer state
+     * */
     getUserInput(): PerseusFreeResponseUserInput;
-    handleChange: (newValue: string) => void;
+    _handleUserInput: (newValue: string) => void;
     isOverLimit(): boolean;
     renderCharacterCount(): React.ReactNode;
     render(): React.ReactNode;

package/dist/widgets/graded-group-set/graded-group-set.d.ts

@@ -1,11 +1,10 @@
 import * as React from "react";
-import * as Changeable from "../../mixins/changeable";
 import { GradedGroup } from "../graded-group/graded-group";
 import type { FocusPath, Widget, WidgetProps } from "../../types";
 import type { GradedGroupSetPromptJSON } from "../../widget-ai-utils/graded-group-set/graded-group-set-ai-utils";
 import type { PerseusGradedGroupSetWidgetOptions } from "@khanacademy/perseus-core";
 type RenderProps = PerseusGradedGroupSetWidgetOptions;
-type Props = Changeable.ChangeableProps & WidgetProps<RenderProps> & {
+type Props = WidgetProps<RenderProps> & {
     trackInteraction: () => void;
 };
 type DefaultProps = {
@@ -20,7 +19,6 @@ declare class GradedGroupSet extends React.Component<Props, State> implements Wi
     static defaultProps: DefaultProps;
     state: State;
     shouldComponentUpdate(nextProps: Props, nextState: State): boolean;
-    change: (...args: ReadonlyArray<unknown>) => any;
     getInputPaths: () => ReadonlyArray<FocusPath>;
     getPromptJSON(): GradedGroupSetPromptJSON;
     setInputValue: (arg1: FocusPath, arg2: any, arg3: any) => any;

package/dist/widgets/grapher/grapher.d.ts

@@ -6,21 +6,11 @@ import type { GridDimensions } from "../../util";
 import type { GrapherPromptJSON } from "../../widget-ai-utils/grapher/grapher-ai-utils";
 import type { PerseusGrapherWidgetOptions, PerseusGrapherUserInput, GrapherPublicWidgetOptions } from "@khanacademy/perseus-core";
 import type { PropsFor } from "@khanacademy/wonder-blocks-core";
-type RenderProps = Pick<GrapherPublicWidgetOptions, "availableTypes" | "graph"> & {
-    plot?: PerseusGrapherWidgetOptions["correct"];
-};
-type ExternalProps = WidgetProps<RenderProps>;
-type Props = ExternalProps & {
-    plot: NonNullable<RenderProps["plot"]>;
-};
-type DefaultProps = {
-    plot: RenderProps["plot"];
-};
+type RenderProps = Pick<GrapherPublicWidgetOptions, "availableTypes" | "graph">;
+type Props = WidgetProps<RenderProps, PerseusGrapherUserInput>;
 declare class Grapher extends React.Component<Props> implements Widget {
     horizHairline: any;
     vertHairline: any;
-    static defaultProps: DefaultProps;
-    static getUserInputFromProps(props: Props): PerseusGrapherUserInput;
     handlePlotChanges: (arg1: any) => any;
     handleActiveTypeChange: (arg1: any) => any;
     _getGridConfig(options: Props["graph"] & {
@@ -33,14 +23,149 @@ declare class Grapher extends React.Component<Props> implements Widget {
     hideHairlines: () => void;
     getUserInput(): PerseusGrapherUserInput;
     getPromptJSON(): GrapherPromptJSON;
+    /**
+     * @deprecated and likely very broken API
+     * [LEMS-3185] do not trust serializedState/restoreSerializedState
+     */
+    getSerializedState(): {
+        plot: import("@khanacademy/perseus-core").GrapherAnswerTypes;
+        graph: {
+            backgroundImage: {
+                bottom?: number;
+                height?: number;
+                left?: number;
+                scale?: number;
+                url?: string | null | undefined;
+                width?: number;
+            };
+            box?: [number, number];
+            editableSettings?: Array<"graph" | "snap" | "image" | "measure">;
+            gridStep?: [number, number];
+            labels: [string, string];
+            markings: import("@khanacademy/perseus-core").MarkingsType;
+            range: import("@khanacademy/perseus-core").GraphRange;
+            rulerLabel: "";
+            rulerTicks: number;
+            showProtractor?: boolean;
+            showRuler?: boolean;
+            showTooltips?: boolean;
+            snapStep?: [number, number];
+            step: [number, number];
+            valid?: boolean | string;
+        };
+        availableTypes: Array<"absolute_value" | "exponential" | "linear" | "logarithm" | "quadratic" | "sinusoid" | "tangent">;
+        reviewModeRubric?: Empty | null | undefined;
+        trackInteraction: (extraData?: Empty | undefined) => void;
+        widgetId: string;
+        alignment: string | null | undefined;
+        static: boolean | null | undefined;
+        problemNum: number | null | undefined;
+        apiOptions: Readonly<Readonly<{
+            isArticle?: boolean;
+            onFocusChange?: (newFocusPath: import("../..").FocusPath, oldFocusPath: import("../..").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;
+            groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
+            imagePlaceholder?: React.ReactNode;
+            widgetPlaceholder?: React.ReactNode;
+            baseElements?: {
+                Link: React.ComponentType<any>;
+            };
+            imagePreloader?: (dimensions: import("../../types").Dimensions) => React.ReactNode;
+            trackInteraction?: (args: {
+                type: string;
+                id: string;
+                correct?: boolean;
+            } & Partial<import("../../types").TrackingGradedGroupExtraArguments> & Partial<{
+                visible: number;
+            }>) => void;
+            customKeypad?: boolean;
+            nativeKeypadProxy?: (blur: () => void) => import("@khanacademy/math-input").KeypadAPI;
+            isMobile?: boolean;
+            isMobileApp?: boolean;
+            setDrawingAreaAvailable?: (arg1: boolean) => unknown;
+            hintProgressColor?: string;
+            canScrollPage?: boolean;
+            editorChangeDelay?: number;
+            flags?: Record<"new-radio-widget", boolean>;
+            onWidgetStartProps?: (widgets: import("@khanacademy/perseus-core").PerseusWidgetsMap) => void;
+        }> & {
+            baseElements: NonNullable<import("../..").APIOptions["baseElements"]>;
+            canScrollPage: NonNullable<import("../..").APIOptions["canScrollPage"]>;
+            editorChangeDelay: NonNullable<import("../..").APIOptions["editorChangeDelay"]>;
+            groupAnnotator: NonNullable<import("../..").APIOptions["groupAnnotator"]>;
+            isArticle: NonNullable<import("../..").APIOptions["isArticle"]>;
+            isMobile: NonNullable<import("../..").APIOptions["isMobile"]>;
+            isMobileApp: NonNullable<import("../..").APIOptions["isMobileApp"]>;
+            onFocusChange: NonNullable<import("../..").APIOptions["onFocusChange"]>;
+            readOnly: NonNullable<import("../..").APIOptions["readOnly"]>;
+            setDrawingAreaAvailable: NonNullable<import("../..").APIOptions["setDrawingAreaAvailable"]>;
+            showAlignmentOptions: NonNullable<import("../..").APIOptions["showAlignmentOptions"]>;
+        }>;
+        keypadElement?: any;
+        questionCompleted?: boolean;
+        onFocus: (blurPath: import("../..").FocusPath) => void;
+        onBlur: (blurPath: import("../..").FocusPath) => void;
+        findWidgets: (criterion: import("../../types").FilterCriterion) => ReadonlyArray<Widget>;
+        reviewMode: boolean;
+        showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
+        onChange: import("../..").ChangeHandler;
+        handleUserInput: (newUserInput: import("@khanacademy/perseus-core").GrapherAnswerTypes, cb?: () => void, silent?: boolean) => void;
+        isLastUsedWidget: boolean;
+        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
+        containerSizeClass: import("../../util/sizing-utils").SizeClass;
+    };
     render(): React.ReactNode;
 }
+declare function transform(options: GrapherPublicWidgetOptions): RenderProps;
+declare function staticTransform(options: PerseusGrapherWidgetOptions): {
+    availableTypes: ("linear" | "quadratic" | "sinusoid" | "absolute_value" | "exponential" | "logarithm" | "tangent")[];
+    plot: import("@khanacademy/perseus-core").GrapherAnswerTypes;
+    graph: {
+        backgroundImage: {
+            bottom?: number;
+            height?: number;
+            left?: number;
+            scale?: number;
+            url?: string | null | undefined;
+            width?: number;
+        };
+        box?: [number, number];
+        editableSettings?: Array<"graph" | "snap" | "image" | "measure">;
+        gridStep?: [number, number];
+        labels: [string, string];
+        markings: import("@khanacademy/perseus-core").MarkingsType;
+        range: import("@khanacademy/perseus-core").GraphRange;
+        rulerLabel: "";
+        rulerTicks: number;
+        showProtractor?: boolean;
+        showRuler?: boolean;
+        showTooltips?: boolean;
+        snapStep?: [number, number];
+        step: [number, number];
+        valid?: boolean | string;
+    };
+};
+/**
+ * @deprecated and likely a very broken API
+ * [LEMS-3185] do not trust serializedState/restoreSerializedState
+ */
+declare function getUserInputFromSerializedState(serializedState: any): PerseusGrapherUserInput;
+declare function getStartUserInput(options: GrapherPublicWidgetOptions): PerseusGrapherUserInput;
 declare const _default: {
     name: string;
     displayName: string;
     hidden: true;
     widget: typeof Grapher;
-    transform: (arg1: GrapherPublicWidgetOptions) => RenderProps;
-    staticTransform: (arg1: PerseusGrapherWidgetOptions) => RenderProps;
+    transform: typeof transform;
+    staticTransform: typeof staticTransform;
+    getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
+    getStartUserInput: typeof getStartUserInput;
 };
 export default _default;

package/dist/widgets/grapher/util.d.ts

@@ -1,11 +1,11 @@
 import { GrapherUtil } from "@khanacademy/perseus-core";
 import type { Coord } from "../../interactive2/types";
-import type { FunctionTypeMappingKeys } from "@khanacademy/perseus-core";
+import type { FunctionTypeMappingKeys, GrapherAnswerTypes } from "@khanacademy/perseus-core";
 type MovableMap = {
     [K in keyof typeof GrapherUtil.MOVABLES]: any;
 };
 export declare const movableTypeToComponent: MovableMap;
-export declare const getEquationString: (props: any) => string;
+export declare const getEquationString: (plot: GrapherAnswerTypes) => string;
 export declare const maybePointsFromNormalized: (coordsList: ReadonlyArray<Coord> | null | undefined, range: [Coord, Coord], step: [number, number], snapStep: [number, number]) => ReadonlyArray<Coord> | null | undefined;
 export declare const defaultPlotProps: (type: FunctionTypeMappingKeys, graph: any) => any;
 export declare const chooseType: <T>(list: ReadonlyArray<T>) => T | undefined;

package/dist/widgets/group/group.d.ts

@@ -33,7 +33,13 @@ declare class Group extends React.Component<Props> implements Widget {
      */
     getUserInput(): UserInputArray | undefined;
     getPromptJSON(): GroupPromptJSON;
+    /**
+     * @deprecated - do not use in new code.
+     */
     getSerializedState: () => any;
+    /**
+     * @deprecated - do not use in new code.
+     */
     restoreSerializedState: (arg1: any, arg2: any) => null;
     getInputPaths(): readonly FocusPath[];
     setInputValue: (arg1: FocusPath, arg2: string, arg3?: () => unknown) => void;

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

@@ -7,21 +7,18 @@
  *  but could also be used for embedding viz's hosted elsewhere.
  */
 import * as React from "react";
-import type { WidgetProps, Widget, ChangeFn } from "../../types";
+import type { WidgetProps, Widget } from "../../types";
 import type { UnsupportedWidgetPromptJSON } from "../../widget-ai-utils/unsupported-widget";
-import type { PerseusIFrameUserInput, UserInputStatus, PerseusIFrameWidgetOptions } from "@khanacademy/perseus-core";
+import type { PerseusIFrameUserInput, PerseusIFrameWidgetOptions } from "@khanacademy/perseus-core";
 type RenderProps = PerseusIFrameWidgetOptions & {
-    status: UserInputStatus;
-    message: string | null;
     width: string;
     height: string;
 };
-type Props = WidgetProps<RenderProps>;
+type Props = WidgetProps<RenderProps, PerseusIFrameUserInput>;
 type DefaultProps = {
-    status: Props["status"];
-    message: Props["message"];
     allowFullScreen: Props["allowFullScreen"];
     allowTopNavigation: Props["allowTopNavigation"];
+    userInput: Props["userInput"];
 };
 declare class Iframe extends React.Component<Props> implements Widget {
     static defaultProps: DefaultProps;
@@ -30,13 +27,18 @@ declare class Iframe extends React.Component<Props> implements Widget {
     getUserInput(): PerseusIFrameUserInput;
     getPromptJSON(): UnsupportedWidgetPromptJSON;
     handleMessageEvent: (arg1: any) => void;
-    change: ChangeFn;
     render(): React.ReactNode;
 }
+/**
+ * @deprecated and likely a very broken API
+ * [LEMS-3185] do not trust serializedState/restoreSerializedState
+ */
+declare function getUserInputFromSerializedState(serializedState: any): PerseusIFrameUserInput;
 declare const _default: {
     name: string;
     displayName: string;
     widget: typeof Iframe;
     hidden: true;
+    getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
 };
 export default _default;

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

@@ -1,6 +1,6 @@
 import * as React from "react";
 import { PerseusI18nContext } from "../../components/i18n-context";
-import type { ChangeFn, WidgetProps, Widget } from "../../types";
+import type { WidgetProps, Widget } from "../../types";
 import type { ImagePromptJSON } from "../../widget-ai-utils/image/image-ai-utils";
 import type { PerseusImageWidgetOptions } from "@khanacademy/perseus-core";
 type RenderProps = PerseusImageWidgetOptions;
@@ -32,7 +32,6 @@ declare class ImageWidget extends React.Component<Props> implements Widget {
     context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
     isWidget: true;
-    change: ChangeFn;
     getPromptJSON(): ImagePromptJSON;
     render(): React.ReactNode;
 }

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

@@ -4,23 +4,19 @@ import type { Path, Widget, WidgetProps } from "../../types";
 import type { InputNumberPromptJSON } from "../../widget-ai-utils/input-number/input-number-ai-utils";
 import type { PerseusInputNumberWidgetOptions, PerseusInputNumberUserInput } from "@khanacademy/perseus-core";
 type RenderProps = Pick<PerseusInputNumberWidgetOptions, "simplify" | "size" | "answerType" | "rightAlign">;
-type ExternalProps = WidgetProps<RenderProps>;
+type ExternalProps = WidgetProps<RenderProps, PerseusInputNumberUserInput>;
 type Props = ExternalProps & {
     apiOptions: NonNullable<ExternalProps["apiOptions"]>;
     linterContext: NonNullable<ExternalProps["linterContext"]>;
     rightAlign: NonNullable<ExternalProps["rightAlign"]>;
     size: NonNullable<ExternalProps["size"]>;
-    currentValue: string;
     answerType: NonNullable<ExternalProps["answerType"]>;
 };
-type DefaultProps = Pick<Props, "answerType" | "apiOptions" | "currentValue" | "linterContext" | "rightAlign" | "size">;
+type DefaultProps = Pick<Props, "answerType" | "apiOptions" | "linterContext" | "rightAlign" | "size" | "userInput">;
 declare class InputNumber extends React.Component<Props> implements Widget {
     static contextType: React.Context<import("../../components/i18n-context").I18nContextType>;
     context: React.ContextType<typeof PerseusI18nContext>;
     static defaultProps: DefaultProps;
-    static getUserInputFromProps(props: Props): {
-        currentValue: string;
-    };
     shouldShowExamples: () => boolean;
     handleChange: (arg1: string, arg2: () => void) => void;
     _handleFocus: () => void;
@@ -30,13 +26,27 @@ declare class InputNumber extends React.Component<Props> implements Widget {
     blurInputPath: (arg1: Path) => void;
     getInputPaths: () => ReadonlyArray<Path>;
     setInputValue: (arg1: Path, arg2: string, arg3: () => void) => void;
+    /**
+     * TODO: remove this when everything is pulling from Renderer state
+     * @deprecated get user input from Renderer state
+     */
     getUserInput(): PerseusInputNumberUserInput;
     getPromptJSON(): InputNumberPromptJSON;
     examples(): ReadonlyArray<string>;
+    /**
+     * @deprecated and likely very broken API
+     * [LEMS-3185] do not trust serializedState/restoreSerializedState
+     */
+    getSerializedState(): any;
     render(): React.ReactNode;
 }
 declare function transform(widgetOptions: PerseusInputNumberWidgetOptions): RenderProps;
 declare function getOneCorrectAnswerFromRubric(rubric: any): string | undefined;
+/**
+ * @deprecated and likely a very broken API
+ * [LEMS-3185] do not trust serializedState/restoreSerializedState
+ */
+declare function getUserInputFromSerializedState(serializedState: any): PerseusInputNumberUserInput;
 declare const _default: {
     name: string;
     displayName: string;
@@ -45,5 +55,6 @@ declare const _default: {
     isLintable: true;
     transform: typeof transform;
     getOneCorrectAnswerFromRubric: typeof getOneCorrectAnswerFromRubric;
+    getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
 };
 export default _default;

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

@@ -23,7 +23,6 @@ declare class Interaction extends React.Component<Props, State> implements Widge
     _updateLineLocation: (arg1: any, arg2: Coord) => void;
     _eval: (arg1: any, arg2: any) => number;
     _extractVars: (arg1: any) => ReadonlyArray<any>;
-    change: (arg1: any, arg2: any, arg3: any) => any;
     getPromptJSON(): UnsupportedWidgetPromptJSON;
     render(): React.ReactNode;
 }
@@ -31,7 +30,6 @@ declare const _default: {
     name: string;
     displayName: string;
     widget: typeof Interaction;
-    transform: <T>(value: T) => T;
     hidden: true;
 };
 export default _default;