@khanacademy/perseus 46.0.1 → 47.0.1

package/dist/perseus-types.d.ts

@@ -1,8 +1,37 @@
-import type { Coord } from "./interactive2/types";
-import type { Interval, vec } from "mafs";
+/**
+ * The Perseus "data schema" file.
+ *
+ * This file, and the types in it, represents the "data schema" that Perseus
+ * uses. The @khanacademy/perseus-editor package edits and produces objects
+ * that conform to the types in this file. Similarly, the top-level renderers
+ * in @khanacademy/perseus, consume objects that conform to these types.
+ *
+ * WARNING: This file should not import any types from elsewhere so that it is
+ * easy to reason about changes that alter the Perseus schema. This helps
+ * ensure that it is not changed accidentally when upgrading a dependant
+ * package or other part of Perseus code. Note that TypeScript does type
+ * checking via something called "structural typing". This means that as long
+ * as the shape of a type matches, the name it goes by doesn't matter. As a
+ * result, a `Coord` type that looks like this `[x: number, y: number]` is
+ * _identical_, in TypeScript's eyes, to this `Vector2` type `[x: number, y:
+ * number]`. Also, with tuples, the labels for each entry is ignored, so `[x:
+ * number, y: number]` is compatible with `[min: number, max: number]`. The
+ * labels are for humans, not TypeScript. :)
+ *
+ * If you make changes to types in this file, be very sure that:
+ *
+ *   a) the changes are backwards compatible. If they are not, old data from
+ *      previous versions of the "schema" could become unrenderable, or worse,
+ *      introduce hard-to-diagnose bugs.
+ *   b) the parsing code (`util/parse-perseus-json/`) is updated to handle
+ *      the new format _as well as_ the old format.
+ */
+export type Coord = [x: number, y: number];
+export type Interval = [min: number, max: number];
+export type Vector2 = Coord;
 export type Range = Interval;
-export type Size = [number, number];
-export type CollinearTuple = [vec.Vector2, vec.Vector2];
+export type Size = [width: number, height: number];
+export type CollinearTuple = [Vector2, Vector2];
 export type ShowSolutions = "all" | "selected" | "none";
 /**
  * Our core set of Perseus widgets.
@@ -124,17 +153,6 @@ export type PerseusItem = {
  * This item is never scored and is rendered by the `ArticleRenderer`.
  */
 export type PerseusArticle = PerseusRenderer | ReadonlyArray<PerseusRenderer>;
