lean4monaco 1.0.3 → 1.0.4

package/dist/monaco-lean4/lean4-infoview/src/infoview/tooltips.js

@@ -0,0 +1,231 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { arrow, autoPlacement, autoUpdate, FloatingArrow, offset, shift, size, useFloating } from '@floating-ui/react';
+import { ConfigContext } from './contexts';
+import { forwardAndUseRef, forwardAndUseStateRef, LogicalDomContext, useLogicalDomObserver, useOnClickOutside, } from './util';
+export function Tooltip(props_) {
+    const { reference, children, style, ...props } = props_;
+    const arrowRef = React.useRef(null);
+    const { refs, floatingStyles, context } = useFloating({
+        elements: { reference },
+        placement: 'top',
+        middleware: [
+            offset(8),
+            shift(),
+            autoPlacement({
+                padding: 10,
+            }),
+            size({
+                apply({ availableHeight, elements }) {
+                    elements.floating.style.maxHeight = `${Math.min(availableHeight, 300)}px`;
+                },
+                padding: 10,
+            }),
+            // NOTE: `padding` should be `tooltip.borderRadius` or more so that the arrow
+            // doesn't overflow the rounded corner.
+            arrow({ element: arrowRef, padding: 6 }),
+        ],
+        whileElementsMounted: autoUpdate,
+    });
+    const logicalDom = React.useContext(LogicalDomContext);
+    const logicalDomCleanupFn = React.useRef(() => { });
+    const floating = (_jsxs("div", { ref: node => {
+            refs.setFloating(node);
+            logicalDomCleanupFn.current();
+            if (node)
+                logicalDomCleanupFn.current = logicalDom.registerDescendant(node);
+            else
+                logicalDomCleanupFn.current = () => { };
+        }, style: { ...style, ...floatingStyles }, className: "tooltip", ...props, children: [_jsx(FloatingArrow, { ref: arrowRef, context: context, fill: "var(--vscode-editorHoverWidget-background)", strokeWidth: 1, stroke: "var(--vscode-editorHoverWidget-border)" }), _jsx("div", { className: "tooltip-content", children: children })] }));
+    // Append the tooltip to the end of document body to avoid layout issues.
+    // (https://github.com/leanprover/vscode-lean4/issues/51)
+    return ReactDOM.createPortal(floating, document.body);
+}
+export const WithToggleableTooltip = forwardAndUseStateRef((props_, ref, setRef) => {
+    const { isTooltipShown, hideTooltip, tooltipChildren, ...props } = props_;
+    // Since we do not want to hide the tooltip if the user is trying to select text in it,
+    // we need both the "click outside" and "click inside" handlers here because they
+    // play nicer with existing selections than a global click handler.
+    // With a single global click handler, any selection anywhere in the InfoView could block
+    // the tooltip from being hidden. This is especially annoying because right-clicking any
+    // element also selects it.
+    // With both inside and outside click handlers, the outside click handler can simply disregard
+    // selections, whereas React ensures that only a selection in the tooltip itself can block
+    // the inside click handler from hiding the tooltip, since the outer selection is removed
+    // before the inside click handler fires.
+    const [logicalSpanElt, logicalDomStorage] = useLogicalDomObserver({ current: ref });
+    const onClickOutside = React.useCallback(() => {
+        hideTooltip();
+    }, [hideTooltip]);
+    useOnClickOutside(logicalSpanElt, onClickOutside);
+    return (_jsx(LogicalDomContext.Provider, { value: logicalDomStorage, children: _jsxs("span", { ref: setRef, onClick: () => {
+                if (!window.getSelection()?.toString())
+                    hideTooltip();
+            }, ...props, children: [isTooltipShown && _jsx(Tooltip, { reference: ref, children: tooltipChildren }), props.children] }) }));
+});
+/** An element which calls `setHoverState` when the hover state of its DOM children changes.
+ *
+ * It is implemented with JS rather than CSS in order to allow nesting of these elements. When nested,
+ * only the smallest (deepest in the DOM tree) {@link DetectHoverSpan} has an enabled hover state. */
+export const DetectHoverSpan = forwardAndUseRef((props_, ref, setRef) => {
+    const { setHoverState, ...props } = props_;
+    const onPointerEvent = (b, e) => {
+        // It's more composable to let pointer events bubble up rather than to call `stopPropagation`,
+        // but we only want to handle hovers in the innermost component. So we record that the
+        // event was handled with a property.
+        // The `contains` check ensures that the node hovered over is a child in the DOM
+        // tree and not just a logical React child (see useLogicalDom and
+        // https://reactjs.org/docs/portals.html#event-bubbling-through-portals).
+        if (ref.current && e.target instanceof Node && ref.current.contains(e.target)) {
+            if ('_DetectHoverSpanSeen' in e)
+                return;
+            e._DetectHoverSpanSeen = {};
+            if (!b)
+                setHoverState('off');
+            else if (e.ctrlKey || e.metaKey)
+                setHoverState('ctrlOver');
+            else
+                setHoverState('over');
+        }
+    };
+    React.useEffect(() => {
+        const onKeyDown = (e) => {
+            if (e.key === 'Control' || e.key === 'Meta')
+                setHoverState(st => (st === 'over' ? 'ctrlOver' : st));
+        };
+        const onKeyUp = (e) => {
+            if (e.key === 'Control' || e.key === 'Meta')
+                setHoverState(st => (st === 'ctrlOver' ? 'over' : st));
+        };
+        // Note: In VSCode these events do not fire when the webview is not in focus.
+        document.addEventListener('keydown', onKeyDown);
+        document.addEventListener('keyup', onKeyUp);
+        return () => {
+            document.removeEventListener('keydown', onKeyDown);
+            document.removeEventListener('keyup', onKeyUp);
+        };
+    }, [setHoverState]);
+    return (_jsx("span", { ...props, ref: setRef, onPointerOver: e => {
+            onPointerEvent(true, e);
+            if (props.onPointerOver)
+                props.onPointerOver(e);
+        }, onPointerOut: e => {
+            onPointerEvent(false, e);
+            if (props.onPointerOut)
+                props.onPointerOut(e);
+        }, onPointerMove: e => {
+            if (e.ctrlKey || e.metaKey)
+                setHoverState(st => (st === 'over' ? 'ctrlOver' : st));
+            else
+                setHoverState(st => (st === 'ctrlOver' ? 'over' : st));
+            if (props.onPointerMove)
+                props.onPointerMove(e);
+        }, children: props.children }));
+});
+const TipChainContext = React.createContext({ pinParent: () => { } });
+/** Shows a tooltip when the children are hovered over or clicked.
+ *
+ * An `onClick` middleware can optionally be given in order to control what happens when the
+ * hoverable area is clicked. The middleware can invoke `next` to execute the default action
+ * which is to pin the tooltip open. */
+export const WithTooltipOnHover = forwardAndUseStateRef((props_, ref, setRef) => {
+    const { tooltipChildren, onClick: onClickProp, ...props } = props_;
+    const config = React.useContext(ConfigContext);
+    const [state, setState] = React.useState('hide');
+    const shouldShow = state !== 'hide';
+    const tipChainCtx = React.useContext(TipChainContext);
+    React.useEffect(() => {
+        if (state === 'pin')
+            tipChainCtx.pinParent();
+    }, [state, tipChainCtx]);
+    const newTipChainCtx = React.useMemo(() => ({
+        pinParent: () => {
+            setState('pin');
+            tipChainCtx.pinParent();
+        },
+    }), [tipChainCtx]);
+    // Note: because tooltips are attached to `document.body`, they are not descendants of the
+    // hoverable area in the DOM tree. Thus the `contains` check fails for elements within tooltip
+    // contents and succeeds for elements within the hoverable. We can use this to distinguish them.
+    const isWithinHoverable = (el) => ref && el instanceof Node && ref.contains(el);
+    const [logicalSpanElt, logicalDomStorage] = useLogicalDomObserver({ current: ref });
+    // We use timeouts for debouncing hover events.
+    const timeout = React.useRef();
+    const clearTimeout = () => {
+        if (timeout.current) {
+            window.clearTimeout(timeout.current);
+            timeout.current = undefined;
+        }
+    };
+    const showDelay = 500;
+    const hideDelay = 300;
+    const isModifierHeld = (e) => e.altKey || e.ctrlKey || e.shiftKey || e.metaKey;
+    const onClick = (e) => {
+        clearTimeout();
+        setState(state => (state === 'pin' ? 'hide' : 'pin'));
+        e.stopPropagation();
+    };
+    const onClickOutside = React.useCallback(() => {
+        clearTimeout();
+        setState('hide');
+    }, []);
+    useOnClickOutside(logicalSpanElt, onClickOutside);
+    const isPointerOverTooltip = React.useRef(false);
+    const startShowTimeout = () => {
+        clearTimeout();
+        if (!config.showTooltipOnHover)
+            return;
+        timeout.current = window.setTimeout(() => {
+            setState(state => (state === 'hide' ? 'show' : state));
+            timeout.current = undefined;
+        }, showDelay);
+    };
+    const startHideTimeout = () => {
+        clearTimeout();
+        timeout.current = window.setTimeout(() => {
+            if (!isPointerOverTooltip.current)
+                setState(state => (state === 'show' ? 'hide' : state));
+            timeout.current = undefined;
+        }, hideDelay);
+    };
+    const onPointerEnter = (e) => {
+        isPointerOverTooltip.current = true;
+        clearTimeout();
+    };
+    const onPointerLeave = (e) => {
+        isPointerOverTooltip.current = false;
+        startHideTimeout();
+    };
+    function guardMouseEvent(act, e) {
+        if ('_WithTooltipOnHoverSeen' in e)
+            return;
+        if (!isWithinHoverable(e.target))
+            return;
+        e._WithTooltipOnHoverSeen = {};
+        act(e);
+    }
+    return (_jsx(LogicalDomContext.Provider, { value: logicalDomStorage, children: _jsxs("span", { ...props, ref: setRef, onClick: e => {
+                guardMouseEvent(e => {
+                    if (onClickProp !== undefined)
+                        onClickProp(e, onClick);
+                    else
+                        onClick(e);
+                }, e);
+            }, onPointerDown: e => {
+                // We have special handling for some modifier+click events, so prevent default browser
+                // events from interfering when a modifier is held.
+                if (isModifierHeld(e))
+                    e.preventDefault();
+            }, onPointerOver: e => {
+                if (!isModifierHeld(e)) {
+                    guardMouseEvent(_ => startShowTimeout(), e);
+                }
+                if (props.onPointerOver !== undefined)
+                    props.onPointerOver(e);
+            }, onPointerOut: e => {
+                guardMouseEvent(_ => startHideTimeout(), e);
+                if (props.onPointerOut !== undefined)
+                    props.onPointerOut(e);
+            }, children: [shouldShow && (_jsx(TipChainContext.Provider, { value: newTipChainCtx, children: _jsx(Tooltip, { reference: ref, onPointerEnter: onPointerEnter, onPointerLeave: onPointerLeave, children: tooltipChildren }) })), props.children] }) }));
+});

