lean4monaco 1.0.2 → 1.0.4

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

@@ -0,0 +1,141 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { InteractiveHypothesisBundle_nonAnonymousNames, TaggedText_stripTags, } from '@leanprover/infoview-api';
+import * as React from 'react';
+import { Details } from './collapsing';
+import { ConfigContext, EditorContext } from './contexts';
+import { LocationsContext, SelectableLocation } from './goalLocation';
+import { InteractiveCode } from './interactiveCode';
+import { WithTooltipOnHover } from './tooltips';
+import { useEvent } from './util';
+/** Returns true if `h` is inaccessible according to Lean's default name rendering. */
+function isInaccessibleName(h) {
+    return h.indexOf('✝') >= 0;
+}
+function goalToString(g) {
+    let ret = '';
+    if (g.userName) {
+        ret += `case ${g.userName}\n`;
+    }
+    for (const h of g.hyps) {
+        const names = InteractiveHypothesisBundle_nonAnonymousNames(h).join(' ');
+        ret += `${names} : ${TaggedText_stripTags(h.type)}`;
+        if (h.val) {
+            ret += ` := ${TaggedText_stripTags(h.val)}`;
+        }
+        ret += '\n';
+    }
+    ret += `⊢ ${TaggedText_stripTags(g.type)}`;
+    return ret;
+}
+export function goalsToString(goals) {
+    return goals.goals.map(goalToString).join('\n\n');
+}
+function getFilteredHypotheses(hyps, filter) {
+    return hyps.reduce((acc, h) => {
+        if (h.isInstance && !filter.showInstance)
+            return acc;
+        if (h.isType && !filter.showType)
+            return acc;
+        const names = filter.showHiddenAssumption ? h.names : h.names.filter(n => !isInaccessibleName(n));
+        const hNew = filter.showLetValue
+            ? { ...h, names }
+            : { ...h, names, val: undefined };
+        if (names.length !== 0)
+            acc.push(hNew);
+        return acc;
+    }, []);
+}
+function Hyp({ hyp: h, mvarId }) {
+    const locs = React.useContext(LocationsContext);
+    const namecls = (h.isInserted ? 'inserted-text ' : '') + (h.isRemoved ? 'removed-text ' : '');
+    const names = InteractiveHypothesisBundle_nonAnonymousNames(h).map((n, i) => (_jsxs("span", { className: namecls + (isInaccessibleName(n) ? 'goal-inaccessible ' : ''), children: [_jsx(SelectableLocation, { locs: locs, loc: mvarId && h.fvarIds && h.fvarIds.length > i ? { mvarId, loc: { hyp: h.fvarIds[i] } } : undefined, alwaysHighlight: false, children: n }), "\u00A0"] }, i)));
+    const typeLocs = React.useMemo(() => locs && mvarId && h.fvarIds && h.fvarIds.length > 0
+        ? { ...locs, subexprTemplate: { mvarId, loc: { hypType: [h.fvarIds[0], ''] } } }
+        : undefined, [locs, mvarId, h.fvarIds]);
+    const valLocs = React.useMemo(() => h.val && locs && mvarId && h.fvarIds && h.fvarIds.length > 0
+        ? { ...locs, subexprTemplate: { mvarId, loc: { hypValue: [h.fvarIds[0], ''] } } }
+        : undefined, [h.val, locs, mvarId, h.fvarIds]);
+    return (_jsxs("div", { children: [_jsx("strong", { className: "goal-hyp", children: names }), ":\u00A0", _jsx(LocationsContext.Provider, { value: typeLocs, children: _jsx(InteractiveCode, { fmt: h.type }) }), h.val && (_jsxs(LocationsContext.Provider, { value: valLocs, children: ["\u00A0:=\u00A0", _jsx(InteractiveCode, { fmt: h.val })] }))] }));
+}
+/**
+ * Displays the hypotheses, target type and optional case label of a goal according to the
+ * provided `filter`. */
+export const Goal = React.memo((props) => {
+    const { goal, filter, additionalClassNames } = props;
+    const config = React.useContext(ConfigContext);
+    const prefix = goal.goalPrefix ?? '⊢ ';
+    const filteredList = getFilteredHypotheses(goal.hyps, filter);
+    const hyps = filter.reverse ? filteredList.slice().reverse() : filteredList;
+    const locs = React.useContext(LocationsContext);
+    const goalLocs = React.useMemo(() => locs && goal.mvarId
+        ? { ...locs, subexprTemplate: { mvarId: goal.mvarId, loc: { target: '' } } }
+        : undefined, [locs, goal.mvarId]);
+    const goalLi = (_jsxs("div", { "data-is-goal": true, children: [_jsx("strong", { className: "goal-vdash", children: prefix }), _jsx(LocationsContext.Provider, { value: goalLocs, children: _jsx(InteractiveCode, { fmt: goal.type }) })] }, 'goal'));
+    let cn = 'font-code tl pre-wrap bl bw1 pl1 b--transparent mb3 ' + additionalClassNames;
+    if (props.goal.isInserted)
+        cn += ' b--inserted ';
+    if (props.goal.isRemoved)
+        cn += ' b--removed ';
+    const children = [
+        filter.reverse && goalLi,
+        hyps.map((h, i) => _jsx(Hyp, { hyp: h, mvarId: goal.mvarId }, i)),
+        !filter.reverse && goalLi,
+    ];
+    if (goal.userName && config.showGoalNames) {
+        return (_jsxs("details", { open: true, className: cn, children: [_jsxs("summary", { className: "mv1 pointer", children: [_jsx("strong", { className: "goal-case", children: "case " }), goal.userName] }), children] }));
+    }
+    else
+        return _jsx("div", { className: cn, children: children });
+});
+function Goals({ goals, filter, displayCount }) {
+    const nGoals = goals.goals.length;
+    const config = React.useContext(ConfigContext);
+    if (nGoals === 0) {
+        return _jsx("strong", { className: "db2 mb2 goal-goals", children: "No goals" });
+    }
+    else {
+        const unemphasizeCn = 'o-70 font-size-code-smaller';
+        return (_jsxs(_Fragment, { children: [displayCount && (_jsxs("strong", { className: "db mb2 goal-goals", children: [nGoals, " ", 1 < nGoals ? 'goals' : 'goal'] })), goals.goals.map((g, i) => (_jsx(Goal, { goal: g, filter: filter, additionalClassNames: i !== 0 && config.emphasizeFirstGoal ? unemphasizeCn : '' }, i)))] }));
+    }
+}
+/**
+ * Display goals together with a header containing the provided children as well as buttons
+ * to control how the goals are displayed.
+ */
+export const FilteredGoals = React.memo(({ headerChildren, goals, displayCount, initiallyOpen, togglingAction }) => {
+    const ec = React.useContext(EditorContext);
+    const config = React.useContext(ConfigContext);
+    const copyToCommentButton = (_jsx("a", { className: "link pointer mh2 dim codicon codicon-quote", "data-id": "copy-goal-to-comment", onClick: _ => {
+            if (goals)
+                void ec.copyToComment(goalsToString(goals));
+        }, title: "copy state to comment" }));
+    const [goalFilters, setGoalFilters] = React.useState({
+        reverse: config.reverseTacticState,
+        showType: true,
+        showInstance: true,
+        showHiddenAssumption: true,
+        showLetValue: true,
+    });
+    const sortClasses = 'link pointer mh2 dim codicon ' + (goalFilters.reverse ? 'codicon-arrow-up ' : 'codicon-arrow-down ');
+    const sortButton = (_jsx("a", { className: sortClasses, title: "reverse list", onClick: _ => {
+            setGoalFilters(s => ({ ...s, reverse: !s.reverse }));
+        } }));
+    const mkFilterButton = (filterFn, filledFn, name) => (_jsxs("a", { className: "link pointer tooltip-menu-content", onClick: _ => {
+            setGoalFilters(filterFn);
+        }, children: [_jsx("span", { className: 'tooltip-menu-icon codicon ' + (filledFn(goalFilters) ? 'codicon-check ' : 'codicon-blank '), children: "\u00A0" }), _jsx("span", { className: "tooltip-menu-text ", children: name })] }));
+    const filterMenu = (_jsxs("span", { children: [mkFilterButton(s => ({ ...s, showType: !s.showType }), gf => gf.showType, 'types'), _jsx("br", {}), mkFilterButton(s => ({ ...s, showInstance: !s.showInstance }), gf => gf.showInstance, 'instances'), _jsx("br", {}), mkFilterButton(s => ({ ...s, showHiddenAssumption: !s.showHiddenAssumption }), gf => gf.showHiddenAssumption, 'hidden assumptions'), _jsx("br", {}), mkFilterButton(s => ({ ...s, showLetValue: !s.showLetValue }), gf => gf.showLetValue, 'let-values')] }));
+    const isFiltered = !goalFilters.showInstance ||
+        !goalFilters.showType ||
+        !goalFilters.showHiddenAssumption ||
+        !goalFilters.showLetValue;
+    const filterButton = (_jsx(WithTooltipOnHover, { tooltipChildren: filterMenu, className: "dim ", children: _jsx("a", { className: 'link pointer mh2 codicon ' + (isFiltered ? 'codicon-filter-filled ' : 'codicon-filter ') }) }));
+    const setOpenRef = React.useRef();
+    useEvent(ec.events.requestedAction, _ => {
+        if (togglingAction !== undefined && setOpenRef.current !== undefined) {
+            setOpenRef.current(t => !t);
+        }
+    }, [setOpenRef, togglingAction], togglingAction);
+    return (_jsx("div", { style: { display: goals !== undefined ? 'block' : 'none' }, children: _jsxs(Details, { setOpenRef: r => (setOpenRef.current = r), initiallyOpen: initiallyOpen, children: [_jsxs("summary", { className: "mv2 pointer", children: [headerChildren, _jsxs("span", { className: "fr", onClick: e => {
+                                e.preventDefault();
+                            }, children: [copyToCommentButton, sortButton, filterButton] })] }), _jsx("div", { className: "ml1", children: goals && _jsx(Goals, { goals: goals, filter: goalFilters, displayCount: displayCount }) })] }) }));
+});

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

