@khanacademy/math-input 15.0.1 → 16.0.0

package/dist/components/keypad-legacy/gesture-manager.d.ts

@@ -1,86 +0,0 @@
-/**
- * A high-level manager for our gesture system. In particular, this class
- * connects our various bits of logic for managing gestures and interactions,
- * and links them together.
- */
-import GestureStateMachine from "./gesture-state-machine";
-import NodeManager from "./node-manager";
-import PopoverStateMachine from "./popover-state-machine";
-import type Key from "../../data/keys";
-import type { ActiveNodesObj, LayoutProps } from "../../types";
-import type * as React from "react";
-type Options = {
-    swipeEnabled: boolean;
-};
-type Handlers = {
-    onSwipeChange?: (dx: number) => void;
-    onSwipeEnd?: (dx: number) => void;
-    onActiveNodesChanged: (activeNodes: ActiveNodesObj) => void;
-    onClick: (key: Key, layoutProps: LayoutProps, inPopover: boolean) => void;
-};
-declare class GestureManager {
-    swipeEnabled: boolean;
-    trackEvents: boolean;
-    nodeManager: NodeManager;
-    popoverStateMachine: PopoverStateMachine;
-    gestureStateMachine: GestureStateMachine;
-    constructor(options: Options, handlers: Handlers, disabledSwipeKeys: ReadonlyArray<Key>, multiPressableKeys: ReadonlyArray<Key>);
-    /**
-     * Handle a touch-start event that originated in a node registered with the
-     * gesture system.
-     *
-     * @param {React.TouchEvent<HTMLDivElement>} evt - the raw touch event from the browser
-     * @param {string} id - the identifier of the DOM node in which the touch
-     *                      occurred
-     */
-    onTouchStart(evt: React.TouchEvent<HTMLDivElement>, id?: string | undefined): void;
-    /**
-     * Handle a touch-move event that originated in a node registered with the
-     * gesture system.
-     *
-     * @param {React.TouchEvent<HTMLDivElement>} evt - the raw touch event from the browser
-     */
-    onTouchMove(evt: React.TouchEvent<HTMLDivElement>): void;
-    /**
-     * Handle a touch-end event that originated in a node registered with the
-     * gesture system.
-     *
-     * @param {React.TouchEvent<HTMLDivElement>} evt - the raw touch event from the browser
-     */
-    onTouchEnd(evt: React.TouchEvent<HTMLDivElement>): void;
-    /**
-     * Handle a touch-cancel event that originated in a node registered with the
-     * gesture system.
-     *
-     * @param {React.TouchEvent<HTMLDivElement>} evt - the raw touch event from the browser
-     */
-    onTouchCancel(evt: React.TouchEvent<HTMLDivElement>): void;
-    /**
-     * Register a DOM node with a given identifier.
-     *
-     * @param {string} id - the identifier of the given node
-     * @param {node} domNode - the DOM node linked to the identifier
-     * @param {string[]} childIds - the identifiers of any DOM nodes that
-     *                              should be considered children of this node,
-     *                              in that they should take priority when
-     *                              intercepting touch events
-     * @param {object} borders - an opaque object describing the node's borders
-     */
-    registerDOMNode(id: any, domNode: any, childIds: any): void;
-    /**
-     * Unregister the DOM node with the given identifier.
-     *
-     * @param {string} id - the identifier of the node to unregister
-     */
-    unregisterDOMNode(id: any): void;
-    /**
-     * Enable event tracking for the gesture manager.
-     */
-    enableEventTracking(): void;
-    /**
-     * Disable event tracking for the gesture manager. When called, the gesture
-     * manager will drop any events received by managed nodes.
-     */
-    disableEventTracking(): void;
-}
-export default GestureManager;

package/dist/components/keypad-legacy/gesture-state-machine.d.ts