package/dist/monaco-lean4/lean4-infoview/src/infoview/traceExplorer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Traces of any substantial compilation or elaboration process are usually extremely verbose,
+ * which makes them slow (or even infeasible) to pretty-print and difficult to understand.
+ * Instead, we provide a "TraceExplorer" UI which allows users to lazily expand trace subtrees,
+ * and (TODO) execute search queries.
+ *
+ * @module
+ */
+import { MsgEmbed } from '@leanprover/infoview-api';
+import { InteractiveTextComponentProps } from './interactiveCode';
+export declare function InteractiveMessage({ fmt }: InteractiveTextComponentProps<MsgEmbed>): any;

package/dist/monaco-lean4/lean4-infoview/src/infoview/traceExplorer.js

@@ -0,0 +1,115 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Traces of any substantial compilation or elaboration process are usually extremely verbose,
+ * which makes them slow (or even infeasible) to pretty-print and difficult to understand.
+ * Instead, we provide a "TraceExplorer" UI which allows users to lazily expand trace subtrees,
+ * and (TODO) execute search queries.
+ *
+ * @module
+ */
+import { InteractiveDiagnostics_msgToInteractive, lazyTraceChildrenToInteractive, } from '@leanprover/infoview-api';
+import * as React from 'react';
+import { Goal } from './goals';
+import { InteractiveCode, InteractiveTaggedText, } from './interactiveCode';
+import { useRpcSession } from './rpcSessions';
+import { DynamicComponent } from './userWidget';
+import { mapRpcError, useAsyncWithTrigger } from './util';
+function LazyTrace({ col, cls, msg }) {
+    const rs = useRpcSession();
+    const [tt, fetchTrace] = useAsyncWithTrigger(() => InteractiveDiagnostics_msgToInteractive(rs, msg, col), [rs, msg, col]);
+    const [open, setOpen] = React.useState(false);
+    if (!open)
+        return (_jsxs("span", { className: "underline-hover pointer", onClick: ev => {
+                void fetchTrace();
+                setOpen(true);
+                ev.stopPropagation();
+            }, children: ["[", cls, "] >"] }));
+    else if (tt.state === 'resolved')
+        return (_jsxs(_Fragment, { children: [_jsxs("span", { className: "underline-hover pointer", onClick: ev => {
+                        setOpen(false);
+                        ev.stopPropagation();
+                    }, children: ["[", cls, "] \u2228"] }), _jsx(InteractiveMessage, { fmt: tt.value })] }));
+    else if (tt.state === 'rejected')
+        return (_jsxs(_Fragment, { children: [_jsxs("span", { className: "underline-hover pointer", onClick: ev => {
+                        void fetchTrace();
+                        ev.stopPropagation();
+                    }, children: ["[", cls, "] Error (click to retry):"] }), ' ', mapRpcError(tt.error)] }));
+    else
+        return _jsxs("span", { children: ["[", cls, "] Loading.."] });
+}
+const TraceClassContext = React.createContext('');
+function abbreviateCommonPrefix(parent, cls) {
+    const parentParts = parent.split('.');
+    const clsParts = cls.split('.');
+    let i = 0;
+    for (; i < parentParts.length && i < clsParts.length && parentParts[i] === clsParts[i]; i++)
+        ;
+    return clsParts.slice(i).join('.');
+}
+function TraceLine({ indent, cls, msg, icon }) {
+    const spaces = ' '.repeat(indent);
+    const abbrCls = abbreviateCommonPrefix(React.useContext(TraceClassContext), cls);
+    return (_jsxs("div", { className: "trace-line", children: [spaces, _jsxs("span", { className: "trace-class", title: cls, children: ["[", abbrCls, "]"] }), ' ', _jsx(InteractiveMessage, { fmt: msg }), " ", icon] }));
+}
+function ChildlessTraceNode(traceEmbed) {
+    return _jsx(TraceLine, { ...traceEmbed, icon: "" });
+}
+function CollapsibleTraceNode(traceEmbed) {
+    const { cls, collapsed: collapsedByDefault, children: lazyKids } = traceEmbed;
+    const rs = useRpcSession();
+    const [children, fetchChildren] = useAsyncWithTrigger(async () => {
+        if ('strict' in lazyKids) {
+            return lazyKids.strict;
+        }
+        else {
+            return lazyTraceChildrenToInteractive(rs, lazyKids.lazy);
+        }
+    }, [rs, lazyKids]);
+    const [open, setOpen] = React.useState(!collapsedByDefault); // TODO: reset when collapsedByDefault changes?
+    if (open && children.state === 'notStarted')
+        void fetchChildren();
+    let icon = open ? '▼' : '▶';
+    if (children.state === 'loading')
+        icon += ' ⋯';
+    const onClick = React.useCallback((ev) => {
+        if (!(ev.target instanceof Node))
+            return;
+        if (!ev.currentTarget || !ev.target)
+            return;
+        // Don't handle clicks within React portals nested in this div (notably, tooltips).
+        if (!ev.currentTarget.contains(ev.target))
+            return;
+        ev.stopPropagation();
+        if (!open)
+            void fetchChildren();
+        setOpen(o => !o);
+    }, [open, fetchChildren]);
+    return (_jsxs("div", { children: [_jsx("div", { className: "pointer", onClick: onClick, children: _jsx(TraceLine, { ...traceEmbed, icon: icon }) }), _jsx("div", { style: { display: open ? 'block' : 'none' }, children: _jsx(TraceClassContext.Provider, { value: cls, children: children.state === 'resolved' ? (children.value.map((tt, i) => _jsx(InteractiveMessage, { fmt: tt }, i))) : children.state === 'rejected' ? (mapRpcError(children.error).toString()) : (_jsx(_Fragment, {})) }) })] }));
+}
+function Trace(traceEmbed) {
+    const noChildren = 'strict' in traceEmbed.children && traceEmbed.children.strict.length === 0;
+    return noChildren ? _jsx(ChildlessTraceNode, { ...traceEmbed }) : _jsx(CollapsibleTraceNode, { ...traceEmbed });
+}
+function InteractiveMessageTag({ tag: embed }) {
+    if ('expr' in embed)
+        return _jsx(InteractiveCode, { fmt: embed.expr });
+    else if ('goal' in embed)
+        return (_jsx(Goal, { goal: embed.goal, filter: {
+                reverse: false,
+                showType: true,
+                showInstance: true,
+                showHiddenAssumption: true,
+                showLetValue: true,
+            }, additionalClassNames: "" }));
+    else if ('widget' in embed)
+        return _jsx(DynamicComponent, { hash: embed.widget.wi.javascriptHash, props: embed.widget.wi.props });
+    else if ('lazyTrace' in embed)
+        return _jsx(LazyTrace, { col: embed.lazyTrace[0], cls: embed.lazyTrace[1], msg: embed.lazyTrace[2] });
+    else if ('trace' in embed)
+        return _jsx(Trace, { ...embed.trace });
+    else
+        return _jsxs("div", { children: ["malformed MsgEmbed: ", JSON.stringify(embed)] });
+}
+export function InteractiveMessage({ fmt }) {
+    return InteractiveTaggedText({ fmt, InnerTagUi: InteractiveMessageTag });
+}

