@khanacademy/perseus 82.1.0 → 82.2.0

package/dist/util.d.ts

@@ -1,5 +1,6 @@
 import { getRealImageUrl, getBaseUrl, getSvgUrl, getDataUrl, getImageSizeModern, isLabeledSVG } from "@khanacademy/perseus-core";
 import type { Coord, Range } from "@khanacademy/perseus-core";
+import type { ASTNode, SingleASTNode } from "@khanacademy/simple-markdown";
 import type * as React from "react";
 type WordPosition = {
     start: number;
@@ -34,6 +35,27 @@ type TouchHandlers = {
  * arrays of strings.
  */
 declare function inputPathsEqual(a?: ReadonlyArray<string> | null, b?: ReadonlyArray<string> | null): boolean;
+/**
+ * Some widgets render as inline content but CANNOT safely live
+ * inside a paragraph (`<p>`). When this function returns true, the
+ * QuestionParagraph component will not render the containing <p> element.
+ * No additional processing is done on the sibling nodes.
+ */
+export declare const noParagraphForInlineWidget: (node: SingleASTNode) => boolean;
+/**
+ * Handle situations in the markdown where a block-level widget doesn't have the
+ * expected double-newline characters in place. The blockRegex function in
+ * perseus-markdown.tsx expects a double-newline. When only a single newline
+ * character exists, then the widget is contained by a <p> element, which is
+ * invalid HTML. This function splits out the widget from the inline text so
+ * that the HTML is valid (<p> elements surround inline content, block-level
+ * widgets are by themselves).
+ *
+ * Only direct children of top-level paragraphs are considered; block widgets
+ * nested inside inline formatting (e.g. `strong`) or inside other containers
+ * (tables, columns) are not split out.
+ */
+declare function splitBlockWidgetsFromParagraphs(ast: ASTNode): ASTNode;
 /**
  * Return the first valid interpretation of 'text' as a number, in the form
  * {value: 2.3, exact: true}.
@@ -164,6 +186,7 @@ declare const Util: {
     readonly rTypeFromWidgetId: RegExp;
     readonly rWidgetParts: RegExp;
     readonly snowman: "☃";
+    readonly splitBlockWidgetsFromParagraphs: typeof splitBlockWidgetsFromParagraphs;
     readonly firstNumericalParse: typeof firstNumericalParse;
     readonly stringArrayOfSize: typeof stringArrayOfSize;
     readonly stringArrayOfSize2D: typeof stringArrayOfSize2D;

package/dist/widget-ai-utils/input-number/input-number-ai-utils.d.ts

@@ -14,7 +14,7 @@ export type InputNumberPromptJSON = {
      * Shown to learners using screen readers to describe what value should
      * be entered.
      */
-    label: string;
+    label?: string;
     /**
      * The current state of the widget user interface. Usually represents a
      * learner's attempt to answer a question.

package/dist/widget-ai-utils/numeric-input/prompt-utils.d.ts

@@ -1,4 +1,4 @@
-import type numericInput from "../../widgets/numeric-input/numeric-input.class";
+import type numericInput from "../../widgets/numeric-input/numeric-input";
 import type React from "react";
 /**
  * JSON describing a numeric-input widget. Intended for consumption by AI tools.

package/dist/{widget-container.d.ts → widget-container.new.d.ts}

@@ -1,3 +1,8 @@
+/***********************************************************************
+ *                                                                     *
+ * WARNING!!!! THERE ARE ACTIVE CHANGES HAPPENING IN THE RENDERER!     *
+ *                                                                     *
+ ***********************************************************************/
 import { type PerseusWidgetOptions } from "@khanacademy/perseus-core";
 import * as React from "react";
 import type { WidgetProps } from "./types";

package/dist/widget-container.old.d.ts

@@ -0,0 +1,31 @@
+/***********************************************************************
+ *                                                                     *
+ * WARNING!!!! THERE ARE ACTIVE CHANGES HAPPENING IN THE RENDERER!     *
+ *                                                                     *
+ ***********************************************************************/
+import { type PerseusWidgetOptions } from "@khanacademy/perseus-core";
+import * as React from "react";
+import type { WidgetProps } from "./types";
+import type { LinterContextProps } from "@khanacademy/perseus-linter";
+type Props = {
+    type: string;
+    id: string;
+    widgetProps: WidgetProps<any, PerseusWidgetOptions>;
+    linterContext: LinterContextProps;
+};
+type DefaultProps = {
+    linterContext: LinterContextProps;
+};
+type State = {
+    sizeClass: "small" | "medium" | "large" | "xlarge";
+};
+declare class WidgetContainerOld extends React.Component<Props, State> {
+    widgetRef: React.RefObject<React.ComponentType<any>>;
+    static defaultProps: DefaultProps;
+    state: State;
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    getWidget: () => any;
+    render(): React.ReactNode;
+}
+export default WidgetContainerOld;

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

@@ -1,11 +1,7 @@
-import * as React from "react";
-import type { PerseusDependenciesV2, WidgetProps } from "../../types";
-import type { PerseusCategorizerWidgetOptions, PerseusCategorizerUserInput } from "@khanacademy/perseus-core";
+import React from "react";
+import type { PerseusDependenciesV2, Widget, WidgetProps } from "../../types";
+import type { PerseusCategorizerUserInput, PerseusCategorizerWidgetOptions } from "@khanacademy/perseus-core";
 type ExternalProps = WidgetProps<PerseusCategorizerWidgetOptions, PerseusCategorizerUserInput>;
-type Props = ExternalProps & {
-    linterContext: NonNullable<ExternalProps["linterContext"]>;
-    dependencies: PerseusDependenciesV2;
-};
 /**
  * @deprecated and likely a very broken API
  * [LEMS-3185] do not trust serializedState
@@ -20,7 +16,66 @@ declare function getStartUserInput(): PerseusCategorizerUserInput;
 declare const _default: {
     name: string;
     displayName: string;
-    widget: React.ForwardRefExoticComponent<Omit<Props, "dependencies"> & React.RefAttributes<any>>;
+    widget: React.ForwardRefExoticComponent<Omit<Omit<PerseusCategorizerWidgetOptions & {
+        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: PerseusCategorizerUserInput, cb?: () => void, silent?: boolean) => void;
+        userInput: PerseusCategorizerUserInput;
+        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
+        containerSizeClass: import("../../util/sizing-utils").SizeClass;
+    } & {
+        linterContext: NonNullable<ExternalProps["linterContext"]>;
+        dependencies: PerseusDependenciesV2;
+    } & React.RefAttributes<Widget>, "dependencies">, "ref"> & React.RefAttributes<any>>;
     getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
     getCorrectUserInput: typeof getCorrectUserInput;
     getStartUserInput: typeof getStartUserInput;

package/dist/widgets/cs-program/cs-program.d.ts

@@ -4,7 +4,6 @@
 import React from "react";
 import type { Widget } from "../../types";
 import type { PerseusCSProgramWidgetOptions, PerseusCSProgramUserInput } from "@khanacademy/perseus-core";
-type WidgetHandle = Pick<Widget, "getPromptJSON" | "getSerializedState">;
 /**
  * @deprecated and likely a very broken API
  * [LEMS-3185] do not trust serializedState
@@ -70,7 +69,7 @@ declare const _default: {
         userInput: PerseusCSProgramUserInput;
         linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
         containerSizeClass: import("../../util/sizing-utils").SizeClass;
-    } & React.RefAttributes<WidgetHandle>>;
+    } & React.RefAttributes<Widget>>;
     hidden: true;
     getStartUserInput: typeof getStartUserInput;
     getUserInputFromSerializedState: typeof getUserInputFromSerializedState;

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

@@ -1,7 +1,6 @@
 import React from "react";
 import type { PerseusDependenciesV2, Widget } from "../../types";
 import type { PerseusDropdownUserInput, PerseusDropdownWidgetOptions } from "@khanacademy/perseus-core";
-type WidgetHandle = Pick<Widget, "focus" | "getPromptJSON" | "getSerializedState">;
 /**
  * @deprecated and likely a very broken API
  * [LEMS-3185] do not trust serializedState
@@ -70,7 +69,7 @@ declare const _default: {
         containerSizeClass: import("../../util/sizing-utils").SizeClass;
     } & {
         dependencies: PerseusDependenciesV2;
-    } & React.RefAttributes<WidgetHandle>, "dependencies">, "ref"> & React.RefAttributes<any>>;
+    } & React.RefAttributes<Widget>, "dependencies">, "ref"> & React.RefAttributes<any>>;
     getStartUserInput: typeof getStartUserInput;
     getCorrectUserInput: typeof getCorrectUserInput;
     getUserInputFromSerializedState: typeof getUserInputFromSerializedState;

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

@@ -1,7 +1,6 @@
 import React from "react";
 import type { Widget } from "../../types";
 import type { PerseusImageWidgetOptions } from "@khanacademy/perseus-core";
-type WidgetHandle = Pick<Widget, "getPromptJSON">;
 declare const _default: {
     name: string;
     displayName: string;
@@ -61,7 +60,7 @@ declare const _default: {
         userInput: Empty;
         linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
         containerSizeClass: import("../../util/sizing-utils").SizeClass;
-    } & React.RefAttributes<WidgetHandle>>;
+    } & React.RefAttributes<Widget>>;
     isLintable: true;
 };
 export default _default;

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

@@ -8,11 +8,67 @@ declare const _default: {
     name: string;
     displayName: string;
     hidden: true;
-    widget: typeof import("../numeric-input/numeric-input.class").NumericInput;
+    widget: import("react").ForwardRefExoticComponent<import("@khanacademy/perseus-core").PerseusNumericInputWidgetOptions & {
+        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: import("@khanacademy/perseus-core").PerseusNumericInputUserInput, cb?: () => void, silent?: boolean) => void;
+        userInput: import("@khanacademy/perseus-core").PerseusNumericInputUserInput;
+        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
+        containerSizeClass: import("../../util/sizing-utils").SizeClass;
+    } & import("react").RefAttributes<import("../../types").Widget>>;
     isLintable: true;
-    getOneCorrectAnswerFromRubric: (rubric: import("@khanacademy/perseus-core").PerseusNumericInputRubric) => string | null | undefined;
-    getStartUserInput: () => import("@khanacademy/perseus-core").PerseusNumericInputUserInput;
-    getCorrectUserInput: (options: import("@khanacademy/perseus-core").PerseusNumericInputWidgetOptions) => import("@khanacademy/perseus-core").PerseusNumericInputUserInput;
+    getOneCorrectAnswerFromRubric: typeof import("../numeric-input/utils").getOneCorrectAnswerFromRubric;
+    getStartUserInput: typeof import("../numeric-input/utils").getStartUserInput;
+    getCorrectUserInput: typeof import("../numeric-input/utils").getCorrectUserInput;
     getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
 };
 export default _default;

package/dist/widgets/matcher/matcher.d.ts

@@ -1,39 +1,15 @@
 import * as React from "react";
-import { PerseusI18nContext } from "../../components/i18n-context";
 import type { SortableOption } from "../../components/sortable";
-import type { WidgetProps, Widget, PerseusDependenciesV2 } from "../../types";
-import type { MatcherPromptJSON } from "../../widget-ai-utils/matcher/matcher-ai-utils";
+import type { Widget, PerseusDependenciesV2 } from "../../types";
 import type { PerseusMatcherWidgetOptions, PerseusMatcherUserInput, MatcherPublicWidgetOptions } from "@khanacademy/perseus-core";
-type Props = WidgetProps<PerseusMatcherWidgetOptions, PerseusMatcherUserInput> & {
-    dependencies: PerseusDependenciesV2;
-};
-type DefaultProps = {
-    labels: Props["labels"];
-    orderMatters: Props["orderMatters"];
-    padding: Props["padding"];
-    problemNum: Props["problemNum"];
-    linterContext: Props["linterContext"];
-    userInput: Props["userInput"];
-};
-type State = {
-    leftHeight: number;
-    rightHeight: number;
-    texRendererLoaded: boolean;
-};
-export declare class Matcher extends React.Component<Props, State> implements Widget {
-    static contextType: React.Context<import("../../components/i18n-context").I18nContextType>;
-    context: React.ContextType<typeof PerseusI18nContext>;
-    static defaultProps: DefaultProps;
-    state: State;
-    componentDidMount(): void;
-    changeAndTrack: () => void;
-    onMeasureLeft: (arg1: any) => void;
-    onMeasureRight: (arg1: any) => void;
-    _getUserInputFromSortable: () => PerseusMatcherUserInput;
-    getPromptJSON(): MatcherPromptJSON;
+/**
+ * The imperative API the Matcher widget exposes to its parent renderer. On top
+ * of the usual `Widget` methods, it can move a named option to a given index
+ * within its column, as if the user had dragged it there.
+ */
+export interface MatcherHandle extends Widget {
     moveLeftOptionToIndex: (option: SortableOption, index: number) => void;
     moveRightOptionToIndex: (option: SortableOption, index: number) => void;
-    render(): React.ReactElement;
 }
 declare function getStartUserInput(options: MatcherPublicWidgetOptions, problemNum: number): PerseusMatcherUserInput;
 /**
@@ -45,7 +21,65 @@ declare const _default: {
     name: string;
     displayName: string;
     hidden: true;
-    widget: React.ForwardRefExoticComponent<Omit<Props, "dependencies"> & React.RefAttributes<any>>;
+    widget: React.ForwardRefExoticComponent<Omit<Omit<PerseusMatcherWidgetOptions & {
+        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: PerseusMatcherUserInput, cb?: () => void, silent?: boolean) => void;
+        userInput: PerseusMatcherUserInput;
+        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
+        containerSizeClass: import("../../util/sizing-utils").SizeClass;
+    } & {
+        dependencies: PerseusDependenciesV2;
+    } & React.RefAttributes<MatcherHandle>, "dependencies">, "ref"> & React.RefAttributes<any>>;
     isLintable: true;
     getStartUserInput: typeof getStartUserInput;
     getUserInputFromSerializedState: typeof getUserInputFromSerializedState;

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

@@ -1,9 +1,6 @@
 import * as React from "react";
 import type { Widget, PerseusDependenciesV2 } from "../../types";
 import type { PerseusNumberLineUserInput, PerseusNumberLineWidgetOptions, NumberLinePublicWidgetOptions } from "@khanacademy/perseus-core";
-type WidgetHandle = Pick<Widget, "focus" | "focusInputPath" | "blurInputPath" | "getInputPaths" | "getDOMNodeForPath" | "getSerializedState" | "getPromptJSON"> & {
-    movePosition: (targetPosition: number) => void;
-};
 /**
  * @deprecated and likely a very broken API
  * [LEMS-3185] do not trust serializedState
@@ -72,7 +69,7 @@ declare const _default: {
         containerSizeClass: import("../../util/sizing-utils").SizeClass;
     } & {
         dependencies: PerseusDependenciesV2;
-    } & React.RefAttributes<WidgetHandle>, "dependencies">, "ref"> & React.RefAttributes<any>>;
+    } & React.RefAttributes<Widget>, "dependencies">, "ref"> & React.RefAttributes<any>>;
     getCorrectUserInput: typeof getCorrectUserInput;
     getStartUserInput: typeof getStartUserInput;
     getUserInputFromSerializedState: typeof getUserInputFromSerializedState;

package/dist/widgets/numeric-input/index.d.ts

@@ -1 +1 @@
-export { default } from "./numeric-input.class";
+export { default } from "./numeric-input";

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

@@ -1,11 +1,12 @@
 import * as React from "react";
-import type { Focusable } from "../../types";
+import { getCorrectUserInput, getOneCorrectAnswerFromRubric, getStartUserInput, getUserInputFromSerializedState } from "./utils";
+import type { Widget } from "../../types";
+import type { PerseusNumericInputUserInput, PerseusNumericInputWidgetOptions } from "@khanacademy/perseus-core";
 /**
- * The NumericInputComponent is a child component of the NumericInput class
- * component. It is responsible for rendering the UI elements of the Numeric
- * Input widget.
+ * The NumericInput widget is a numeric input field that supports a variety of
+ * answer forms, including integers, decimals, fractions, and mixed numbers.
  */
-export declare const NumericInputComponent: React.ForwardRefExoticComponent<import("@khanacademy/perseus-core").PerseusNumericInputWidgetOptions & {
+export declare const NumericInput: React.ForwardRefExoticComponent<PerseusNumericInputWidgetOptions & {
     trackInteraction: (extraData?: Empty | undefined) => void;
     widgetId: string;
     widgetIndex: number;
@@ -57,53 +58,75 @@ export declare const NumericInputComponent: React.ForwardRefExoticComponent<impo
     findWidgets: import("../../types").FindWidgetsFunction;
     reviewMode: boolean;
     showSolutions?: import("@khanacademy/perseus-core").ShowSolutions;
-    handleUserInput: (newUserInput: import("@khanacademy/perseus-core").PerseusNumericInputUserInput, cb?: () => void, silent?: boolean) => void;
-    userInput: import("@khanacademy/perseus-core").PerseusNumericInputUserInput;
+    handleUserInput: (newUserInput: PerseusNumericInputUserInput, cb?: () => void, silent?: boolean) => void;
+    userInput: PerseusNumericInputUserInput;
     linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
     containerSizeClass: import("../../util/sizing-utils").SizeClass;
-} & {
-    size: NonNullable<string>;
-    textAlign: NonNullable<"center" | "left" | "right">;
-    apiOptions: NonNullable<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"]>;
-    }>>;
-    coefficient: NonNullable<boolean>;
-    answerForms: ReadonlyArray<import("@khanacademy/perseus-core").PerseusNumericInputAnswerForm>;
-    labelText: string;
-    linterContext: NonNullable<import("@khanacademy/perseus-linter").LinterContextProps>;
-} & React.RefAttributes<Focusable>>;
+} & React.RefAttributes<Widget>>;
+declare const _default: {
+    name: string;
+    displayName: string;
+    widget: React.ForwardRefExoticComponent<PerseusNumericInputWidgetOptions & {
+        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: PerseusNumericInputUserInput, cb?: () => void, silent?: boolean) => void;
+        userInput: PerseusNumericInputUserInput;
+        linterContext: import("@khanacademy/perseus-linter").LinterContextProps;
+        containerSizeClass: import("../../util/sizing-utils").SizeClass;
+    } & React.RefAttributes<Widget>>;
+    isLintable: true;
+    getCorrectUserInput: typeof getCorrectUserInput;
+    getOneCorrectAnswerFromRubric: typeof getOneCorrectAnswerFromRubric;
+    getStartUserInput: typeof getStartUserInput;
+    getUserInputFromSerializedState: typeof getUserInputFromSerializedState;
+};
+export default _default;