@@ -1,105 +0,0 @@
-import type Key from "../../data/keys";
-/**
- * The state machine that backs our gesture system. In particular, this state
- * machine manages the interplay between focuses, touch ups, and swiping.
- * It is entirely ignorant of the existence of popovers and the positions of
- * DOM nodes, operating solely on IDs. The state machine does accommodate for
- * multi-touch interactions, tracking gesture state on a per-touch basis.
- */
-export type Handlers = {
-    onFocus: (id: string) => void;
-    onBlur: () => void;
-    onTrigger: (id: string) => void;
-    onLongPress: (id: string) => void;
-    onSwipeChange?: (x: number) => void;
-    onSwipeEnd?: (x: number) => void;
-    onTouchEnd: (id: string) => void;
-};
-type Options = {
-    longPressWaitTimeMs: number;
-    swipeThresholdPx: number;
-    holdIntervalMs: number;
-};
-type TouchState = {
-    activeNodeId: Key;
-    pressAndHoldIntervalId: number | null;
-    longPressTimeoutId: number | null;
-    swipeLocked: boolean;
-    startX: number;
-};
-type TouchStateMap = Record<Key, TouchState>;
-type SwipeState = {
-    touchId: Key;
-    startX: number;
-};
-declare class GestureStateMachine {
-    handlers: Handlers;
-    options: Options;
-    swipeDisabledNodeIds: ReadonlyArray<Key>;
-    multiPressableKeys: ReadonlyArray<Key>;
-    touchState: Partial<TouchStateMap>;
-    swipeState: SwipeState | null;
-    constructor(handlers: Handlers, options: Partial<Options>, swipeDisabledNodeIds?: ReadonlyArray<Key>, multiPressableKeys?: ReadonlyArray<Key>);
-    _maybeCancelLongPressForTouch(touchId: any): void;
-    _maybeCancelPressAndHoldForTouch(touchId: any): void;
-    _cleanupTouchEvent(touchId: any): void;
-    /**
-     * Handle a focus event on the node with the given identifier, which may be
-     * `null` to indicate that the user has dragged their finger off of any
-     * registered nodes, but is still in the middle of a gesture.
-     *
-     * @param {string|null} id - the identifier of the newly focused node, or
-     *                           `null` if no node is focused
-     * @param {number} touchId - a unique identifier associated with the touch
-     */
-    _onFocus(id: any, touchId: any): void;
-    /**
-     * Clear out all active gesture information.
-     */
-    _onSwipeStart(): void;
-    /**
-     * A function that returns the identifier of the node over which the touch
-     * event occurred. This is provided as a piece of lazy computation, as
-     * computing the DOM node for a given point is expensive, and the state
-     * machine won't always need that information. For example, if the user is
-     * swiping, then `onTouchMove` needs to be performant and doesn't care about
-     * the node over which the touch occurred.
-     *
-     * @typedef idComputation
-     * @returns {DOMNode} - the identifier of the node over which the touch
-     *                      occurred
-     */
-    /**
-     * Handle a touch-start event on the node with the given identifer.
-     *
-     * @param {idComputation} getId - a function that returns identifier of the
-     *                                node over which the start event occurred
-     * @param {number} touchId - a unique identifier associated with the touch
-     */
-    onTouchStart(getId: any, touchId: any, pageX: any): void;
-    /**
-     * Handle a touch-move event on the node with the given identifer.
-     *
-     * @param {idComputation} getId - a function that returns identifier of the
-     *                                node over which the move event occurred
-     * @param {number} touchId - a unique identifier associated with the touch
-     * @param {number} pageX - the x coordinate of the touch
-     * @param {boolean} swipeEnabled - whether the system should allow for
-     *                                 transitions into a swiping state
-     */
-    onTouchMove(getId: any, touchId: any, pageX: any, swipeEnabled: any): void;
-    /**
-     * Handle a touch-end event on the node with the given identifer.
-     *
-     * @param {idComputation} getId - a function that returns identifier of the
-     *                                node over which the end event occurred
-     * @param {number} touchId - a unique identifier associated with the touch
-     * @param {number} pageX - the x coordinate of the touch
-     */
-    onTouchEnd(getId: any, touchId: any, pageX: any): void;
-    /**
-     * Handle a touch-cancel event.
-     */
-    onTouchCancel(touchId: any): void;
-}
-export default GestureStateMachine;

