@khanacademy/perseus 3.0.0 → 4.0.0

package/dist/types.d.ts

@@ -0,0 +1,262 @@
+import katex from "katex";
+import katexA11y from "katex/dist/contrib/render-a11y-string";
+import * as React from "react";
+import type { SerializedHighlightSet } from "./components/highlighting/types";
+import type { ILogger } from "./logging/log";
+import type { Item } from "./multi-items/item-types";
+import type { PerseusWidget } from "./perseus-types";
+import type { SizeClass } from "./util/sizing-utils";
+import type { Result } from "@khanacademy/wonder-blocks-data";
+export type FocusPath = ReadonlyArray<string> | null | undefined;
+type State = any;
+export interface RendererInterface {
+    getSerializedState(): State;
+    restoreSerializedState(state: State, callback?: () => void): void;
+    scoreInput(): KEScore;
+    blur(): void;
+    focus(): boolean | null | undefined;
+    props: any;
+}
+export type Dimensions = {
+    width?: number;
+    height?: number;
+};
+export type DeviceType = "phone" | "tablet" | "desktop";
+export type Widget = any;
+export type WidgetDict = {
+    [name: string]: Widget;
+};
+export type ImageDict = {
+    [url: string]: Dimensions;
+};
+export type PerseusScore = {
+    type: "invalid";
+    message?: string | null | undefined;
+    suppressAlmostThere?: boolean | null | undefined;
+} | {
+    type: "points";
+    earned: number;
+    total: number;
+    message?: string | null | undefined;
+};
+export type KEScore = {
+    empty: boolean;
+    correct: boolean;
+    message?: string | null | undefined;
+    suppressAlmostThere?: boolean | null | undefined;
+    guess: any;
+    state: any;
+};
+export type Hint = {
+    widgets: WidgetDict;
+    content: string;
+    images: ImageDict;
+    replace?: boolean;
+};
+export type Version = {
+    major: number;
+    minor: number;
+};
+export type EditorMode = "edit" | "preview" | "json";
+export type ChoiceState = {
+    selected: boolean;
+    crossedOut: boolean;
+    highlighted: boolean;
+    rationaleShown: boolean;
+    correctnessShown: boolean;
+    previouslyAnswered: boolean;
+    readOnly: boolean;
+};
+export type ChangeHandler = (arg1: {
+    hints?: ReadonlyArray<Hint>;
+    replace?: boolean;
+    content?: string;
+    widgets?: WidgetDict;
+    images?: ImageDict;
+    question?: any;
+    answerArea?: any;
+    itemDataVersion?: Version;
+    item?: Item;
+    editorMode?: EditorMode;
+    jsonMode?: boolean;
+    value?: any;
+    choiceStates?: ReadonlyArray<ChoiceState>;
+    currentValue?: string;
+    selected?: number;
+    tools?: ReadonlyArray<any>;
+    transformations?: ReadonlyArray<any>;
+    highlights?: SerializedHighlightSet;
+    plot?: any;
+}, callback?: () => unknown | null | undefined, silent?: boolean) => unknown;
+export type ImageUploader = (file: string, callback: (url: string) => unknown) => unknown;
+export type WidgetSize = "normal" | "small" | "mini";
+export type Path = ReadonlyArray<string>;
+type StubTagEditorType = any;
+export type APIOptions = Readonly<{
+    isArticle?: boolean;
+    onInputError?: (widgetId: any, value: string, message?: string | null | undefined) => unknown;
+    onFocusChange?: (newFocusPath: FocusPath, oldFocusPath: FocusPath, keypadElement?: HTMLElement, focusedElement?: HTMLElement) => unknown;
+    GroupMetadataEditor?: React.ComponentType<StubTagEditorType>;
+    showAlignmentOptions?: boolean;
+    readOnly?: boolean;
+    answerableCallback?: (arg1: boolean) => unknown;
+    getAnotherHint?: () => unknown;
+    interactionCallback?: () => unknown;
+    groupAnnotator?: (groupNumber: number, widgetId: string) => React.ReactNode;
+    imagePlaceholder?: React.ReactNode;
+    widgetPlaceholder?: React.ReactNode;
+    baseElements?: {
+        Link: React.ComponentType<any>;
+    };
+    imagePreloader?: (dimensions: Dimensions) => React.ReactNode;
+    trackInteraction?: () => unknown;
+    customKeypad?: boolean;
+    nativeKeypadProxy?: () => unknown;
+    isMobile?: boolean;
+    setDrawingAreaAvailable?: (arg1: boolean) => unknown;
+    useDraftEditor?: boolean;
+    hintProgressColor?: string;
+    canScrollPage?: boolean;
+    inModal?: boolean;
+    crossOutEnabled?: boolean;
+    editorChangeDelay?: number;
+}>;
+type TeXProps = {
+    children: string;
+    katexOptions?: any;
+    onClick?: () => unknown;
+    onRender?: (root?: any) => unknown;
+    style?: any;
+};
+export type DomInsertCheckFn = (text: string, node: HTMLElement, attribute?: string, jiptString?: string) => string | false;
+export type JIPT = {
+    useJIPT: boolean;
+};
+export type JiptLabelStore = {
+    addLabel: (label?: any, useMath?: any) => void;
+};
+export interface JiptRenderer {
+    replaceJiptContent: (content: string, paragraphIndex: number) => void;
+}
+export type JiptTranslationComponents = {
+    addComponent: (renderer: JiptRenderer) => number;
+    removeComponentAtIndex: (index: number) => void;
+};
+export type VideoData = {
+    __typename: "Video";
+    id: string;
+    title: string | null | undefined;
+    /**
+     * Unique identifier on YouTube.
+     * If this is a dubbed video, this is always the original English version on
+     * YouTube. If the localized version is needed, use translatedYoutubeId.
+     * Example: KL6sMOn7ULo
+     */
+    youtubeId: string | null | undefined;
+    contentId: string | null | undefined;
+};
+interface StaticUrlFn {
+    (maybeRelativeUrl: string): string;
+    (maybeRelativeUrl?: undefined | null | undefined): undefined | null | undefined;
+}
+type InitialRequestUrlInterface = {
+    origin: string;
+    host: string;
+    protocol: string;
+};
+export type VideoKind = "YOUTUBE_ID" | "READABLE_ID";
+export type PerseusDependencies = {
+    JIPT: JIPT;
+    graphieMovablesJiptLabels: JiptLabelStore;
+    svgImageJiptLabels: JiptLabelStore;
+    rendererTranslationComponents: JiptTranslationComponents;
+    getKaTeX: () => Promise<katex>;
+    getRenderA11yString: () => Promise<katexA11y>;
+    loadMathjax: () => Promise<unknown>;
+    logKaTeXError: (expression: string, error: Error) => Promise<Response | null | undefined>;
+    KatexProvider: React.ComponentType<{
+        children: React.ReactNode;
+    }>;
+    shouldUseFutureKaTeX: (flag: boolean) => void;
+    TeX: React.ComponentType<TeXProps>;
+    staticUrl: StaticUrlFn;
+    InitialRequestUrl: InitialRequestUrlInterface;
+    useVideo(id: string, kind: VideoKind): Result<{
+        video: VideoData | null | undefined;
+    }>;
+    Log: ILogger;
+    isDevServer: boolean;
+    kaLocale: string;
+    isMobile: boolean;
+};
+export type APIOptionsWithDefaults = Readonly<APIOptions & {
+    GroupMetadataEditor: NonNullable<APIOptions["GroupMetadataEditor"]>;
+    baseElements: NonNullable<APIOptions["baseElements"]>;
+    canScrollPage: NonNullable<APIOptions["canScrollPage"]>;
+    crossOutEnabled: NonNullable<APIOptions["crossOutEnabled"]>;
+    editorChangeDelay: NonNullable<APIOptions["editorChangeDelay"]>;
+    groupAnnotator: NonNullable<APIOptions["groupAnnotator"]>;
+    inModal: NonNullable<APIOptions["inModal"]>;
+    isArticle: NonNullable<APIOptions["isArticle"]>;
+    isMobile: NonNullable<APIOptions["isMobile"]>;
+    onFocusChange: NonNullable<APIOptions["onFocusChange"]>;
+    onInputError: NonNullable<APIOptions["onInputError"]>;
+    readOnly: NonNullable<APIOptions["readOnly"]>;
+    setDrawingAreaAvailable: NonNullable<APIOptions["setDrawingAreaAvailable"]>;
+    showAlignmentOptions: NonNullable<APIOptions["showAlignmentOptions"]>;
+    useDraftEditor: NonNullable<APIOptions["useDraftEditor"]>;
+}>;
+export type LinterContextProps = {
+    contentType: string;
+    highlightLint: boolean;
+    paths: ReadonlyArray<string>;
+    stack: ReadonlyArray<string>;
+};
+export type Tracking = "" | "all";
+export type Alignment = "default" | "block" | "inline-block" | "inline" | "float-left" | "float-right" | "full-width";
+type WidgetOptions = any;
+export type WidgetTransform = (arg1: WidgetOptions, problemNumber?: number) => any;
+export type WidgetExports<T extends React.ComponentType<any> = React.ComponentType<any>> = Readonly<{
+    name: string;
+    displayName: string;
+    getWidget?: () => T;
+    accessible?: boolean | ((props: any) => boolean);
+    hidden?: boolean;
+    version?: Version;
+    supportedAlignments?: ReadonlyArray<Alignment>;
+    defaultAlignment?: Alignment;
+    getDefaultAlignment?: () => Alignment;
+    isLintable?: boolean;
+    transform?: WidgetTransform;
+    tracking?: Tracking;
+    staticTransform?: WidgetTransform;
+    traverseChildWidgets?: any;
+    propUpgrades?: {
+        [key: string]: (arg1: any) => any;
+    };
+    widget: T;
+}>;
+export type WidgetInfo = PerseusWidget;
+export type FilterCriterion = string | ((id: string, widgetInfo: WidgetInfo, widget?: Widget | null | undefined) => boolean);
+export type WidgetProps<RenderProps, Rubric> = RenderProps & {
+    widgetId: string;
+    alignment: string | null | undefined;
+    static: boolean | null | undefined;
+    problemNum: number | null | undefined;
+    apiOptions: APIOptionsWithDefaults;
+    keypadElement?: any;
+    questionCompleted?: boolean;
+    onFocus: (blurPath: FocusPath) => void;
+    onBlur: (blurPath: FocusPath) => void;
+    findWidgets: (arg1: FilterCriterion) => ReadonlyArray<Widget>;
+    reviewModeRubric: Rubric;
+    onChange: ChangeHandler;
+    trackInteraction: (extraData?: any) => void;
+    isLastUsedWidget: boolean;
+    linterContext: LinterContextProps;
+    containerSizeClass: SizeClass;
+};
+export type ChangeFn = (newPropsOrSinglePropName: string | {
+    [key: string]: any;
+}, propValue?: any, callback?: () => unknown) => any | null | undefined;
+export {};