@@ -0,0 +1,18 @@
+import { DocumentPosition } from './util';
+type InfoKind = 'cursor' | 'pin';
+interface InfoPinnable {
+    kind: InfoKind;
+    /** Takes an argument for caching reasons, but should only ever (un)pin itself. */
+    onPin: (pos: DocumentPosition) => void;
+}
+/**
+ * Note: in the cursor view, we have to keep the cursor position as part of the component state
+ * to avoid flickering when the cursor moved. Otherwise, the component is re-initialised and the
+ * goal states reset to `undefined` on cursor moves.
+ */
+export type InfoProps = InfoPinnable & {
+    pos: DocumentPosition;
+};
+/** Fetches info from the server and renders an {@link InfoDisplay}. */
+export declare function Info(props: InfoProps): any;
+export {};

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

@@ -0,0 +1,278 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import * as React from 'react';
+import { getInteractiveDiagnostics, getInteractiveGoals, getInteractiveTermGoal, isRpcError, RpcErrorCode, Widget_getWidgets, } from '@leanprover/infoview-api';
+import { ConfigContext, EditorContext, EnvPosContext, LspDiagnosticsContext, ProgressContext } from './contexts';
+import { GoalsLocation, LocationsContext } from './goalLocation';
+import { FilteredGoals, goalsToString } from './goals';
+import { lspDiagToInteractive, MessagesList } from './messages';
+import { RpcContext, useRpcSessionAtPos } from './rpcSessions';
+import { PanelWidgetDisplay } from './userWidget';
+import { basename, discardMethodNotFound, DocumentPosition, mapRpcError, RangeHelpers, useAsyncWithTrigger, useEvent, usePausableState, } from './util';
+const InfoStatusBar = React.memo((props) => {
+    const { kind, onPin, status, pos, isPaused, setPaused, triggerUpdate } = props;
+    const ec = React.useContext(EditorContext);
+    const statusColTable = {
+        updating: 'gold ',
+        error: 'dark-red ',
+        ready: '',
+    };
+    const statusColor = statusColTable[status];
+    const locationString = `${basename(pos.uri)}:${pos.line + 1}:${pos.character}`;
+    const isPinned = kind === 'pin';
+    return (_jsxs("summary", { style: { transition: 'color 0.5s ease' }, className: 'mv2 pointer ' + statusColor, children: [locationString, isPinned && !isPaused && ' (pinned)', !isPinned && isPaused && ' (paused)', isPinned && isPaused && ' (pinned and paused)', _jsxs("span", { className: "fr", onClick: e => {
+                    e.preventDefault();
+                }, children: [isPinned && (_jsx("a", { className: "link pointer mh2 dim codicon codicon-go-to-file", "data-id": "reveal-file-location", onClick: _ => {
+                            void ec.revealPosition(pos);
+                        }, title: "reveal file location" })), _jsx("a", { className: 'link pointer mh2 dim codicon ' + (isPinned ? 'codicon-pinned ' : 'codicon-pin '), "data-id": "toggle-pinned", onClick: _ => {
+                            onPin(pos);
+                        }, title: isPinned ? 'unpin' : 'pin' }), _jsx("a", { className: 'link pointer mh2 dim codicon ' +
+                            (isPaused ? 'codicon-debug-continue ' : 'codicon-debug-pause '), "data-id": "toggle-paused", onClick: _ => {
+                            setPaused(!isPaused);
+                        }, title: isPaused ? 'continue updating' : 'pause updating' }), _jsx("a", { className: "link pointer mh2 dim codicon codicon-refresh", "data-id": "update", onClick: _ => {
+                            void triggerUpdate();
+                        }, title: "update" })] })] }));
+});
+const InfoDisplayContent = React.memo((props) => {
+    const { pos, messages, goals, termGoal, error, userWidgets, triggerUpdate, isPaused, setPaused } = props;
+    const hasWidget = userWidgets.length > 0;
+    const hasError = !!error;
+    const hasMessages = messages.length !== 0;
+    const config = React.useContext(ConfigContext);
+    const nothingToShow = !hasError && !goals && !termGoal && !hasMessages && !hasWidget;
+    const [selectedLocs, setSelectedLocs] = React.useState([]);
+    React.useEffect(() => setSelectedLocs([]), [pos.uri, pos.line, pos.character]);
+    const locs = React.useMemo(() => ({
+        isSelected: (l) => selectedLocs.some(v => GoalsLocation.isEqual(v, l)),
+        setSelected: (l, act) => setSelectedLocs(ls => {
+            // We ensure that `selectedLocs` maintains its reference identity if the selection
+            // status of `l` didn't change.
+            const newLocs = ls.filter(v => !GoalsLocation.isEqual(v, l));
+            const wasSelected = newLocs.length !== ls.length;
+            const isSelected = typeof act === 'function' ? act(wasSelected) : act;
+            if (isSelected)
+                newLocs.push(l);
+            return wasSelected === isSelected ? ls : newLocs;
+        }),
+        subexprTemplate: undefined,
+    }), [selectedLocs]);
+    /* Adding {' '} to manage string literals properly: https://reactjs.org/docs/jsx-in-depth.html#string-literals-1 */
+    return (_jsxs(_Fragment, { children: [hasError && (_jsxs("div", { className: "error", children: ["Error updating: ", error, ".", _jsxs("a", { className: "link pointer dim", onClick: e => {
+                            e.preventDefault();
+                            void triggerUpdate();
+                        }, children: [' ', "Try again."] })] }, "errors")), _jsx(LocationsContext.Provider, { value: locs, children: _jsx(FilteredGoals, { headerChildren: "Tactic state", initiallyOpen: true, goals: goals, displayCount: true }, "goals") }), _jsx(FilteredGoals, { headerChildren: "Expected type", goals: termGoal !== undefined ? { goals: [termGoal] } : undefined, initiallyOpen: config.showExpectedType, displayCount: false, togglingAction: "toggleExpectedType" }, "term-goal"), userWidgets.map(widget => {
+                const inner = (_jsx(PanelWidgetDisplay, { pos: pos, goals: goals ? goals.goals : [], termGoal: termGoal, selectedLocations: selectedLocs, widget: widget }, `widget::${widget.id}::${widget.range?.toString()}`));
+                if (widget.name)
+                    return (_jsxs("details", { open: true, children: [_jsx("summary", { className: "mv2 pointer", children: widget.name }), inner] }, `widget::${widget.id}::${widget.range?.toString()}`));
+                else
+                    return inner;
+            }), _jsx("div", { style: { display: hasMessages ? 'block' : 'none' }, children: _jsxs("details", { open: true, children: [_jsxs("summary", { className: "mv2 pointer", children: ["Messages (", messages.length, ")"] }), _jsx("div", { className: "ml1", children: _jsx(MessagesList, { uri: pos.uri, messages: messages }) })] }, "messages") }, "messages"), nothingToShow &&
+                (isPaused ? (
+                /* Adding {' '} to manage string literals properly: https://reactjs.org/docs/jsx-in-depth.html#string-literals-1 */
+                _jsxs("span", { children: ["Updating is paused.", ' ', _jsx("a", { className: "link pointer dim", onClick: e => {
+                                e.preventDefault();
+                                void triggerUpdate();
+                            }, children: "Refresh" }), ' ', "or", ' ', _jsx("a", { className: "link pointer dim", onClick: e => {
+                                e.preventDefault();
+                                setPaused(false);
+                            }, children: "resume updating" }), ' ', "to see information."] })) : ('No info found.'))] }));
+});
+/** Displays goal state and messages. Can be paused. */
+function InfoDisplay(props0) {
+    // Used to update the paused state *just once* if it is paused,
+    // but a display update is triggered
+    const [shouldRefresh, setShouldRefresh] = React.useState(false);
+    const [{ isPaused, setPaused }, props, propsRef] = usePausableState(false, props0);
+    if (shouldRefresh) {
+        propsRef.current = props0;
+        setShouldRefresh(false);
+    }
+    const triggerDisplayUpdate = async () => {
+        await props0.triggerUpdate();
+        setShouldRefresh(true);
+    };
+    const { kind, goals, rpcSess } = props;
+    const ec = React.useContext(EditorContext);
+    // If we are the cursor infoview, then we should subscribe to
+    // some commands from the editor extension
+    const isCursor = kind === 'cursor';
+    useEvent(ec.events.requestedAction, _ => {
+        if (!isCursor)
+            return;
+        if (goals)
+            void ec.copyToComment(goalsToString(goals));
+    }, [isCursor, goals, ec], 'copyToComment');
+    useEvent(ec.events.requestedAction, _ => {
+        if (!isCursor)
+            return;
+        setPaused(isPaused => !isPaused);
+    }, [isCursor, setPaused], 'togglePaused');
+    return (_jsx(RpcContext.Provider, { value: rpcSess, children: _jsx(EnvPosContext.Provider, { value: props.pos, children: _jsxs("details", { open: true, children: [_jsx(InfoStatusBar, { ...props, triggerUpdate: triggerDisplayUpdate, isPaused: isPaused, setPaused: setPaused }), _jsx("div", { className: "ml1", children: _jsx(InfoDisplayContent, { ...props, triggerUpdate: triggerDisplayUpdate, isPaused: isPaused, setPaused: setPaused }) })] }) }) }));
+}
+/** Fetches info from the server and renders an {@link InfoDisplay}. */
+export function Info(props) {
+    if (props.kind === 'cursor')
+        return _jsx(InfoAtCursor, { ...props });
+    else
+        return _jsx(InfoAux, { ...props, pos: props.pos });
+}
+function InfoAtCursor(props) {
+    const ec = React.useContext(EditorContext);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const [curLoc, setCurLoc] = React.useState(ec.events.changedCursorLocation.current);
+    useEvent(ec.events.changedCursorLocation, loc => loc && setCurLoc(loc), []);
+    const pos = { uri: curLoc.uri, ...curLoc.range.start };
+    return _jsx(InfoAux, { ...props, pos: pos });
+}
+function useIsProcessingAt(p) {
+    const allProgress = React.useContext(ProgressContext);
+    const processing = allProgress.get(p.uri);
+    if (!processing)
+        return false;
+    return processing.some(i => RangeHelpers.contains(i.range, p));
+}
+function InfoAux(props) {
+    const config = React.useContext(ConfigContext);
+    const pos = props.pos;
+    const rpcSess = useRpcSessionAtPos(pos);
+    // Compute the LSP diagnostics at this info's position. We try to ensure that if these remain
+    // the same, then so does the identity of `lspDiagsHere` so that it can be used as a dep.
+    const lspDiags = React.useContext(LspDiagnosticsContext);
+    const [lspDiagsHere, setLspDiagsHere] = React.useState([]);
+    React.useEffect(() => {
+        // Note: the curly braces are important. https://medium.com/geekculture/react-uncaught-typeerror-destroy-is-not-a-function-192738a6e79b
+        setLspDiagsHere(diags0 => {
+            const diagPred = (d) => RangeHelpers.contains(d.fullRange || d.range, { line: pos.line, character: pos.character }, config.allErrorsOnLine);
+            const newDiags = (lspDiags.get(pos.uri) || []).filter(diagPred);
+            if (newDiags.length === diags0.length && newDiags.every((d, i) => d === diags0[i]))
+                return diags0;
+            return newDiags;
+        });
+    }, [lspDiags, pos.uri, pos.line, pos.character, config.allErrorsOnLine]);
+    const serverIsProcessing = useIsProcessingAt(pos);
+    // This is a virtual dep of the info-requesting function. It is bumped whenever the Lean server
+    // indicates that another request should be made. Bumping it dirties the dep state of
+    // `useAsyncWithTrigger` below, causing the `useEffect` lower down in this component to
+    // make the request. We cannot simply call `triggerUpdateCore` because `useAsyncWithTrigger`
+    // does not support reentrancy like that.
+    const [updaterTick, setUpdaterTick] = React.useState(0);
+    const [state, triggerUpdateCore] = useAsyncWithTrigger(() => new Promise((resolve, reject) => {
+        const goalsReq = getInteractiveGoals(rpcSess, DocumentPosition.toTdpp(pos));
+        const termGoalReq = getInteractiveTermGoal(rpcSess, DocumentPosition.toTdpp(pos));
+        const widgetsReq = Widget_getWidgets(rpcSess, pos).catch(discardMethodNotFound);
+        const messagesReq = getInteractiveDiagnostics(rpcSess, { start: pos.line, end: pos.line + 1 })
+            // fall back to non-interactive diagnostics when lake fails
+            // (see https://github.com/leanprover/vscode-lean4/issues/90)
+            .then(diags => (diags.length === 0 ? lspDiagsHere.map(lspDiagToInteractive) : diags));
+        // While `lake print-paths` is running, the output of Lake is shown as
+        // info diagnostics on line 1.  However, all RPC requests block until
+        // Lake is finished, so we don't see these diagnostics while Lake is
+        // building. Therefore we show the LSP diagnostics on line 1 if the
+        // server does not respond within half a second.
+        // The same is true for fatal header diagnostics like the stale dependency notification.
+        const isAllHeaderDiags = lspDiagsHere.length > 0 && lspDiagsHere.every(diag => diag.range.start.line === 0);
+        if (isAllHeaderDiags) {
+            setTimeout(() => resolve({
+                pos,
+                status: 'updating',
+                messages: lspDiagsHere.map(lspDiagToInteractive),
+                goals: undefined,
+                termGoal: undefined,
+                error: undefined,
+                userWidgets: [],
+                rpcSess,
+            }), 500);
+        }
+        // NB: it is important to await await reqs at once, otherwise
+        // if both throw then one exception becomes unhandled.
+        Promise.all([goalsReq, termGoalReq, widgetsReq, messagesReq]).then(([goals, termGoal, userWidgets, messages]) => resolve({
+            pos,
+            status: 'ready',
+            messages,
+            goals,
+            termGoal,
+            error: undefined,
+            userWidgets: userWidgets?.widgets ?? [],
+            rpcSess,
+        }), ex => {
+            if (ex?.code === RpcErrorCode.ContentModified || ex?.code === RpcErrorCode.RpcNeedsReconnect) {
+                // Document has been changed since we made the request, or we need to reconnect
+                // to the RPC sessions. Try again.
+                setUpdaterTick(t => t + 1);
+                reject('retry');
+            }
+            let errorString = '';
+            if (typeof ex === 'string') {
+                errorString = ex;
+            }
+            else if (isRpcError(ex)) {
+                errorString = mapRpcError(ex).message;
+            }
+            else if (ex instanceof Error) {
+                errorString = ex.toString();
+            }
+            else {
+                errorString = `Unrecognized error: ${JSON.stringify(ex)}`;
+            }
+            resolve({
+                pos,
+                status: 'error',
+                messages: lspDiagsHere.map(lspDiagToInteractive),
+                goals: undefined,
+                termGoal: undefined,
+                error: `Error fetching goals: ${errorString}`,
+                userWidgets: [],
+                rpcSess,
+            });
+        });
+    }), [updaterTick, pos.uri, pos.line, pos.character, rpcSess, serverIsProcessing, lspDiagsHere]);
+    // We use a timeout to debounce info requests. Whenever a request is already scheduled
+    // but something happens that warrants a request for newer info, we cancel the old request
+    // and schedule just the new one.
+    const updaterTimeout = React.useRef();
+    const clearUpdaterTimeout = () => {
+        if (updaterTimeout.current) {
+            window.clearTimeout(updaterTimeout.current);
+            updaterTimeout.current = undefined;
+        }
+    };
+    const triggerUpdate = React.useCallback(() => new Promise(resolve => {
+        clearUpdaterTimeout();
+        const tm = window.setTimeout(() => {
+            void triggerUpdateCore().then(resolve);
+            updaterTimeout.current = undefined;
+        }, config.debounceTime);
+        // Hack: even if the request is cancelled, the promise should resolve so that no `await`
+        // is left waiting forever. We ensure this happens in a simple way.
+        window.setTimeout(resolve, config.debounceTime);
+        updaterTimeout.current = tm;
+    }), [triggerUpdateCore, config.debounceTime]);
+    const [displayProps, setDisplayProps] = React.useState({
+        pos,
+        status: 'updating',
+        messages: [],
+        goals: undefined,
+        termGoal: undefined,
+        error: undefined,
+        userWidgets: [],
+        rpcSess,
+        triggerUpdate,
+    });
+    // Propagates changes in the state of async info requests to the display props,
+    // and re-requests info if needed.
+    // This effect triggers new requests for info whenever need. It also propagates changes
+    // in the state of the `useAsyncWithTrigger` to the displayed props.
+    React.useEffect(() => {
+        if (state.state === 'notStarted')
+            void triggerUpdate();
+        else if (state.state === 'loading')
+            setDisplayProps(dp => ({ ...dp, status: 'updating' }));
+        else if (state.state === 'resolved') {
+            setDisplayProps({ ...state.value, triggerUpdate });
+        }
+        else if (state.state === 'rejected' && state.error !== 'retry') {
+            // The code inside `useAsyncWithTrigger` may only ever reject with a `retry` exception.
+            console.warn('Unreachable code reached with error: ', state.error);
+        }
+    }, [state, triggerUpdate]);
+    return _jsx(InfoDisplay, { kind: props.kind, onPin: props.onPin, ...displayProps });
+}

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