package/dist/monaco-lean4/lean4-infoview/src/infoview/userWidget.d.ts

@@ -0,0 +1,48 @@
+import * as React from 'react';
+import { InteractiveGoal, InteractiveTermGoal, RpcSessionAtPos, UserWidgetInstance } from '@leanprover/infoview-api';
+import { GoalsLocation } from './goalLocation';
+import { DocumentPosition } from './util';
+/**
+ * Fetch source code from Lean and dynamically import it as a JS module.
+ *
+ * The source must hash to `hash` (in Lean) and must have been annotated with `@[widget]`
+ * or `@[widget_module]` at some point before `pos`. */
+export declare function importWidgetModule(rs: RpcSessionAtPos, pos: DocumentPosition, hash: string): Promise<any>;
+export interface DynamicComponentProps {
+    hash: string;
+    props: any;
+    /** @deprecated set {@link EnvPosContext} instead */
+    pos?: DocumentPosition;
+}
+/**
+ * Use {@link importWidgetModule} to import a module
+ * which must `export default` a React component,
+ * and render that with `props`.
+ * Errors in the component are caught in an error boundary.
+ *
+ * The {@link EnvPosContext} must be set.
+ * It is used to retrieve the `Lean.Environment`
+ * from which the widget module identified by `hash`
+ * is obtained.
+ */
+export declare function DynamicComponent(props_: React.PropsWithChildren<DynamicComponentProps>): any;
+interface PanelWidgetDisplayProps {
+    pos: DocumentPosition;
+    goals: InteractiveGoal[];
+    termGoal?: InteractiveTermGoal;
+    selectedLocations: GoalsLocation[];
+    widget: UserWidgetInstance;
+}
+/** Props that every infoview panel widget receives as input to its `default` export. */
+export interface PanelWidgetProps {
+    /** Cursor position in the file at which the widget is being displayed. */
+    pos: DocumentPosition;
+    /** The current tactic-mode goals. */
+    goals: InteractiveGoal[];
+    /** The current term-mode goal, if any. */
+    termGoal?: InteractiveTermGoal;
+    /** Locations currently selected in the goal state. */
+    selectedLocations: GoalsLocation[];
+}
+export declare function PanelWidgetDisplay({ pos, goals, termGoal, selectedLocations, widget }: PanelWidgetDisplayProps): any;
+export {};