package/dist/components/keypad-legacy/icon.d.ts

@@ -1,15 +0,0 @@
-/**
- * A component that renders an icon for a symbol with the given name.
- */
-import * as React from "react";
-import type { IconConfig } from "../../types";
-import type { StyleType } from "@khanacademy/wonder-blocks-core";
-type Props = {
-    focused: boolean;
-    icon: IconConfig;
-    style?: StyleType;
-};
-declare class Icon extends React.PureComponent<Props> {
-    render(): JSX.Element;
-}
-export default Icon;

package/dist/components/keypad-legacy/index.d.ts

@@ -1 +0,0 @@
-export { default } from "./provided-keypad";

package/dist/components/keypad-legacy/keypad-button.d.ts

@@ -1,53 +0,0 @@
-/**
- * A component that renders a keypad button.
- */
-import * as React from "react";
-import { BorderDirection } from "../../enums";
-import type { KeyType } from "../../enums";
-import type { Border, NonManyKeyConfig, IconConfig } from "../../types";
-import type { StyleType } from "@khanacademy/wonder-blocks-core";
-interface ReduxProps {
-    heightPx: number;
-    widthPx: number;
-}
-interface Props extends ReduxProps {
-    ariaLabel?: string;
-    borders: Border;
-    childKeys: ReadonlyArray<NonManyKeyConfig>;
-    disabled: boolean;
-    focused: boolean;
-    popoverEnabled: boolean;
-    type: KeyType;
-    icon?: IconConfig;
-    style?: StyleType;
-    onTouchCancel?: (evt: React.TouchEvent<HTMLDivElement>) => void;
-    onTouchEnd?: (evt: React.TouchEvent<HTMLDivElement>) => void;
-    onTouchMove?: (evt: React.TouchEvent<HTMLDivElement>) => void;
-    onTouchStart?: (evt: React.TouchEvent<HTMLDivElement>) => void;
-    ref?: (any: any) => void;
-}
-declare class KeypadButton extends React.PureComponent<Props> {
-    buttonSizeStyle: StyleType | undefined;
-    static defaultProps: {
-        borders: readonly BorderDirection[];
-        childKeys: never[];
-        disabled: boolean;
-        focused: boolean;
-        popoverEnabled: boolean;
-    };
-    UNSAFE_componentWillMount(): void;
-    componentDidMount(): void;
-    UNSAFE_componentWillUpdate(newProps: any, newState: any): void;
-    _preInjectStyles: () => void;
-    _getFocusStyle: (type: KeyType) => any[];
-    _getButtonStyle: (type: any, borders: any, style?: any) => any[];
-    render(): JSX.Element;
-}
-declare const _default: import("react-redux").ConnectedComponent<typeof KeypadButton, import("react-redux").Omit<Pick<React.ClassAttributes<KeypadButton> & Props, "style" | "ref" | "ariaLabel" | "onTouchCancel" | "onTouchEnd" | "onTouchMove" | "onTouchStart" | "type" | "icon" | "key" | "heightPx" | "widthPx"> & {
-    focused?: boolean | undefined;
-    disabled?: boolean | undefined;
-    borders?: readonly (BorderDirection | undefined)[] | undefined;
-    childKeys?: readonly NonManyKeyConfig[] | undefined;
-    popoverEnabled?: boolean | undefined;
-} & {}, "heightPx" | "widthPx">>;
-export default _default;

package/dist/components/keypad-legacy/keypad-container.d.ts