@@ -0,0 +1,2 @@
+/** Manages and displays pinned infos, as well as info for the current location. */
+export declare function Infos(): any;

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

@@ -0,0 +1,113 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createElement as _createElement } from "react";
+import * as React from 'react';
+import { TextDocumentContentChangeEvent, } from 'vscode-languageserver-protocol';
+import { EditorContext } from './contexts';
+import { Info } from './info';
+import { DocumentPosition, PositionHelpers, useClientNotificationEffect, useClientNotificationState, useEvent, useEventResult, } from './util';
+function isPinned(pinnedPositions, pos) {
+    return pinnedPositions.some(p => DocumentPosition.isEqual(p, pos));
+}
+/** Manages and displays pinned infos, as well as info for the current location. */
+export function Infos() {
+    const ec = React.useContext(EditorContext);
+    // Update pins when the document changes. In particular, when edits are made
+    // earlier in the text such that a pin has to move up or down.
+    const [pinnedPositions, setPinnedPositions] = useClientNotificationState('textDocument/didChange', new Array(), (pinnedPositions, params) => {
+        if (pinnedPositions.length === 0)
+            return pinnedPositions;
+        let changed = false;
+        const newPins = pinnedPositions.map(pin => {
+            if (pin.uri !== params.textDocument.uri)
+                return pin;
+            // NOTE(WN): It's important to make a clone here, otherwise this
+            // actually mutates the pin. React state updates must be pure.
+            // See https://github.com/facebook/react/issues/12856
+            const newPin = { ...pin };
+            for (const chg of params.contentChanges) {
+                if (!TextDocumentContentChangeEvent.isIncremental(chg)) {
+                    changed = true;
+                    return null;
+                }
+                if (PositionHelpers.isLessThanOrEqual(newPin, chg.range.start))
+                    continue;
+                // We can assume chg.range.start < pin
+                // If the pinned position is replaced with new text, just delete the pin.
+                if (PositionHelpers.isLessThanOrEqual(newPin, chg.range.end)) {
+                    changed = true;
+                    return null;
+                }
+                const oldPin = { ...newPin };
+                // How many lines before the pin position were added by the change.
+                // Can be negative when more lines are removed than added.
+                let additionalLines = 0;
+                let lastLineLen = chg.range.start.character;
+                for (const c of chg.text)
+                    if (c === '\n') {
+                        additionalLines++;
+                        lastLineLen = 0;
+                    }
+                    else
+                        lastLineLen++;
+                // Subtract lines that were already present
+                additionalLines -= chg.range.end.line - chg.range.start.line;
+                newPin.line += additionalLines;
+                if (oldPin.line < chg.range.end.line) {
+                    // Should never execute by the <= check above.
+                    throw new Error('unreachable code reached');
+                }
+                else if (oldPin.line === chg.range.end.line) {
+                    newPin.character = lastLineLen + (oldPin.character - chg.range.end.character);
+                }
+            }
+            if (!DocumentPosition.isEqual(newPin, pin))
+                changed = true;
+            // NOTE(WN): We maintain the `key` when a pin is moved around to maintain
+            // its component identity and minimise flickering.
+            return newPin;
+        });
+        if (changed)
+            return newPins.filter(p => p !== null);
+        return pinnedPositions;
+    }, []);
+    // Remove pins for closed documents
+    useClientNotificationEffect('textDocument/didClose', (params) => {
+        setPinnedPositions(pinnedPositions => pinnedPositions.filter(p => p.uri !== params.textDocument.uri));
+    }, []);
+    const curPos = useEventResult(ec.events.changedCursorLocation, loc => loc ? { uri: loc.uri, ...loc.range.start } : undefined);
+    // Update pins on UI actions
+    const pinKey = React.useRef(0);
+    const pin = React.useCallback((pos) => {
+        setPinnedPositions(pinnedPositions => {
+            if (isPinned(pinnedPositions, pos))
+                return pinnedPositions;
+            pinKey.current += 1;
+            return [...pinnedPositions, { ...pos, key: pinKey.current.toString() }];
+        });
+    }, [setPinnedPositions]);
+    const unpin = React.useCallback((pos) => {
+        setPinnedPositions(pinnedPositions => {
+            if (!isPinned(pinnedPositions, pos))
+                return pinnedPositions;
+            return pinnedPositions.filter(p => !DocumentPosition.isEqual(p, pos));
+        });
+    }, [setPinnedPositions]);
+    // Toggle pin at current position when the editor requests it
+    useEvent(ec.events.requestedAction, _ => {
+        if (!curPos)
+            return;
+        setPinnedPositions(pinnedPositions => {
+            if (isPinned(pinnedPositions, curPos)) {
+                return pinnedPositions.filter(p => !DocumentPosition.isEqual(p, curPos));
+            }
+            else {
+                pinKey.current += 1;
+                return [...pinnedPositions, { ...curPos, key: pinKey.current.toString() }];
+            }
+        });
+    }, [curPos?.uri, curPos?.line, curPos?.character, setPinnedPositions, pinKey], 'togglePin');
+    const infoProps = pinnedPositions.map(pos => ({ kind: 'pin', onPin: unpin, pos, key: pos.key }));
+    if (curPos)
+        infoProps.push({ kind: 'cursor', onPin: pin, key: 'cursor', pos: curPos });
+    return (_jsxs("div", { children: [infoProps.map(ps => (_createElement(Info, { ...ps, key: ps.key }))), !curPos && _jsx("p", { children: "Click somewhere in the Lean file to enable the infoview." })] }));
+}

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

@@ -0,0 +1,18 @@
+import { SubexprInfo, TaggedText } from '@leanprover/infoview-api';
+export interface InteractiveTextComponentProps<T> {
+    fmt: TaggedText<T>;
+}
+export interface InteractiveTagProps<T> extends InteractiveTextComponentProps<T> {
+    tag: T;
+}
+export interface InteractiveTaggedTextProps<T> extends InteractiveTextComponentProps<T> {
+    InnerTagUi: (_: InteractiveTagProps<T>) => JSX.Element;
+}
+/**
+ * Core loop to display {@link TaggedText} objects. Invokes `InnerTagUi` on `tag` nodes in order to support
+ * various embedded information, for example subexpression information stored in {@link CodeWithInfos}.
+ * */
+export declare function InteractiveTaggedText<T>({ fmt, InnerTagUi }: InteractiveTaggedTextProps<T>): any;
+export type InteractiveCodeProps = InteractiveTextComponentProps<SubexprInfo>;
+/** Displays a {@link CodeWithInfos} obtained via RPC from the Lean server. */
+export declare function InteractiveCode(props: InteractiveCodeProps): any;