package/dist/monaco-lean4/lean4-infoview/src/infoview/userWidget.js

@@ -0,0 +1,54 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { Widget_getWidgetSource, } from '@leanprover/infoview-api';
+import { EnvPosContext } from './contexts';
+import { ErrorBoundary } from './errors';
+import { useRpcSession } from './rpcSessions';
+import { mapRpcError, useAsyncPersistent } from './util';
+async function dynamicallyLoadModule(hash, code) {
+    const file = new File([code], `widget_${hash}.js`, { type: 'text/javascript' });
+    const url = URL.createObjectURL(file);
+    return await import(url);
+}
+const moduleCache = new Map();
+/**
+ * Fetch source code from Lean and dynamically import it as a JS module.
+ *
+ * The source must hash to `hash` (in Lean) and must have been annotated with `@[widget]`
+ * or `@[widget_module]` at some point before `pos`. */
+export async function importWidgetModule(rs, pos, hash) {
+    if (moduleCache.has(hash)) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return moduleCache.get(hash);
+    }
+    const resp = await Widget_getWidgetSource(rs, pos, hash);
+    const mod = await dynamicallyLoadModule(hash, resp.sourcetext);
+    moduleCache.set(hash, mod);
+    return mod;
+}
+/**
+ * Use {@link importWidgetModule} to import a module
+ * which must `export default` a React component,
+ * and render that with `props`.
+ * Errors in the component are caught in an error boundary.
+ *
+ * The {@link EnvPosContext} must be set.
+ * It is used to retrieve the `Lean.Environment`
+ * from which the widget module identified by `hash`
+ * is obtained.
+ */
+export function DynamicComponent(props_) {
+    const { hash, props, children } = props_;
+    const rs = useRpcSession();
+    const pos = React.useContext(EnvPosContext);
+    const state = useAsyncPersistent(() => {
+        if (!pos)
+            throw new Error('position context is not set');
+        return importWidgetModule(rs, pos, hash);
+    }, [rs, pos, hash]);
+    return (_jsx(React.Suspense, { fallback: `Loading component '${hash}'..`, children: _jsxs(ErrorBoundary, { children: [state.state === 'resolved' && React.createElement(state.value.default, props, children), state.state === 'rejected' && _jsxs("span", { className: "red", children: ["Error: ", mapRpcError(state.error).message] })] }) }));
+}
+export function PanelWidgetDisplay({ pos, goals, termGoal, selectedLocations, widget }) {
+    const componentProps = { pos, goals, termGoal, selectedLocations, ...widget.props };
+    return _jsx(DynamicComponent, { hash: widget.javascriptHash, props: componentProps });
+}