@@ -1,41 +0,0 @@
-import * as React from "react";
-import { LayoutMode, KeypadType } from "../../enums";
-import type { StyleType } from "@khanacademy/wonder-blocks-core";
-interface ReduxProps {
-    active?: boolean;
-    extraKeys?: ReadonlyArray<string>;
-    keypadType?: KeypadType;
-    layoutMode?: LayoutMode;
-    navigationPadEnabled?: boolean;
-}
-interface Props extends ReduxProps {
-    onDismiss?: () => void;
-    onElementMounted: (element: any) => void;
-    onPageSizeChange?: (pageWidth: number, pageHeight: number, containerWidth: number, containerHeight: number) => void;
-    style?: StyleType;
-}
-type State = {
-    hasBeenActivated: boolean;
-    viewportWidth: string | number;
-};
-declare class KeypadContainer extends React.Component<Props, State> {
-    _containerRef: React.RefObject<HTMLDivElement>;
-    _containerResizeObserver: ResizeObserver | null;
-    _resizeTimeout: number | null | undefined;
-    hasMounted: boolean | undefined;
-    state: {
-        hasBeenActivated: boolean;
-        viewportWidth: string;
-    };
-    UNSAFE_componentWillMount(): void;
-    componentDidMount(): void;
-    UNSAFE_componentWillReceiveProps(nextProps: any): void;
-    componentDidUpdate(prevProps: any): void;
-    componentWillUnmount(): void;
-    _throttleResizeHandler: () => void;
-    _onResize: () => void;
-    renderKeypad: () => JSX.Element;
-    render(): JSX.Element;
-}
-declare const _default: import("react-redux").ConnectedComponent<typeof KeypadContainer, import("react-redux").Omit<React.ClassAttributes<KeypadContainer> & Props, "active" | "extraKeys" | "keypadType" | "onPageSizeChange" | "layoutMode" | "navigationPadEnabled">>;
-export default _default;

package/dist/components/keypad-legacy/keypad.d.ts

@@ -1,31 +0,0 @@
-/**
- * A keypad component that acts as a container for rows or columns of buttons,
- * and manages the rendering of echo animations on top of those buttons.
- */
-import * as React from "react";
-import type { Bound, Popover, Echo } from "../../types";
-import type { StyleType } from "@khanacademy/wonder-blocks-core";
-interface ReduxProps {
-    active: boolean;
-    echoes: ReadonlyArray<Echo>;
-    popover: Popover | null;
-}
-interface Props extends ReduxProps {
-    children: React.ReactNode;
-    style?: StyleType;
-    removeEcho?: (animationId: string) => void;
-}
-declare class Keypad extends React.Component<Props> {
-    _isMounted: boolean | undefined;
-    _resizeTimeout: number | null | undefined;
-    _container: Bound | null | undefined;
-    componentDidMount(): void;
-    UNSAFE_componentWillReceiveProps(newProps: any): void;
-    componentWillUnmount(): void;
-    _computeContainer: () => void;
-    _updateSizeAndPosition: () => void;
-    _onResize: () => void;
-    render(): JSX.Element;
-}
-declare const _default: import("react-redux").ConnectedComponent<typeof Keypad, import("react-redux").Omit<React.ClassAttributes<Keypad> & Props, "active" | "popover" | "echoes" | "removeEcho">>;
-export default _default;

package/dist/components/keypad-legacy/many-keypad-button.d.ts

@@ -1,15 +0,0 @@
-/**
- * A keypad button that displays an arbitrary number of symbols, with no
- * 'default' symbol.
- */
-import * as React from "react";
-type Props = {
-    keys: ReadonlyArray<string>;
-};
-declare class ManyKeypadButton extends React.Component<Props> {
-    static defaultProps: {
-        keys: never[];
-    };
-    render(): JSX.Element;
-}
-export default ManyKeypadButton;

package/dist/components/keypad-legacy/math-icon.d.ts

@@ -1,16 +0,0 @@
-/**
- * A component that renders an icon with math (via KaTeX).
- */
-import * as React from "react";
-import type { StyleType } from "@khanacademy/wonder-blocks-core";
-type Props = {
-    math: string;
-    style: StyleType;
-};
-declare class MathIcon extends React.Component<Props> {
-    componentDidMount(): void;
-    componentDidUpdate(prevProps: any): void;
-    _renderMath: () => void;
-    render(): JSX.Element;
-}
-export default MathIcon;

