@khanacademy/perseus 7.2.1 → 8.0.0

package/dist/multi-items/multi-renderer.js.flow

@@ -1,213 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import * as React from "react";
-import Renderer from "../renderer";
-import type { Widget } from "../renderer";
-import type { APIOptions, FilterCriterion } from "../types";
-import type { Item, ContentNode, HintNode, TagsNode } from "./item-types";
-import type { Shape, ArrayShape } from "./shape-types";
-import type { Tree } from "./tree-types";
-import type { TreeMapper, ContentMapper, HintMapper, Path } from "./trees";
-declare type Hint = any;
-declare type Score = any;
-declare type SerializedState = any;
-declare type RendererProps = React.ElementConfig<typeof Renderer>;
-declare type ContentRendererElement = React.Element<any>;
-declare type HintRendererElement = React.Element<any>;
-declare type ContentRendererData = {|
-  makeRenderer: () => ContentRendererElement,
-  ref: Renderer | null | void,
-|};
-declare type FindWidgetsFunc = (
-  criterion: FilterCriterion
-) => $ReadOnlyArray<Widget | null | void>;
-declare type HintRendererData = {|
-  makeRenderer: () => HintRendererElement,
-  findExternalWidgets: FindWidgetsFunc | null | void,
-  ref: null,
-  hint: Hint,
-|};
-declare type RendererData = ContentRendererData | HintRendererData;
-declare type RendererDataTree = Tree<
-  ContentRendererData,
-  HintRendererData,
-  null
->;
-/**
- * TODO(somewhatabstract, JIRA-XXXX):
- * Some usage of this type somewhere is causing TypeScript to believe that these
- * elements should be components. Don't know where that is, to fix it up
- * properly. In reality, these types are just too hard to use and aren't
- * really helping us out as I now have to suppress this rather than
- * get value from the type. :(
- */
-declare type RendererTree = Tree<
-  ContentRendererElement,
-  HintRendererElement,
-  null
->;
-declare type ScoreTree = Tree<Score, null, null>;
-declare type SerializedStateTree = Tree<SerializedState, null, null>;
-declare type Props = {|
-  item: Item,
-  shape: Shape,
-  children: (tree: {|
-    renderers: RendererTree,
-  |}) => React.Element<any>,
-  serializedState?: SerializedStateTree | null | void,
-  onSerializedStateUpdated?: (state: SerializedStateTree) => void,
-  onInteractWithWidget?: (id: string) => void,
-  apiOptions?: APIOptions,
-  reviewMode?: boolean | null | void,
-|};
-declare type State = {|
-  rendererDataTree: RendererDataTree | null | void,
-  renderError: Error | null | void,
-|};
-declare class MultiRenderer extends React.Component<Props, State> {
-  rendererDataTreeMapper: TreeMapper<
-    ContentNode,
-    ContentRendererData,
-    HintNode,
-    HintRendererData,
-    TagsNode,
-    null
-  >;
-  getRenderersMapper: TreeMapper<
-    ContentRendererData,
-    ContentRendererElement,
-    HintRendererData,
-    HintRendererElement,
-    null,
-    null
-  >;
-  constructor(props: Props): this;
-  UNSAFE_componentWillReceiveProps(nextProps: Props): void;
-
-  /**
-   * Attempt to build a State that includes a renderer tree corresponding to
-   * the item provided in props. On error, return a state with `renderError`
-   * set instead.
-   */
-  _tryMakeRendererState(props: Props): State;
-  _handleSerializedStateUpdated: (path: Path, newState?: any) => void;
-
-  /**
-   * Props that aren't directly used by the MultiRenderer are delegated to
-   * the underlying Renderers.
-   */
-  _getRendererProps(): RendererProps;
-
-  /**
-   * Construct a Renderer and a ref placeholder for the given ContentNode.
-   */
-  _makeContentRendererData(
-    content: ContentNode,
-    path: Path
-  ): ContentRendererData;
-
-  /**
-   * Construct a Renderer for the given HintNode, and keep track of the hint
-   * itself for future use, too.
-   */
-  _makeHintRendererData(hint: HintNode): HintRendererData;
-
-  /**
-   * Construct a tree of interconnected RendererDatas, corresponding to the
-   * given item. Called in `_tryMakeRendererState`, in order to store this
-   * tree in the component state.
-   */
-  _makeRendererDataTree(item: Item, shape: Shape): RendererDataTree;
-
-  /**
-   * Return all widgets that meet the given criterion, from all Renderers
-   * except the Renderer that triggered this call.
-   *
-   * This function is provided to each Renderer's `findExternalWidgets` prop,
-   * which enables widgets in different Renderers to discover each other and
-   * communicate.
-   */
-  _findWidgets(
-    callingData: RendererData,
-    filterCriterion: FilterCriterion
-  ): $ReadOnlyArray<Widget | null | void>;
-
-  /**
-   * Copy the renderer tree, apply the given transformation to the leaf nodes
-   * and the optional given transformation to the array nodes, and return the
-   * result.
-   *
-   * Used to provide structured data to the call site (the Renderer tree on
-   * `render`, the Score tree on `getScores`, etc.), and to traverse the
-   * renderer tree even when we disregard the output (like in
-   * `_findWidgets`).
-   */
-  _mapRenderers<O>(leafMapper: {|
-    ...ContentMapper<RendererData, O>,
-    ...HintMapper<RendererData, O>,
-  |}): Tree<O, O, null> | null | void;
-  _scoreFromRef(ref?: Renderer | null): Score;
-
-  /**
-   * Return a tree in the shape of the multi-item, with scores at each of
-   * the content nodes and `null` at the other leaf nodes.
-   */
-  getScores(): ScoreTree;
-
-  /**
-   * Return a single composite score for all rendered content nodes.
-   * The `guess` is a tree in the shape of the multi-item, with an individual
-   * guess at each content node and `null` at the other leaf nodes.
-   */
-  score(): Score;
-
-  /**
-   * Return a tree in the shape of the multi-item, with serialized state at
-   * each of the content nodes and `null` at the other leaf nodes.
-   *
-   * If the lastSerializedState argument is supplied, this function will fill
-   * in the state of not-currently-rendered content and hint nodes with the
-   * values from the previous serialized state. If no lastSerializedState is
-   * supplied, `null` will be returned for not-currently-rendered content and
-   * hint nodes.
-   */
-  _getSerializedState(
-    lastSerializedState?: SerializedStateTree
-  ): SerializedStateTree;
-
-  /**
-   * Given a tree in the shape of the multi-item, with serialized state at
-   * each of the content nodes, restore each state to the corresponding
-   * renderer if currently mounted.
-   */
-  restoreSerializedState(
-    serializedState: SerializedState,
-    callback?: () => any
-  ): void;
-
-  /**
-   * Given an array of renderers, if it happens to be an array of *hint*
-   * renderers, then attach a `firstN` method to the array, which allows the
-   * layout to render the hints together in one HintsRenderer.
-   */
-  _annotateRendererArray(
-    renderers: $ReadOnlyArray<Renderer>,
-    rendererDatas: $ReadOnlyArray<RendererData>,
-    shape: ArrayShape
-  ): $ReadOnlyArray<Renderer>;
-
-  /**
-   * Return a tree in the shape of the multi-item, with a Renderer at each
-   * content node and a HintRenderer at each hint node.
-   *
-   * This is generated by running each of the `makeRenderer` functions at the
-   * leaf nodes.
-   */
-  _getRenderers(): RendererTree;
-  render(): React.Node;
-}
-declare export default typeof MultiRenderer;