package/dist/monaco-lean4/lean4-infoview/src/infoview/util.d.ts

@@ -0,0 +1,144 @@
+import * as React from 'react';
+import type { DocumentUri, Position, Range, TextDocumentPositionParams } from 'vscode-languageserver-protocol';
+import { EventEmitter } from './event';
+/** A document URI and a position in that document. */
+export interface DocumentPosition extends Position {
+    uri: DocumentUri;
+}
+export declare namespace DocumentPosition {
+    function isEqual(p1: DocumentPosition, p2: DocumentPosition): boolean;
+    function toTdpp(p: DocumentPosition): TextDocumentPositionParams;
+    function toString(p: DocumentPosition): string;
+}
+export declare namespace PositionHelpers {
+    function isLessThanOrEqual(p1: Position, p2: Position): boolean;
+}
+export declare namespace RangeHelpers {
+    function contains(range: Range, pos: Position, ignoreCharacter?: boolean): boolean;
+}
+export declare function escapeHtml(s: string): string;
+/** @deprecated (unused) */
+export declare function colorizeMessage(goal: string): string;
+export declare function basename(path: string): string;
+/**
+ * A specialization of {@link React.useEffect} which executes `f` with the event data
+ * whenever `ev` fires.
+ * If `key` is provided, `f` is only invoked on events fired with that key.
+ */
+export declare function useEvent<E, K>(ev: EventEmitter<E, K>, f: (_: E) => void, dependencies?: React.DependencyList, key?: K): void;
+/**
+ * A piece of React {@link React.useState} which returns the data that `ev` most recently fired with.
+ * If `f` is provided, the data is mapped through `f` first. */
+export declare function useEventResult<E, K>(ev: EventEmitter<E, K>): E | undefined;
+export declare function useEventResult<E, K, T>(ev: EventEmitter<E, K>, f: (newVal: E) => T): T | undefined;
+export declare function useServerNotificationEffect<T>(method: string, f: (params: T) => void, deps?: React.DependencyList): void;
+/**
+ * Returns the same tuple as `setState` such that whenever a server notification with `method`
+ * arrives at the editor, the state will be updated according to `f`.
+ */
+export declare function useServerNotificationState<S, T>(method: string, initial: S, f: (params: T) => Promise<(state: S) => S>, deps?: React.DependencyList): [S, React.Dispatch<React.SetStateAction<S>>];
+export declare function useClientNotificationEffect<T>(method: string, f: (params: T) => void, deps?: React.DependencyList): void;
+/**
+ * Like {@link useServerNotificationState} but for client->server notifications sent by the editor.
+ */
+export declare function useClientNotificationState<S, T>(method: string, initial: S, f: (state: S, params: T) => S, deps?: React.DependencyList): [S, React.Dispatch<React.SetStateAction<S>>];
+/** Useful for controlling {@link usePausableState} from child components. */
+export interface PausableProps {
+    isPaused: boolean;
+    setPaused: React.Dispatch<React.SetStateAction<boolean>>;
+}
+/**
+ * Returns `[{ isPaused, setPaused }, tPausable, tRef]` s.t.
+ * - `[isPaused, setPaused]` are the paused status state
+ * - for as long as `isPaused` is set, `tPausable` holds its initial value (the `t` passed before pausing)
+ *   rather than updates with changes to `t`.
+ * - `tRef` can be used to overwrite the paused state
+ *
+ * To pause child components, `startPaused` can be passed in their props.
+ */
+export declare function usePausableState<T>(startPaused: boolean, t: T): [PausableProps, T, React.MutableRefObject<T>];
+export type Keyed<T> = T & {
+    key: string;
+};
+/**
+ * Adds a unique `key` property to each element in `elems` using
+ * the values of (possibly non-injective) `getId`.
+ */
+export declare function addUniqueKeys<T>(elems: T[], getId: (el: T) => string): Keyed<T>[];
+/** Like `React.forwardRef`, but also allows reading the ref inside the forwarding component.
+ * Adapted from https://itnext.io/reusing-the-ref-from-forwardref-with-react-hooks-4ce9df693dd */
+export declare function forwardAndUseRef<T, P>(render: (props: P, ref: React.RefObject<T>, setRef: (_: T | null) => void) => React.ReactElement | null): React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<T>>;
+/** Like `forwardAndUseRef`, but the ref is stored in state so that setting it triggers a render.
+ * Should only be used if re-rendering is necessary. */
+export declare function forwardAndUseStateRef<T, P>(render: (props: P, ref: T | null, setRef: (_: T | null) => void) => React.ReactElement | null): React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<T>>;
+export interface LogicalDomElement {
+    contains(el: Node): boolean;
+}
+export interface LogicalDomStorage {
+    /** Registers a descendant in the logical DOM.
+     * Returns a function which disposes of the registration. */
+    registerDescendant(el: LogicalDomElement): () => void;
+}
+export declare const LogicalDomContext: any;
+/** Suppose a component B appears as a React descendant of the component A. For layout reasons,
+ * we sometimes don't want B to appear as a descendant of A in the DOM, so we use `createPortal`.
+ * We may still however want to carry out `contains` checks as if B were there, i.e. according to
+ * the React tree structure rather than the DOM structure. While React already correctly propagates
+ * DOM events up the React tree, other functionality such as `contains` is not provided. We provide
+ * it in this hook.
+ *
+ * Accepts a ref to the observed {@link HTMLElement} (A in the example). Returns:
+ * - a {@link LogicalDomElement} which provides `contains` checks for that {@link HTMLElement}; and
+ * - a {@link LogicalDomStorage} which MUST be passed to a {@link LogicalDomContext} enclosing
+ *   the observed {@link HTMLElement}.
+ *
+ * Additionally, any component which introduces a portal MUST call `registerDescendant` in the
+ * {@link LogicalDomContext} with a ref to the portalled component (B in the example). */
+export declare function useLogicalDomObserver(elt: React.RefObject<HTMLElement>): [LogicalDomElement, LogicalDomStorage];
+/**
+ * An effect which calls `onClickOutside` whenever an element not logically descending from `ld`
+ * (see {@link useLogicalDomObserver}) is clicked. Note that `onClickOutside` is not called on clicks
+ * on the scrollbar since these should usually not impact the app's state. */
+export declare function useOnClickOutside(ld: LogicalDomElement, onClickOutside: (_: PointerEvent) => void): void;
+/** Sends an exception object to a throwable error.
+ * Maps JSON Rpc errors to throwable errors.
+ */
+export declare function mapRpcError(err: unknown): Error;
+/** Catch handler for RPC methods that just returns undefined if the method is not found.
+ * This is useful for compatibility with versions of Lean that do not yet have the given RPC method.
+ */
+export declare function discardMethodNotFound(e: unknown): undefined;
+export type AsyncState<T> = {
+    state: 'loading';
+} | {
+    state: 'resolved';
+    value: T;
+} | {
+    state: 'rejected';
+    error: any;
+};
+export type AsyncWithTriggerState<T> = {
+    state: 'notStarted';
+} | AsyncState<T>;
+export declare function useAsyncWithTrigger<T>(fn: () => Promise<T>, deps?: React.DependencyList): [AsyncWithTriggerState<T>, () => Promise<void>];
+/** This React hook will run the given promise function `fn` whenever the deps change
+ * and use it to update the status and result when the promise resolves.
+ *
+ * This function prevents race conditions if the requests resolve in a
+ * different order to that which they were requested in:
+ *
+ * - Request 1 is sent with, say, line=42.
+ * - Request 2 is sent with line=90.
+ * - Request 2 returns with diags=[].
+ * - Request 1 returns with diags=['error'].
+ *
+ * Without `useAsync` we would now return the diagnostics for line 42 even though we're at line 90.
+ *
+ * When the deps change, the function immediately returns `{ state: 'loading' }`.
+ */
+export declare function useAsync<T>(fn: () => Promise<T>, deps?: React.DependencyList): AsyncState<T>;
+/** Like {@link useAsync} but never transitions from `resolved` to `loading` by internally storing
+ * the latest `resolved` state and continuing to return it while an update is in flight. The lower
+ * amount of re-renders tends to be less visually jarring.
+ */
+export declare function useAsyncPersistent<T>(fn: () => Promise<T>, deps?: React.DependencyList): AsyncState<T>;