package/dist/components/keypad-legacy/multi-symbol-grid.d.ts

@@ -1,14 +0,0 @@
-/**
- * A grid of symbols, rendered as text and positioned based on the number of
- * symbols provided. Up to four symbols will be shown.
- */
-import * as React from "react";
-import type { IconConfig } from "../../types";
-type Props = {
-    focused: boolean;
-    icons: ReadonlyArray<IconConfig>;
-};
-declare class MultiSymbolGrid extends React.Component<Props> {
-    render(): JSX.Element;
-}
-export default MultiSymbolGrid;

package/dist/components/keypad-legacy/multi-symbol-popover.d.ts

@@ -1,12 +0,0 @@
-/**
- * A popover that renders a set of keys floating above the page.
- */
-import * as React from "react";
-import type { KeyConfig } from "../../types";
-type Prop = {
-    keys: ReadonlyArray<KeyConfig>;
-};
-declare class MultiSymbolPopover extends React.Component<Prop> {
-    render(): JSX.Element;
-}
-export default MultiSymbolPopover;

package/dist/components/keypad-legacy/navigation-pad.d.ts

@@ -1,14 +0,0 @@
-/**
- * A component that renders a navigation pad, which consists of an arrow for
- * each possible direction.
- */
-import * as React from "react";
-import type { StyleType } from "@khanacademy/wonder-blocks-core";
-type Props = {
-    roundTopLeft: boolean;
-    style: StyleType;
-};
-declare class NavigationPad extends React.Component<Props> {
-    render(): JSX.Element;
-}
-export default NavigationPad;

package/dist/components/keypad-legacy/node-manager.d.ts

@@ -1,49 +0,0 @@
-import type { LayoutProps, Bound } from "../../types";
-/**
- * A manager for our node-to-ID system. In particular, this class is
- * responsible for maintaing a mapping between DOM nodes and node IDs, and
- * translating touch events from the raw positions at which they occur to the
- * nodes over which they are occurring. This differs from browser behavior, in
- * which touch events are only sent to the node in which a touch started.
- */
-declare class NodeManager {
-    _nodesById: Record<string, HTMLElement>;
-    _orderedIds: ReadonlyArray<string>;
-    _cachedBoundingBoxesById: Record<string, Bound>;
-    constructor();
-    /**
-     * Register a DOM node with a given identifier.
-     *
-     * @param {string} id - the identifier of the given node
-     * @param {node} domNode - the DOM node linked to the identifier
-     * @param {object} borders - an opaque object describing the node's borders
-     */
-    registerDOMNode(id: string, domNode: HTMLElement, childIds: ReadonlyArray<string>): void;
-    /**
-     * Unregister the DOM node with the given identifier.
-     *
-     * @param {string} id - the identifier of the node to unregister
-     */
-    unregisterDOMNode(id: string): void;
-    /**
-     * Return the identifier of the topmost node located at the given
-     * coordinates.
-     *
-     * @param {number} x - the x coordinate at which to search for a node
-     * @param {number} y - the y coordinate at which to search for a node
-     * @returns {null|string} - null or the identifier of the topmost node at
-     *                          the given coordinates
-     */
-    idForCoords(x: number, y: number): string | void;
-    /**
-     * Return the necessary layout information, including the bounds and border
-     * values, for the node with the given identifier.
-     *
-     * @param {string} id - the identifier of the node for which to return the
-     *                      layout information
-     * @returns {object} - the bounding client rect for the given node, along
-     *                     with its borders
-     */
-    layoutPropsForId(id: string): LayoutProps;
-}
-export default NodeManager;

package/dist/components/keypad-legacy/popover-manager.d.ts

@@ -1,13 +0,0 @@
-/**
- * A component that renders and animates the popovers that appear over the
- * multi-functional keys.
- */
-import * as React from "react";
-import type { Popover } from "../../types";
-type PopoverManagerProps = {
-    popover: Popover | null;
-};
-declare class PopoverManager extends React.Component<PopoverManagerProps> {
-    render(): JSX.Element | null;
-}
-export default PopoverManager;