package/dist/widgets/numeric-input/utils.d.ts

@@ -1,5 +1,5 @@
 import type { PerseusStrings } from "../../strings";
-import type { PerseusNumericInputAnswerForm, PerseusNumericInputWidgetOptions } from "@khanacademy/perseus-core";
+import type { PerseusNumericInputAnswerForm, PerseusNumericInputRubric, PerseusNumericInputUserInput, PerseusNumericInputWidgetOptions } from "@khanacademy/perseus-core";
 /**
  * Generates the specific set of examples for the current question.
  * This string is shown as examples to the user in a tooltip.
@@ -21,3 +21,16 @@ export declare const unionAnswerForms: (answerFormsList: ReadonlyArray<ReadonlyA
  * so that we can generate the examples for the widget.
  */
 export declare function normalizeCorrectAnswerForms(answers: PerseusNumericInputWidgetOptions["answers"]): ReadonlyArray<PerseusNumericInputAnswerForm>;
+export declare function getStartUserInput(): PerseusNumericInputUserInput;
+/**
+ * @deprecated and likely a very broken API
+ * [LEMS-3185] do not trust serializedState
+ */
+export declare function getUserInputFromSerializedState(serializedState: any): PerseusNumericInputUserInput;
+export declare function findPrecision(value: number): number;
+export declare function findCommonFractions(value: number): {
+    num: number;
+    denom: number;
+} | undefined;
+export declare function getCorrectUserInput(options: PerseusNumericInputWidgetOptions): PerseusNumericInputUserInput;
+export declare function getOneCorrectAnswerFromRubric(rubric: PerseusNumericInputRubric): string | null | undefined;

package/dist/widgets/phet-simulation/phet-simulation.d.ts

@@ -48,6 +48,8 @@ export declare class PhetSimulation extends React.Component<Props, State> implem
      * the lack of support for the Fullscreen API.
      */
     toggleFullScreen: () => void;
+    requestIframeFullscreen: () => void;
+    renderCornerButton(url: URL, isMobileApp: boolean | undefined): React.ReactNode;
     render(): React.ReactNode;
 }
 declare const _default: {