package/dist/multi-items/prop-type-builders.js.flow

@@ -1,22 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { Shape } from "./shape-types";
-
-/**
- * A recursive PropType that accepts Shape objects, and rejects other objects.
- *
- * Usage: `propTypes: {shape: shapePropType}`.
- */
-declare export function shapePropType(...args: $ReadOnlyArray<any>): any;
-
-/**
- * Return a PropType that accepts Items of the given shape, and rejects other
- * objects.
- *
- * Usage: `propTypes: {item: buildPropTypeForShape(myShape)}`
- */
-declare export function buildPropTypeForShape(shape: Shape): any;

package/dist/multi-items/shape-types.js.flow

@@ -1,60 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-/**
- * Type definitions for multi-item shapes.
- *
- * A shape is an object that serves as a runtime type declaration: it specifies
- * a tree structure for a particular class of multi-item.
- *
- * We use shapes instead static compile-time typing because the CMS needs to
- * understand the shape of our content library's multi-items at runtime, and
- * it's not always possible to infer the full shape from an example multi-item.
- *
- * Shapes also enable us to traverse a multi-item-shaped tree with confidence,
- * even when we can't infer the shape from the tree alone.
- *
- * We *could* go all-in on a more general library to make certain types
- * runtime-inspectable, in order to DRY some things up, but that's probably a
- * big ol' infrastructural magic mess, and the narrower scope of Shapes makes
- * it easier to be confident that we've covered all cases rather than having to
- * deal with all possible Javascript types.
- */
-export type ContentShape = {|
-  type: "content",
-|};
-export type HintShape = {|
-  type: "hint",
-|};
-export type TagsShape = {|
-  type: "tags",
-|};
-export type ArrayShape = {|
-  type: "array",
-
-  /**
-   * Each element of an ArrayNode has the same shape, which is specified by
-   * the `elementShape` property.
-   */
-  elementShape: Shape,
-|};
-export type ObjectShape = {|
-  type: "object",
-
-  /**
-   * Each property of an ObjectNode has its own shape, which is specified
-   * under the corresponding key in the `shape` property.
-   */
-  shape: {
-    [k: string]: Shape,
-  },
-|};
-export type Shape =
-  | ContentShape
-  | HintShape
-  | TagsShape
-  | ArrayShape
-  | ObjectShape;