package/dist/components/keypad-legacy/popover-state-machine.d.ts

@@ -1,68 +0,0 @@
-import type { ActiveNodesObj } from "../../types";
-/**
- * A state machine for the popover state. In particular, this class manages the
- * mapping of parent nodes to their children, and translates touch events that
- * traverse various nodes to actions that are conditioned on whether a popover
- * is present.
- */
-type Handlers = {
-    onActiveNodesChanged: (activeNodes: ActiveNodesObj) => void;
-    onClick: (keyId: string, domNodeId: string, inPopover: boolean) => void;
-};
-declare class PopoverStateMachine {
-    handlers: Handlers;
-    popovers: Record<string, ReadonlyArray<string>>;
-    activePopover: string | null;
-    constructor(handlers: any);
-    /**
-     * Register a popover container as containing a set of children.
-     *
-     * @param {string} id - the identifier of the popover container
-     * @param {string[]} childIds - the identifiers of the nodes contained in
-     *                              the popover container
-     */
-    registerPopover(id: any, childIds: any): void;
-    /**
-     * Unregister a popover container.
-     *
-     * @param {string} id - the identifier of the popover container to
-     *                      unregister
-     */
-    unregisterPopover(id: any): void;
-    /**
-     * @returns {boolean} - whether a popover is active and visible
-     */
-    isPopoverVisible(): boolean;
-    /**
-     * Blur the active nodes.
-     */
-    onBlur(): void;
-    /**
-     * Handle a focus event on the node with the given identifier.
-     *
-     * @param {string} id - the identifier of the node that was focused
-     */
-    onFocus(id: any): void;
-    /**
-     * Handle a long press event on the node with the given identifier.
-     *
-     * @param {string} id - the identifier of the node that was long-pressed
-     */
-    onLongPress(id: any): void;
-    /**
-     * Handle the trigger (click or hold) of the node with the given identifier.
-     *
-     * @param {string} id - the identifier of the node that was triggered
-     */
-    onTrigger(id: any): void;
-    /**
-     * Handle a touch-end event on the node with the given identifier.
-     *
-     * @param {string} id - the identifier of the node over which the touch
-     *                      ended
-     */
-    onTouchEnd(id: any): void;
-    _isNodeInsidePopover(popover: any, id: any): boolean;
-    _defaultNodeForPopover(popover: any): string;
-}
-export default PopoverStateMachine;

package/dist/components/keypad-legacy/provided-keypad.d.ts

@@ -1,28 +0,0 @@
-import * as React from "react";
-import ReactDOM from "react-dom";
-import type { Cursor, KeypadConfiguration, KeyHandler, KeypadAPI } from "../../types";
-import type { AnalyticsEventHandlerFn } from "@khanacademy/perseus-core";
-import type { StyleType } from "@khanacademy/wonder-blocks-core";
-type Props = {
-    setKeypadActive: (keypadActive: boolean) => void;
-    keypadActive: boolean;
-    onElementMounted?: (arg1: any) => void;
-    onDismiss?: () => void;
-    style?: StyleType;
-    onAnalyticsEvent: AnalyticsEventHandlerFn;
-};
-declare class ProvidedKeypad extends React.Component<Props> implements KeypadAPI {
-    store: any;
-    constructor(props: any);
-    componentDidUpdate(prevProps: any): void;
-    activate: () => void;
-    dismiss: () => void;
-    configure: (configuration: KeypadConfiguration, cb: () => void) => void;
-    setCursor: (cursor: Cursor) => void;
-    setKeyHandler: (keyHandler: KeyHandler) => void;
-    getDOMNode: () => ReturnType<typeof ReactDOM.findDOMNode>;
-    onElementMounted: (element: any) => void;
-    onDismiss: () => void;
-    render(): React.ReactNode;
-}
-export default ProvidedKeypad;

package/dist/components/keypad-legacy/store/actions.d.ts