package/dist/types.js.flow

@@ -0,0 +1,337 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import katex from "katex";
+import katexA11y from "katex/dist/contrib/render-a11y-string";
+import * as React from "react";
+import type { SerializedHighlightSet } from "./components/highlighting/types";
+import type { ILogger } from "./logging/log";
+import type { Item } from "./multi-items/item-types";
+import type { PerseusWidget } from "./perseus-types";
+import type { SizeClass } from "./util/sizing-utils";
+import type { Result } from "@khanacademy/wonder-blocks-data";
+export type FocusPath = $ReadOnlyArray<string> | null | void;
+declare type State = any;
+export interface RendererInterface {
+  getSerializedState(): State;
+  restoreSerializedState(state: State, callback?: () => void): void;
+  scoreInput(): KEScore;
+  blur(): void;
+  focus(): boolean | null | void;
+  props: any;
+}
+export type Dimensions = {|
+  width?: number,
+  height?: number,
+|};
+export type DeviceType = "phone" | "tablet" | "desktop";
+export type Widget = any;
+export type WidgetDict = {
+  [name: string]: Widget,
+};
+export type ImageDict = {
+  [url: string]: Dimensions,
+};
+export type PerseusScore =
+  | {|
+      type: "invalid",
+      message?: string | null | void,
+      suppressAlmostThere?: boolean | null | void,
+    |}
+  | {|
+      type: "points",
+      earned: number,
+      total: number,
+      message?: string | null | void,
+    |};
+export type KEScore = {|
+  empty: boolean,
+  correct: boolean,
+  message?: string | null | void,
+  suppressAlmostThere?: boolean | null | void,
+  guess: any,
+  state: any,
+|};
+export type Hint = {|
+  widgets: WidgetDict,
+  content: string,
+  images: ImageDict,
+  replace?: boolean,
+|};
+export type Version = {|
+  major: number,
+  minor: number,
+|};
+export type EditorMode = "edit" | "preview" | "json";
+export type ChoiceState = {|
+  selected: boolean,
+  crossedOut: boolean,
+  highlighted: boolean,
+  rationaleShown: boolean,
+  correctnessShown: boolean,
+  previouslyAnswered: boolean,
+  readOnly: boolean,
+|};
+export type ChangeHandler = (
+  arg1: {|
+    hints?: $ReadOnlyArray<Hint>,
+    replace?: boolean,
+    content?: string,
+    widgets?: WidgetDict,
+    images?: ImageDict,
+    question?: any,
+    answerArea?: any,
+    itemDataVersion?: Version,
+    item?: Item,
+    editorMode?: EditorMode,
+    jsonMode?: boolean,
+    value?: any,
+    choiceStates?: $ReadOnlyArray<ChoiceState>,
+    currentValue?: string,
+    selected?: number,
+    tools?: $ReadOnlyArray<any>,
+    transformations?: $ReadOnlyArray<any>,
+    highlights?: SerializedHighlightSet,
+    plot?: any,
+  |},
+  callback?: () => mixed | null | void,
+  silent?: boolean
+) => mixed;
+export type ImageUploader = (
+  file: string,
+  callback: (url: string) => mixed
+) => mixed;
+export type WidgetSize = "normal" | "small" | "mini";
+export type Path = $ReadOnlyArray<string>;
+declare type StubTagEditorType = any;
+export type APIOptions = $ReadOnly<{|
+  isArticle?: boolean,
+  onInputError?: (
+    widgetId: any,
+    value: string,
+    message?: string | null | void
+  ) => mixed,
+  onFocusChange?: (
+    newFocusPath: FocusPath,
+    oldFocusPath: FocusPath,
+    keypadElement?: HTMLElement,
+    focusedElement?: HTMLElement
+  ) => mixed,
+  GroupMetadataEditor?: React.ComponentType<StubTagEditorType>,
+  showAlignmentOptions?: boolean,
+  readOnly?: boolean,
+  answerableCallback?: (arg1: boolean) => mixed,
+  getAnotherHint?: () => mixed,
+  interactionCallback?: () => mixed,
+  groupAnnotator?: (groupNumber: number, widgetId: string) => React.Node,
+  imagePlaceholder?: React.Node,
+  widgetPlaceholder?: React.Node,
+  baseElements?: {|
+    Link: React.ComponentType<any>,
+  |},
+  imagePreloader?: (dimensions: Dimensions) => React.Node,
+  trackInteraction?: () => mixed,
+  customKeypad?: boolean,
+  nativeKeypadProxy?: () => mixed,
+  isMobile?: boolean,
+  setDrawingAreaAvailable?: (arg1: boolean) => mixed,
+  useDraftEditor?: boolean,
+  hintProgressColor?: string,
+  canScrollPage?: boolean,
+  inModal?: boolean,
+  crossOutEnabled?: boolean,
+  editorChangeDelay?: number,
+|}>;
+declare type TeXProps = {|
+  children: string,
+  katexOptions?: any,
+  onClick?: () => mixed,
+  onRender?: (root?: any) => mixed,
+  style?: any,
+|};
+export type DomInsertCheckFn = (
+  text: string,
+  node: HTMLElement,
+  attribute?: string,
+  jiptString?: string
+) => string | false;
+export type JIPT = {|
+  useJIPT: boolean,
+|};
+export type JiptLabelStore = {|
+  addLabel: (label?: any, useMath?: any) => void,
+|};
+export interface JiptRenderer {
+  replaceJiptContent: (content: string, paragraphIndex: number) => void;
+}
+export type JiptTranslationComponents = {|
+  addComponent: (renderer: JiptRenderer) => number,
+  removeComponentAtIndex: (index: number) => void,
+|};
+export type VideoData = {|
+  __typename: "Video",
+  id: string,
+  title: string | null | void,
+
+  /**
+   * Unique identifier on YouTube.
+   * If this is a dubbed video, this is always the original English version on
+   * YouTube. If the localized version is needed, use translatedYoutubeId.
+   * Example: KL6sMOn7ULo
+   */
+  youtubeId: string | null | void,
+  contentId: string | null | void,
+|};
+declare interface StaticUrlFn {
+  (maybeRelativeUrl: string): string;
+  (maybeRelativeUrl?: void | null | void): void | null | void;
+}
+declare type InitialRequestUrlInterface = {|
+  origin: string,
+  host: string,
+  protocol: string,
+|};
+export type VideoKind = "YOUTUBE_ID" | "READABLE_ID";
+export type PerseusDependencies = {|
+  JIPT: JIPT,
+  graphieMovablesJiptLabels: JiptLabelStore,
+  svgImageJiptLabels: JiptLabelStore,
+  rendererTranslationComponents: JiptTranslationComponents,
+  getKaTeX: () => Promise<katex>,
+  getRenderA11yString: () => Promise<katexA11y>,
+  loadMathjax: () => Promise<mixed>,
+  logKaTeXError: (
+    expression: string,
+    error: Error
+  ) => Promise<Response | null | void>,
+  KatexProvider: React.ComponentType<{|
+    children: React.Node,
+  |}>,
+  shouldUseFutureKaTeX: (flag: boolean) => void,
+  TeX: React.ComponentType<TeXProps>,
+  staticUrl: StaticUrlFn,
+  InitialRequestUrl: InitialRequestUrlInterface,
+  useVideo(
+    id: string,
+    kind: VideoKind
+  ): Result<{|
+    video: VideoData | null | void,
+  |}>,
+  Log: ILogger,
+  isDevServer: boolean,
+  kaLocale: string,
+  isMobile: boolean,
+|};
+export type APIOptionsWithDefaults = $ReadOnly<{|
+  ...APIOptions,
+  ...{|
+    GroupMetadataEditor: $NonMaybeType<
+      $PropertyType<APIOptions, "GroupMetadataEditor">
+    >,
+    baseElements: $NonMaybeType<$PropertyType<APIOptions, "baseElements">>,
+    canScrollPage: $NonMaybeType<$PropertyType<APIOptions, "canScrollPage">>,
+    crossOutEnabled: $NonMaybeType<
+      $PropertyType<APIOptions, "crossOutEnabled">
+    >,
+    editorChangeDelay: $NonMaybeType<
+      $PropertyType<APIOptions, "editorChangeDelay">
+    >,
+    groupAnnotator: $NonMaybeType<$PropertyType<APIOptions, "groupAnnotator">>,
+    inModal: $NonMaybeType<$PropertyType<APIOptions, "inModal">>,
+    isArticle: $NonMaybeType<$PropertyType<APIOptions, "isArticle">>,
+    isMobile: $NonMaybeType<$PropertyType<APIOptions, "isMobile">>,
+    onFocusChange: $NonMaybeType<$PropertyType<APIOptions, "onFocusChange">>,
+    onInputError: $NonMaybeType<$PropertyType<APIOptions, "onInputError">>,
+    readOnly: $NonMaybeType<$PropertyType<APIOptions, "readOnly">>,
+    setDrawingAreaAvailable: $NonMaybeType<
+      $PropertyType<APIOptions, "setDrawingAreaAvailable">
+    >,
+    showAlignmentOptions: $NonMaybeType<
+      $PropertyType<APIOptions, "showAlignmentOptions">
+    >,
+    useDraftEditor: $NonMaybeType<$PropertyType<APIOptions, "useDraftEditor">>,
+  |},
+|}>;
+export type LinterContextProps = {|
+  contentType: string,
+  highlightLint: boolean,
+  paths: $ReadOnlyArray<string>,
+  stack: $ReadOnlyArray<string>,
+|};
+export type Tracking = "" | "all";
+export type Alignment =
+  | "default"
+  | "block"
+  | "inline-block"
+  | "inline"
+  | "float-left"
+  | "float-right"
+  | "full-width";
+declare type WidgetOptions = any;
+export type WidgetTransform = (
+  arg1: WidgetOptions,
+  problemNumber?: number
+) => any;
+export type WidgetExports<
+  T: React.ComponentType<any> = React.ComponentType<any>
+> = $ReadOnly<{|
+  name: string,
+  displayName: string,
+  getWidget?: () => T,
+  accessible?: boolean | ((props: any) => boolean),
+  hidden?: boolean,
+  version?: Version,
+  supportedAlignments?: $ReadOnlyArray<Alignment>,
+  defaultAlignment?: Alignment,
+  getDefaultAlignment?: () => Alignment,
+  isLintable?: boolean,
+  transform?: WidgetTransform,
+  tracking?: Tracking,
+  staticTransform?: WidgetTransform,
+  traverseChildWidgets?: any,
+  propUpgrades?: {
+    [key: string]: (arg1: any) => any,
+  },
+  widget: T,
+|}>;
+export type WidgetInfo = PerseusWidget;
+export type FilterCriterion =
+  | string
+  | ((
+      id: string,
+      widgetInfo: WidgetInfo,
+      widget?: Widget | null | void
+    ) => boolean);
+export type WidgetProps<RenderProps, Rubric> = {|
+  ...RenderProps,
+  ...{|
+    widgetId: string,
+    alignment: string | null | void,
+    static: boolean | null | void,
+    problemNum: number | null | void,
+    apiOptions: APIOptionsWithDefaults,
+    keypadElement?: any,
+    questionCompleted?: boolean,
+    onFocus: (blurPath: FocusPath) => void,
+    onBlur: (blurPath: FocusPath) => void,
+    findWidgets: (arg1: FilterCriterion) => $ReadOnlyArray<Widget>,
+    reviewModeRubric: Rubric,
+    onChange: ChangeHandler,
+    trackInteraction: (extraData?: any) => void,
+    isLastUsedWidget: boolean,
+    linterContext: LinterContextProps,
+    containerSizeClass: SizeClass,
+  |},
+|};
+export type ChangeFn = (
+  newPropsOrSinglePropName:
+    | string
+    | {
+        [key: string]: any,
+      },
+  propValue?: any,
+  callback?: () => mixed
+) => any | null | void;