package/dist/multi-items/shapes.js.flow

@@ -1,25 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type {
-  Shape,
-  ContentShape,
-  HintShape,
-  TagsShape,
-  ArrayShape,
-  ObjectShape,
-} from "./shape-types";
-declare var _default: {|
-  content: ContentShape,
-  hint: HintShape,
-  hints: ArrayShape,
-  tags: TagsShape,
-  arrayOf: (elementShape: Shape) => ArrayShape,
-  shape: (shape: {
-    [k: string]: Shape,
-  }) => ObjectShape,
-|};
-declare export default typeof _default;

package/dist/multi-items/tree-types.js.flow

@@ -1,45 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-/**
- * Type definitions for generic trees that are shaped like multi-items.
- *
- * Multi-items are trees! But we also often have other trees that are shaped
- * like multi-items - for example, if we map a multi-item tree into a tree of
- * renderer info and state, and then map that again into a tree of just the
- * renderer nodes, like we do in MultiRenderer.
- *
- * Therefore, we provide the type Tree<C, H>, which represents a tree that's
- * shaped like a multi-item, but the data that lives at each type of leaf could
- * be anything.
- *
- * So, in a Tree<C, H>, content leaf nodes have type C, and hint leaf nodes
- * have type H. An ItemTree is a Tree<ContentNode, HintNode>.
- *
- * That is, we still preserve the distinction between node types, and thereby
- * enforce the Tree's adherence to some multi-item Shape, but we're flexible
- * about exactly what type of data the tree contains at its leaves.
- *
- * This enables us to write generic tree-traversal and tree-mapping functions,
- * as you'll see in trees.js.
- */
-export type ArrayNode<C, H, T> = Tree<C, H, T>;
-export type ObjectNode<C, H, T> = {
-  [k: string]: Tree<C, H, T>,
-};
-/**
- * TODO(somewhatabstract, JIRA-XXXX):
- * We should ditch this type or create some helpers for working with it.
- * As it stands, consumers have to check each node's type before using it
- * in order to ensure that TypeScript can track its refinement and appropriate use.
- * It's messy.
- */
-export type Tree<C, H, T> =
-  | C
-  | H
-  | T
-  | ArrayNode<C, H, T>
-  | ObjectNode<C, H, T>;

package/dist/multi-items/trees.js.flow