@@ -1,55 +0,0 @@
-import type Key from "../../../data/keys";
-import type { Bound, KeypadConfiguration, KeyHandler, Cursor, ActiveNodesObj } from "../../../types";
-type DismissKeypadAction = {
-    type: "DismissKeypad";
-};
-export declare const dismissKeypad: () => DismissKeypadAction;
-type ActivateKeypadAction = {
-    type: "ActivateKeypad";
-};
-export declare const activateKeypad: () => ActivateKeypadAction;
-/**
- * Configure the keypad with the provided configuration parameters.
- */
-type ConfigureKeypadAction = {
-    type: "ConfigureKeypad";
-    configuration: KeypadConfiguration;
-};
-export declare const configureKeypad: (configuration: KeypadConfiguration) => ConfigureKeypadAction;
-type SetPageSizeAction = {
-    type: "SetPageSize";
-    pageWidth: number;
-    pageHeight: number;
-    containerWidth: number;
-    containerHeight: number;
-};
-export declare const setPageSize: (pageWidth: number, pageHeight: number, containerWidth: number, containerHeight: number) => SetPageSizeAction;
-type RemoveEchoAction = {
-    type: "RemoveEcho";
-    animationId: string;
-};
-export declare const removeEcho: (animationId: string) => RemoveEchoAction;
-type SetKeyHandlerAction = {
-    type: "SetKeyHandler";
-    keyHandler: KeyHandler;
-};
-export declare const setKeyHandler: (keyHandler: KeyHandler) => SetKeyHandlerAction;
-type SetCursorAction = {
-    type: "SetCursor";
-    cursor: Cursor;
-};
-export declare const setCursor: (cursor: Cursor) => SetCursorAction;
-type SetActiveNodesAction = {
-    type: "SetActiveNodes";
-    activeNodes: any;
-};
-export declare const setActiveNodes: (activeNodes: ActiveNodesObj) => SetActiveNodesAction;
-type PressKeyAction = {
-    type: "PressKey";
-    key: Key;
-    initialBounds: Bound;
-    inPopover: boolean;
-};
-export declare const pressKey: (key: Key, initialBounds: Bound, inPopover: any) => PressKeyAction;
-export type Action = DismissKeypadAction | ActivateKeypadAction | ConfigureKeypadAction | SetPageSizeAction | RemoveEchoAction | SetKeyHandlerAction | SetCursorAction | SetActiveNodesAction | PressKeyAction;
-export {};

package/dist/components/keypad-legacy/store/echo-reducer.d.ts

@@ -1,4 +0,0 @@
-import type { Action } from "./actions";
-import type { EchoState } from "./types";
-declare const echoReducer: (state: EchoState | undefined, action: Action) => EchoState;
-export default echoReducer;

package/dist/components/keypad-legacy/store/index.d.ts

@@ -1,9 +0,0 @@
-import * as Redux from "redux";
-import type { GestureState } from "./types";
-export declare const createStore: () => Redux.Store<Redux.EmptyObject & {
-    input: import("./types").InputState;
-    keypad: import("./types").KeypadState;
-    gestures: GestureState;
-    echoes: import("./types").EchoState;
-    layout: import("./types").LayoutState;
-}, Redux.AnyAction>;

package/dist/components/keypad-legacy/store/input-reducer.d.ts

@@ -1,4 +0,0 @@
-import type { Action } from "./actions";
-import type { InputState } from "./types";
-declare const inputReducer: (state: InputState | undefined, action: Action) => InputState;
-export default inputReducer;

package/dist/components/keypad-legacy/store/keypad-reducer.d.ts

@@ -1,4 +0,0 @@
-import type { Action } from "./actions";
-import type { KeypadState } from "./types";
-declare const keypadReducer: (state: KeypadState | undefined, action: Action) => KeypadState;
-export default keypadReducer;

package/dist/components/keypad-legacy/store/layout-reducer.d.ts

@@ -1,4 +0,0 @@
-import type { Action } from "./actions";
-import type { LayoutState } from "./types";
-declare const layoutReducer: (state: LayoutState | undefined, action: Action) => LayoutState;
-export default layoutReducer;