package/dist/util/a11y.d.ts

@@ -0,0 +1,3 @@
+import type { StyleDeclaration } from "aphrodite";
+declare const _default: StyleDeclaration;
+export default _default;

package/dist/util/a11y.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import type { StyleDeclaration } from "aphrodite";
+declare var _default: StyleDeclaration;
+declare export default typeof _default;

package/dist/util/answer-types.d.ts

@@ -0,0 +1,34 @@
+type Guess = any;
+type Predicate = any;
+type Score = {
+    empty: boolean;
+    correct: boolean;
+    message: string | null | undefined;
+    suppressAlmostThere?: boolean | null | undefined;
+    guess: Guess;
+    ungraded?: boolean;
+};
+export declare const errors: {
+    readonly APPROXIMATED_PI_ERROR: string;
+    readonly EXTRA_SYMBOLS_ERROR: string;
+    readonly NEEDS_TO_BE_SIMPLFIED_ERROR: string;
+    readonly MISSING_PERCENT_ERROR: string;
+    readonly MULTIPLICATION_SIGN_ERROR: string;
+    readonly WRONG_CASE_ERROR: string;
+    readonly WRONG_LETTER_ERROR: string;
+};
+declare const KhanAnswerTypes: {
+    readonly predicate: {
+        readonly defaultForms: "integer, proper, improper, mixed, decimal";
+        readonly createValidatorFunctional: (predicate: Predicate, options: any) => (arg1: Guess) => Score;
+    };
+    readonly number: {
+        readonly convertToPredicate: (correctAnswer: string, options: any) => Predicate;
+        readonly createValidatorFunctional: (correctAnswer: string, options: any) => (arg1: Guess) => Score;
+    };
+    readonly expression: {
+        readonly parseSolution: (solutionString: string, options: any) => any;
+        readonly createValidatorFunctional: (solution: any, options: any) => (arg1: Guess) => Score;
+    };
+};
+export default KhanAnswerTypes;