@@ -1,147 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type {
-  Shape,
-  ContentShape,
-  HintShape,
-  TagsShape,
-  ArrayShape,
-} from "./shape-types";
-import type { Tree, ArrayNode } from "./tree-types";
-
-/**
- * The sequence of edges that lead to a particular node in a Tree.
- * Elements can be `string` to correspond to an ObjectNode key, or `number` to
- * correspond to an ArrayNode index.
- */
-export type Path = $ReadOnlyArray<string | number>;
-/**
- * These are function interfaces for mapping over various types of tree nodes.
- *
- * ArrayMapper is a bit more complicated than the leaf node mappers. It's
- * executed in the context of a `mapTree` call, after we've finished mapping
- * its child nodes, so the function has access to both the resulting array
- * (with mapped elements) and the original array (with the original untouched
- * elements).
- *
- * The ArrayMapper then has the opportunity to apply a final transformation to
- * the resulting array, like filtering certain elements or (in the hacky
- * MultiRenderer case) attaching a `renderHints` method to arrays of hint
- * renderers :)
- *
- * This is why `TreeMapper#setArrayMapper` must be called last: ArrayMapper's
- * types depend on the ContentMapper and HintMapper's types. And, since you can
- * only specify one mapper at a time in this builder interface (which is
- * necessary to provide default mappers in a type-safe way), you need your
- * dependencies to already be in place by the time you call `setArrayMapper`.
- * Otherwise, we'd have to set the ArrayMapper and *hope* that you *eventually*
- * provide a compatible ContentMapper and HintMapper, which is difficult to
- * prove at compile time.
- *
- * There's no ObjectMapper here, but not for any particular reason. We just
- * don't have a use case for it yet, so we haven't built it yet.
- */
-export type ContentMapper<CI, CO> = (
-  content: CI,
-  shape: ContentShape,
-  path: Path
-) => CO;
-export type HintMapper<HI, HO> = (hint: HI, shape: HintShape, path: Path) => HO;
-export type TagsMapper<TI, TO> = (tag: TI, shape: TagsShape, path: Path) => TO;
-export type ArrayMapper<CI, CO, HI, HO, TI, TO> = (
-  mappedArray: ArrayNode<CO, HO, TO>,
-  originalArray: ArrayNode<CI, HI, TI>,
-  shape: ArrayShape,
-  path: Path
-) => ArrayNode<CO, HO, TO>;
-/**
- * A TreeMapper is a collection of node mappers, which, together, compose the
- * behavior for mapping over an entire tree.
- *
- * This serves as the interface for the two TreeMapper classes, including both
- * the internal mapper properties that we care about, and the `mapTree`
- * function that the call site will use.
- */
-export interface TreeMapper<CI, CO, HI, HO, TI, TO> {
-  content: ContentMapper<CI, CO>;
-  hint: HintMapper<HI, HO>;
-  tags: TagsMapper<TI, TO>;
-  array: ArrayMapper<CI, CO, HI, HO, TI, TO>;
-  mapTree(tree: Tree<CI, HI, TI>, shape: Shape): Tree<CO, HO, TO>;
-}
-/**
- * This is a TreeMapper that only has mappers specified for its leaf nodes; its
- * array mapper is the identity function.
- *
- * This is the TreeMapper initially returned by `buildMapper`. It allows you to
- * change the types of your ContentMapper and HintMapper, which is safe because
- * none of the other mappers that depend on those types (aka ArrayMapper) have
- * been specified yet. (Or, more specifically, the ArrayMapper is currently
- * `identity`, which can trivially vary with the ContentMapper and HintMapper's
- * types.)
- *
- * Once you call `setArrayMapper`, however, we move to the other class:
- * TreeMapperForLeavesAndCollections.
- */
-declare class TreeMapperJustForLeaves<CI, CO, HI, HO, TI, TO> {
-  content: ContentMapper<CI, CO>;
-  hint: HintMapper<HI, HO>;
-  tags: TagsMapper<TI, TO>;
-  array: ArrayMapper<CI, CO, HI, HO, TI, TO>;
-  constructor(
-    content: ContentMapper<CI, CO>,
-    hint: HintMapper<HI, HO>,
-    tags: TagsMapper<TI, TO>
-  ): this;
-  setContentMapper<CI2, CO2>(
-    newContentMapper: ContentMapper<CI2, CO2>
-  ): TreeMapperJustForLeaves<CI2, CO2, HI, HO, TI, TO>;
-  setHintMapper<HI2, HO2>(
-    newHintMapper: HintMapper<HI2, HO2>
-  ): TreeMapperJustForLeaves<CI, CO, HI2, HO2, TI, TO>;
-  setTagsMapper<TI2, TO2>(
-    newTagsMapper: TagsMapper<TI2, TO2>
-  ): TreeMapperJustForLeaves<CI, CO, HI, HO, TI2, TO2>;
-  setArrayMapper(
-    newArrayMapper: ArrayMapper<CI, CO, HI, HO, TI, TO>
-  ): TreeMapperForLeavesAndCollections<CI, CO, HI, HO, TI, TO>;
-  mapTree(tree: Tree<CI, HI, TI>, shape: Shape): Tree<CO, HO, TO>;
-}
-/**
- * This is a TreeMapper that already has an ArrayMapper specified, so its
- * ContentMapper and HintMapper are now locked in.
- */
-declare class TreeMapperForLeavesAndCollections<CI, CO, HI, HO, TI, TO> {
-  content: ContentMapper<CI, CO>;
-  hint: HintMapper<HI, HO>;
-  tags: TagsMapper<TI, TO>;
-  array: ArrayMapper<CI, CO, HI, HO, TI, TO>;
-  constructor(
-    content: ContentMapper<CI, CO>,
-    hint: HintMapper<HI, HO>,
-    tags: TagsMapper<TI, TO>,
-    array: ArrayMapper<CI, CO, HI, HO, TI, TO>
-  ): this;
-  setArrayMapper(
-    newArrayMapper: ArrayMapper<CI, CO, HI, HO, TI, TO>
-  ): TreeMapperForLeavesAndCollections<CI, CO, HI, HO, TI, TO>;
-  mapTree(tree: Tree<CI, HI, TI>, shape: Shape): Tree<CO, HO, TO>;
-}
-/**
- * Return a new TreeMapper that will perform a no-op transformation on an input
- * tree. To make it useful, chain any combination of `setContentMapper`,
- * `setHintMapper`, `setTagMapper`, and `setArrayMapper` to specify
- * transformations for the individual node types.
- */
-declare export function buildMapper<
-  C,
-  C,
-  H,
-  H,
-  T,
-  T
->(): TreeMapperJustForLeaves<C, C, H, H, T, T>;

