@khanacademy/perseus 2.1.0 → 4.0.0

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

@@ -0,0 +1,60 @@
+/**
+ * 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 Flow 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.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Utility functions for constructing and inferring 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. See shape-types.js
+ * for further discussion.
+ *
+ * This module allows you to construct arbitrary Shape trees, by combining
+ * leaf node shapes like `content` and `hint` into composite shapes like
+ * `arrayOf(shape({foo: content, bar: hint}))`.
+ */
+import type { Shape, ContentShape, HintShape, TagsShape, ArrayShape, ObjectShape } from "./shape-types";
+declare const _default: {
+    content: ContentShape;
+    hint: HintShape;
+    hints: ArrayShape;
+    tags: TagsShape;
+    arrayOf: (elementShape: Shape) => ArrayShape;
+    shape: (shape: {
+        [k: string]: Shape;
+    }) => ObjectShape;
+};
+export default _default;

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

@@ -0,0 +1,25 @@
+/**
+ * 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.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 flow 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/tree-types.js.flow

@@ -0,0 +1,45 @@
+/**
+ * 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 flow 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.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Utility functions for manipulating multi-item-shaped trees.
+ *
+ * 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. See tree-types.js for further
+ * discussion.
+ *
+ * These functions enable us to manipulate generic multi-item-shaped trees,
+ * regardless of what type of data they contain at their leaves. You can use
+ * the mapper functions to transform a tree into another tree of the same
+ * shape, or to discover all the nodes of a particular type.
+ *
+ * We expose two simple mapper functions (mapContentNodes and mapHintNodes),
+ * and also a more complex interface for creating a mapping over all of a
+ * tree's node types simultaneously:
+ *
+ * `buildMapper()` returns a TreeMapper object that allows you to build your
+ * mapper object one node type at a time. Then, you can execute your mapping by
+ * calling the `mapTree` method.
+ *
+ * For example:
+ *     const renderers = buildMapper()
+ *         .setContentMapper(this.renderContentNode)
+ *         .setHintMapper(this.renderHintNode)
+ *         .setTagsMapper(this.renderTagsNode)
+ *         .setArrayMapper(this.hideSkippedQuestions)
+ *         .mapTree(tree, shape);
+ *
+ * This will copy the given tree, apply the given transformations to the
+ * content, hint, and array nodes respectively, and return the resulting tree.
+ *
+ * For node types whose mappers aren't specified, we default to the identity
+ * function. (This builder interface enables us to implement that default
+ * behavior in a provably type-safe way, while not requiring the call site to
+ * be aware of all the node types. Hooray!)
+ *
+ * The call to `setArrayMapper` must come last, because the array mapper's
+ * argument types depend on the other mappers' types. See ArrayMapper for more
+ * details.
+ *
+ * WARNING: These functions trust that the provided tree conforms to the
+ * provided shape. If not, behavior is undefined and may not respect the type
+ * signatures specified here.
+ */
+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>);
+    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>);
+    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.
+ */
+export declare function buildMapper<C, C, H, H, T, T>(): TreeMapperJustForLeaves<C, C, H, H, T, T>;
+export {};

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

@@ -0,0 +1,147 @@
+/**
+ * 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.d.ts

@@ -0,0 +1,73 @@
+/**
+ * This library provides support for Perseus multi-items: structured Perseus
+ * content that content creators can easily create, and that applications can
+ * easily render into different parts of the layout.
+ *
+ * For more details about application and motivation, see:
+ * https://sites.google.com/a/khanacademy.org/forge/for-developers/perseus-items-and-multi-items
+ *
+ * This file primarily exposes the `MultiRenderer` component, which performs
+ * multi-rendering. To multi-render a question, pass in the content of the item
+ * to the `MultiRenderer` component as a props. Then, pass in a function which
+ * takes an object of renderers (in the same structure as the content), and
+ * return a render tree. The `MultiRenderer` component will allow you to
+ * combine scores, serialized state, etc. without having to manually call on
+ * each of the functions. It also handles inter-widgets requests between the
+ * different renderers.
+ * For more details, see `multi-items/multi-renderer.jsx`.
+ *
+ * Example:
+ *
+ *   item = {_multi: {
+ *       left: <content data>,
+ *       right: [<content data>, <content data>],
+ *   }}
+ *   shape = shapes.shape({
+ *       left: shapes.content,
+ *       right: shapes.arrayOf(shapes.content),
+ *   })
+ *
+ *   <MultiRenderer item={item} shape={shape}>
+ *       {({renderers}) =>
+ *           <div>
+ *               <div id="left">{renderers.left}</div>
+ *               <ul id="right">
+ *                   {renderers.right.map(r => <li>{r}</li>)}
+ *               </ul>
+ *           </div>
+ *       }
+ *   </MultiRenderer>
+ *
+ * This file also exposes `shapes`, which helps you construct a runtime type
+ * declaration for your particular class of multi-item. This can then be used
+ * to create a MultirendererEditor for your multi-item shape, and to validate
+ * that a multi-item conforms to the shape via `buildPropTypeForShape`.
+ * For more details, see `multi-items/shapes.js`.
+ *
+ * This file also exposes some utility functions for working with generic
+ * multi-items, like `findContentNodesInItem`, `findHintNodesInItem`,
+ * `inferItemShape`, and `buildEmptyItemForShape`.
+ * For more details, see `multi-items/items.js`.
+ */
+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 const _default: {
+    MultiRenderer: typeof MultiRenderer;
+    shapes: {
+        content: import(".").ContentShape;
+        hint: import(".").HintShape;
+        hints: import(".").ArrayShape;
+        tags: import(".").TagsShape;
+        arrayOf: (elementShape: import(".").Shape) => import(".").ArrayShape;
+        shape: (shape: {
+            [k: string]: import(".").Shape;
+        }) => import(".").ObjectShape;
+    };
+    buildPropTypeForShape: typeof buildPropTypeForShape;
+    buildEmptyItemForShape: typeof buildEmptyItemForShape;
+    findContentNodesInItem: typeof findContentNodesInItem;
+    findHintNodesInItem: typeof findHintNodesInItem;
+    inferItemShape: typeof inferItemShape;
+};
+export default _default;

package/dist/multi-items.js.flow

@@ -0,0 +1,36 @@
+/**
+ * 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;