package/dist/util/answer-types.js.flow

@@ -0,0 +1,49 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+declare type Guess = any;
+declare type Predicate = any;
+declare type Score = {|
+  empty: boolean,
+  correct: boolean,
+  message: string | null | void,
+  suppressAlmostThere?: boolean | null | void,
+  guess: Guess,
+  ungraded?: boolean,
+|};
+declare export var errors: {|
+  +APPROXIMATED_PI_ERROR: string,
+  +EXTRA_SYMBOLS_ERROR: string,
+  +NEEDS_TO_BE_SIMPLFIED_ERROR: string,
+  +MISSING_PERCENT_ERROR: string,
+  +MULTIPLICATION_SIGN_ERROR: string,
+  +WRONG_CASE_ERROR: string,
+  +WRONG_LETTER_ERROR: string,
+|};
+declare var KhanAnswerTypes: {|
+  +predicate: {|
+    +defaultForms: "integer, proper, improper, mixed, decimal",
+    +createValidatorFunctional: (
+      predicate: Predicate,
+      options: any
+    ) => (arg1: Guess) => Score,
+  |},
+  +number: {|
+    +convertToPredicate: (correctAnswer: string, options: any) => Predicate,
+    +createValidatorFunctional: (
+      correctAnswer: string,
+      options: any
+    ) => (arg1: Guess) => Score,
+  |},
+  +expression: {|
+    +parseSolution: (solutionString: string, options: any) => any,
+    +createValidatorFunctional: (
+      solution: any,
+      options: any
+    ) => (arg1: Guess) => Score,
+  |},
+|};
+declare export default typeof KhanAnswerTypes;