package/dist/multi-items.js.flow

@@ -1,36 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import * as $Flowgen$Import$_2e_ from ".";
-import {
-  buildEmptyItemForShape,
-  findContentNodesInItem,
-  findHintNodesInItem,
-  inferItemShape,
-} from "./multi-items/items";
-import MultiRenderer from "./multi-items/multi-renderer";
-import { buildPropTypeForShape } from "./multi-items/prop-type-builders";
-declare var _default: {|
-  MultiRenderer: typeof MultiRenderer,
-  shapes: {|
-    content: $Flowgen$Import$_2e_.ContentShape,
-    hint: $Flowgen$Import$_2e_.HintShape,
-    hints: $Flowgen$Import$_2e_.ArrayShape,
-    tags: $Flowgen$Import$_2e_.TagsShape,
-    arrayOf: (
-      elementShape: $Flowgen$Import$_2e_.Shape
-    ) => $Flowgen$Import$_2e_.ArrayShape,
-    shape: (shape: {
-      [k: string]: $Flowgen$Import$_2e_.Shape,
-    }) => $Flowgen$Import$_2e_.ObjectShape,
-  |},
-  buildPropTypeForShape: typeof buildPropTypeForShape,
-  buildEmptyItemForShape: typeof buildEmptyItemForShape,
-  findContentNodesInItem: typeof findContentNodesInItem,
-  findHintNodesInItem: typeof findHintNodesInItem,
-  inferItemShape: typeof inferItemShape,
-|};
-declare export default typeof _default;