-/**
- * A "MultiItem" is an advanced Perseus item. It is rendered by the
- * `MultiRenderer` and you can control the layout of individual parts of the
- * item.
- *
- * @deprecated MultiItem support is slated for removal in a future Perseus
- * release.
- */
-export type MultiItem = {
-    _multi: any;
-};
 export type Version = {
     major: number;
     minor: number;

package/dist/types.d.ts

@@ -1,5 +1,4 @@
 import type { ILogger } from "./logging/log";
-import type { Item } from "./multi-items/item-types";
 import type { Hint, PerseusAnswerArea, PerseusGraphType, PerseusWidget, PerseusWidgetsMap } from "./perseus-types";
 import type { PerseusStrings } from "./strings";
 import type { SizeClass } from "./util/sizing-utils";
@@ -99,7 +98,6 @@ export type ChangeHandler = (arg1: {
     question?: any;
     answerArea?: PerseusAnswerArea | null;
     itemDataVersion?: Version;
-    item?: Item;
     editorMode?: EditorMode;
     jsonMode?: boolean;
     value?: any;

package/dist/widget-type-utils.d.ts

@@ -54,8 +54,6 @@ export declare function getWidgetsMapFromItemData(itemData: PerseusItem): Perseu
 export declare function getWidgetFromWidgetMap(widgetId: string, widgetMap: PerseusWidgetsMap): PerseusWidget | null;
 /**
  * Get select widgets from a widget map.
- * Useful for multi-items that needs to split
- * one PerseusItem into several
  *
  * @param {ReadonlyArray<string>} widgetIds to extract
  * @param {PerseusWidgetsMap} widgetMap to extract from

package/package.json

@@ -3,7 +3,7 @@
     "description": "Core Perseus API (includes renderers and widgets)",
     "author": "Khan Academy",
     "license": "MIT",
-    "version": "46.0.1",
+    "version": "47.0.1",
     "publishConfig": {
         "access": "public"
     },

package/dist/multi-items/item-types.d.ts

@@ -1,33 +0,0 @@
-/**
- * Type definitions for multi-item types, including:
- *
- * - Item: A multi-item tree wrapped in a `_multi` key, to help us recognize it
- *         as a multi-item in other contexts and avoid misinterpreting its
- *         other properties.
- * - ItemTree: A multi-item without the `_multi` key. Conforms to the Tree
- *             interface, so it's compatible with our tree traversal functions.
- * - And the various types of nodes that compose a tree.
- */
-import type { Tree, ArrayNode, ObjectNode } from "./tree-types";
-import type { PerseusWidgetsMap } from "../perseus-types";
-import type { ImageDict } from "../types";
-export type ContentNode = {
-    __type: "content" | "item";
-    content?: string | null | undefined;
-    images?: ImageDict | null | undefined;
-    widgets?: PerseusWidgetsMap | null | undefined;
-};
-export type HintNode = {
-    __type: "hint";
-    content?: string | null | undefined;
-    images?: ImageDict | null | undefined;
-    widgets?: PerseusWidgetsMap | null | undefined;
-    replace?: boolean | null | undefined;
-};
-export type TagsNode = ReadonlyArray<string>;
-export type ItemArrayNode = ArrayNode<ContentNode, HintNode, TagsNode>;
-export type ItemObjectNode = ObjectNode<ContentNode, HintNode, TagsNode>;
-export type ItemTree = Tree<ContentNode, HintNode, TagsNode>;
-export type Item = {
-    _multi: ItemTree;
-};

package/dist/multi-items/items.d.ts

@@ -1,53 +0,0 @@
-/**
- * Utility functions for constructing and manipulating multi-items.
- *
- * These functions apply *specifically* to Items and ItemTrees - things that
- * actually semantically *are* multi-items. For more general functions for
- * traversing and manipulating *anything* shaped like a multi-item (like a
- * renderer tree or a score tree or, well, a multi-item), see trees.js.
- */
-import type { Item, ItemTree, ContentNode, HintNode } from "./item-types";
-import type { Shape } from "./shape-types";
-/**
- * Return a semantically empty ItemTree that conforms to the given shape.
- *
- * - An empty content node has an empty content string and no widgets/images.
- * - An empty hint node has an empty content string and no widgets/images.
- * - An empty array node has no elements.
- * - An empty object node has a semantically empty node for each of its keys.
- *   (That is, we recursively call buildEmptyItemTreeForShape for each key.)
- */
-export declare function buildEmptyItemTreeForShape(shape: Shape): ItemTree;
-/**
- * Return a semantically empty Item that conforms to the given shape.
- *
- * - An empty content node has an empty content string and no widgets/images.
- * - An empty hint node has an empty content string and no widgets/images.
- * - An empty array node has no elements.
- * - An empty object node has a semantically empty node for each of its keys.
- *   (That is, we recursively call buildEmptyItemTreeForShape for each key.)
- */
-export declare function buildEmptyItemForShape(shape: Shape): Item;
-/**
- * Given an Item and its Shape, yield all of its content nodes to the callback.
- */
-export declare function findContentNodesInItem(item: Item, shape: Shape, callback: (c: ContentNode) => any): void;
-/**
- * Given an Item and its Shape, yield all of its hint nodes to the callback.
- */
-export declare function findHintNodesInItem(item: Item, shape: Shape, callback: (h: HintNode) => any): void;
-/**
- * Given an ItemTree, return a Shape that it conforms to.
- *
- * The Shape might not be complete or correct Shape that this Item was designed
- * for. If you have access to the intended Shape, use that instead.
- */
-export declare function inferItemShape(item: Item): Shape;
-/**
- * Convert the given Item to an ItemTree, by unwrapping the `_multi` key.
- */
-export declare function itemToTree(item: Item): ItemTree;
-/**
- * Convert the given ItemTree to an Item, by wrapping it in the `_multi` key.
- */
-export declare function treeToItem(node: ItemTree): Item;

package/dist/multi-items/multi-renderer.d.ts

@@ -1,159 +0,0 @@
-import * as React from "react";
-import { PerseusI18nContext } from "../components/i18n-context";
-import Renderer from "../renderer";
-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";
-import type { APIOptions, FilterCriterion, PerseusDependenciesV2, Widget } from "../types";
-import type { PropsFor } from "@khanacademy/wonder-blocks-core";
-type Hint = any;
-type Score = any;
-type SerializedState = any;
-type RendererProps = PropsFor<typeof Renderer>;
-type ContentRendererElement = React.ReactElement<any>;
-type HintRendererElement = React.ReactElement<any>;
-type ContentRendererData = {
-    makeRenderer: () => ContentRendererElement;
-    ref: Renderer | null | undefined;
-};
-type FindWidgetsFunc = (criterion: FilterCriterion) => ReadonlyArray<Widget | null | undefined>;
-type HintRendererData = {
-    makeRenderer: () => HintRendererElement;
-    findExternalWidgets: FindWidgetsFunc | null | undefined;
-    ref: null;
-    hint: Hint;
-};
-type RendererData = ContentRendererData | HintRendererData;
-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. :(
- */
-type RendererTree = Tree<ContentRendererElement, HintRendererElement, null>;
-type ScoreTree = Tree<Score, null, null>;
-type SerializedStateTree = Tree<SerializedState, null, null>;
-type Props = {
-    item: Item;
-    shape: Shape;
-    children: (tree: {
-        renderers: RendererTree;
-    }) => React.ReactElement<any>;
-    serializedState?: SerializedStateTree | null | undefined;
-    onSerializedStateUpdated?: (state: SerializedStateTree) => void;
-    onInteractWithWidget?: (id: string) => void;
-    apiOptions?: APIOptions;
-    reviewMode?: boolean | null | undefined;
-    dependencies: PerseusDependenciesV2;
-};
-type State = {
-    rendererDataTree: RendererDataTree | null | undefined;
-    renderError: Error | null | undefined;
-};
-declare class MultiRenderer extends React.Component<Props, State> {
-    static contextType: React.Context<{
-        strings: import("../strings").PerseusStrings;
-        locale: string;
-    }>;
-    context: React.ContextType<typeof PerseusI18nContext>;
-    rendererDataTreeMapper: TreeMapper<ContentNode, ContentRendererData, HintNode, HintRendererData, TagsNode, null>;
-    getRenderersMapper: TreeMapper<ContentRendererData, ContentRendererElement, HintRendererData, HintRendererElement, null, null>;
-    constructor(props: Props);
-    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 | undefined>;
-    /**
-     * 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 | undefined;
-    _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.ReactNode;
-}
-export default MultiRenderer;

package/dist/multi-items/prop-type-builders.d.ts

@@ -1,14 +0,0 @@
-/**
- * Utility functions to build React PropTypes for multi-items and shapes.
- *
- * If you're writing new components, though, consider using the Item and Shape
- * types instead.
- */
-import type { Shape } from "./shape-types";
-/**
- * Return a PropType that accepts Items of the given shape, and rejects other
- * objects.
- *
- * Usage: `propTypes: {item: buildPropTypeForShape(myShape)}`
- */
-export declare function buildPropTypeForShape(shape: Shape): any;

package/dist/multi-items/shape-types.d.ts

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

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

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

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