lean4monaco 1.0.2 → 1.0.4

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

@@ -0,0 +1,164 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from 'react';
+import { getGoToLocation, InteractiveDiagnostics_infoToInteractive, TaggedText_stripTags, } from '@leanprover/infoview-api';
+import { marked } from 'marked';
+import { EditorContext } from './contexts';
+import { GoalsLocation, LocationsContext, SelectableLocation } from './goalLocation';
+import { useRpcSession } from './rpcSessions';
+import { WithToggleableTooltip, WithTooltipOnHover } from './tooltips';
+import { mapRpcError, useAsync, useEvent } from './util';
+/**
+ * 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 function InteractiveTaggedText({ fmt, InnerTagUi }) {
+    if ('text' in fmt)
+        return _jsx(_Fragment, { children: fmt.text });
+    else if ('append' in fmt)
+        return (_jsx(_Fragment, { children: fmt.append.map((a, i) => (_jsx(InteractiveTaggedText, { fmt: a, InnerTagUi: InnerTagUi }, i))) }));
+    else if ('tag' in fmt)
+        return _jsx(InnerTagUi, { fmt: fmt.tag[1], tag: fmt.tag[0] });
+    else
+        throw new Error(`malformed 'TaggedText': '${fmt}'`);
+}
+function Markdown({ contents }) {
+    const renderer = new marked.Renderer();
+    renderer.code = (code, lang) => {
+        // todo: render Lean code blocks using the lean syntax.json
+        return `<div class="font-code pre-wrap">${code}</div>`;
+    };
+    renderer.codespan = code => {
+        return `<code class="font-code">${code}</code>`;
+    };
+    const markedOptions = {};
+    markedOptions.sanitizer = (html) => {
+        return '';
+    };
+    markedOptions.sanitize = true;
+    markedOptions.silent = true;
+    markedOptions.renderer = renderer;
+    // todo: vscode also has lots of post render sanitization and hooking up of href clicks and so on.
+    // see https://github.com/microsoft/vscode/blob/main/src/vs/base/browser/markdownRenderer.ts
+    const renderedMarkdown = marked.parse(contents, markedOptions);
+    return _jsx("div", { dangerouslySetInnerHTML: { __html: renderedMarkdown } });
+    // handy for debugging:
+    // return <div>{ renderedMarkdown } </div>
+}
+/** Shows `explicitValue : itsType` and a docstring if there is one. */
+function TypePopupContents({ info }) {
+    const rs = useRpcSession();
+    // When `err` is defined we show the error,
+    // otherwise if `ip` is defined we show its contents,
+    // otherwise a 'loading' message.
+    const interactive = useAsync(() => InteractiveDiagnostics_infoToInteractive(rs, info.info), [rs, info.info]);
+    // Even when subexpressions are selectable in our parent component, it doesn't make sense
+    // to select things inside the *type* of the parent, so we clear the context.
+    // NOTE: selecting in the explicit term does make sense but it complicates the implementation
+    // so let's not add it until someone really wants it.
+    return (_jsx(LocationsContext.Provider, { value: undefined, children: _jsx("div", { className: "tooltip-code-content", children: interactive.state === 'resolved' ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: "font-code tl pre-wrap", children: [interactive.value.exprExplicit && _jsx(InteractiveCode, { fmt: interactive.value.exprExplicit }), ' ', ": ", interactive.value.type && _jsx(InteractiveCode, { fmt: interactive.value.type })] }), interactive.value.doc && (_jsxs(_Fragment, { children: [_jsx("hr", {}), _jsx(Markdown, { contents: interactive.value.doc })] })), info.diffStatus && (_jsxs(_Fragment, { children: [_jsx("hr", {}), _jsx("div", { children: DIFF_TAG_TO_EXPLANATION[info.diffStatus] })] }))] })) : interactive.state === 'rejected' ? (_jsxs(_Fragment, { children: ["Error: ", mapRpcError(interactive.error).message] })) : (_jsx(_Fragment, { children: "Loading.." })) }) }));
+}
+const DIFF_TAG_TO_CLASS = {
+    wasChanged: 'inserted-text',
+    willChange: 'removed-text',
+    wasInserted: 'inserted-text',
+    willInsert: 'inserted-text',
+    willDelete: 'removed-text',
+    wasDeleted: 'removed-text',
+};
+const DIFF_TAG_TO_EXPLANATION = {
+    wasChanged: 'This subexpression has been modified.',
+    willChange: 'This subexpression will be modified.',
+    wasInserted: 'This subexpression has been inserted.',
+    willInsert: 'This subexpression will be inserted.',
+    wasDeleted: 'This subexpression has been removed.',
+    willDelete: 'This subexpression will be deleted.',
+};
+/**
+ * Tagged spans can be hovered over to display extra info stored in the associated `SubexprInfo`.
+ * Moreover if this component is rendered in a context where locations can be selected, the span
+ * can be shift-clicked to select it.
+ */
+function InteractiveCodeTag({ tag: ct, fmt }) {
+    const rs = useRpcSession();
+    const ec = React.useContext(EditorContext);
+    const [hoverState, setHoverState] = React.useState('off');
+    const [goToDefErrorState, setGoToDefErrorState] = React.useState(false);
+    // We mimick the VSCode ctrl-hover and ctrl-click UI for go-to-definition
+    const [goToLoc, setGoToLoc] = React.useState(undefined);
+    const fetchGoToLoc = React.useCallback(async () => {
+        if (goToLoc !== undefined)
+            return goToLoc;
+        try {
+            const lnks = await getGoToLocation(rs, 'definition', ct.info);
+            if (lnks.length > 0) {
+                const loc = { uri: lnks[0].targetUri, range: lnks[0].targetSelectionRange };
+                setGoToLoc(loc);
+                return loc;
+            }
+        }
+        catch (e) {
+            console.error('Error in go-to-definition: ', JSON.stringify(e));
+        }
+        return undefined;
+    }, [rs, ct.info, goToLoc]);
+    // Eagerly fetch the location as soon as the pointer enters this area so that we can show
+    // an underline if a jump target is available.
+    React.useEffect(() => {
+        if (hoverState === 'ctrlOver')
+            void fetchGoToLoc();
+    }, [hoverState, fetchGoToLoc]);
+    const execGoToLoc = React.useCallback(async (withError) => {
+        const loc = await fetchGoToLoc();
+        if (loc === undefined) {
+            if (withError) {
+                setGoToDefErrorState(true);
+            }
+            return;
+        }
+        await ec.revealPosition({ uri: loc.uri, ...loc.range.start });
+    }, [fetchGoToLoc, ec]);
+    const locs = React.useContext(LocationsContext);
+    const ourLoc = locs && locs.subexprTemplate && ct.subexprPos
+        ? GoalsLocation.withSubexprPos(locs.subexprTemplate, ct.subexprPos)
+        : undefined;
+    let spanClassName = hoverState === 'ctrlOver' && goToLoc !== undefined ? 'underline ' : '';
+    if (ct.diffStatus) {
+        spanClassName += DIFF_TAG_TO_CLASS[ct.diffStatus] + ' ';
+    }
+    // ID that we can use to identify the component that a context menu was opened in.
+    // When selecting a custom context menu entry, VS Code will execute a VS Code command
+    // parameterized with `data-vscode-context`. We then use this context to execute the
+    // command in the context of the correct interactive code tag in the InfoView.
+    const interactiveCodeTagId = React.useId();
+    const vscodeContext = { interactiveCodeTagId };
+    useEvent(ec.events.goToDefinition, async (_) => void execGoToLoc(true), [execGoToLoc], interactiveCodeTagId);
+    return (_jsx(WithToggleableTooltip, { tooltipChildren: `No definition found for '${TaggedText_stripTags(fmt)}'`, isTooltipShown: goToDefErrorState, hideTooltip: () => setGoToDefErrorState(false), children: _jsx(WithTooltipOnHover, { "data-vscode-context": JSON.stringify(vscodeContext), "data-has-tooltip-on-hover": true, tooltipChildren: _jsx(TypePopupContents, { info: ct }), onClick: (e, next) => {
+                // On ctrl-click or ⌘-click, if location is known, go to it in the editor
+                if (e.ctrlKey || e.metaKey) {
+                    setHoverState(st => (st === 'over' ? 'ctrlOver' : st));
+                    void execGoToLoc(false);
+                }
+                else if (!e.shiftKey)
+                    next(e);
+            }, onContextMenu: e => {
+                // Mark the event as seen so that parent handlers skip it.
+                // We cannot use `stopPropagation` as that prevents the VSC context menu from showing up.
+                if ('_InteractiveCodeTagSeen' in e)
+                    return;
+                e._InteractiveCodeTagSeen = {};
+                if (!(e.target instanceof Node))
+                    return;
+                if (!e.currentTarget.contains(e.target))
+                    return;
+                // Select the pretty-printed code.
+                const sel = window.getSelection();
+                if (!sel)
+                    return;
+                sel.removeAllRanges();
+                sel.selectAllChildren(e.currentTarget);
+            }, children: _jsx(SelectableLocation, { setHoverState: setHoverState, className: spanClassName, locs: locs, loc: ourLoc, alwaysHighlight: true, children: _jsx(InteractiveCode, { fmt: fmt }) }) }) }));
+}
+/** Displays a {@link CodeWithInfos} obtained via RPC from the Lean server. */
+export function InteractiveCode(props) {
+    return (_jsx("span", { className: "font-code", children: _jsx(InteractiveTaggedText, { ...props, InnerTagUi: InteractiveCodeTag }) }));
+}

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

@@ -0,0 +1,13 @@
+import '@vscode/codicons/dist/codicon.css';
+import '@vscode/codicons/dist/codicon.ttf';
+import 'tachyons/css/tachyons.css';
+import './index.css';
+import { EditorApi, InfoviewApi } from '@leanprover/infoview-api';
+/**
+ * Render the Lean infoview into the DOM element `uiElement`.
+ *
+ * @param editorApi is a collection of methods which the infoview needs to be able to invoke
+ * on the editor in order to function correctly (such as inserting text or moving the cursor).
+ * @returns a collection of methods which must be invoked when the relevant editor events occur.
+ */
+export declare function renderInfoview(editorApi: EditorApi, uiElement: HTMLElement): InfoviewApi;

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

@@ -0,0 +1,97 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { VSCodeButton } from '@vscode/webview-ui-toolkit/react';
+import * as React from 'react';
+import * as ReactDOM from 'react-dom/client';
+import '@vscode/codicons/dist/codicon.css';
+import '@vscode/codicons/dist/codicon.ttf';
+import 'tachyons/css/tachyons.css';
+import './index.css';
+import { defaultInfoviewConfig, } from '@leanprover/infoview-api';
+import { ConfigContext, EditorContext, ProgressContext, VersionContext } from './contexts';
+import { EditorConnection } from './editorConnection';
+import { EventEmitter } from './event';
+import { Infos } from './infos';
+import { AllMessages, WithLspDiagnosticsContext } from './messages';
+import { WithRpcSessions } from './rpcSessions';
+import { ServerVersion } from './serverVersion';
+import { useClientNotificationEffect, useEventResult, useServerNotificationState } from './util';
+function Main(props) {
+    const ec = React.useContext(EditorContext);
+    /* Set up updates to the global infoview state on editor events. */
+    const config = useEventResult(ec.events.changedInfoviewConfig) ?? defaultInfoviewConfig;
+    const [allProgress, _1] = useServerNotificationState('$/lean/fileProgress', new Map(), async (params) => allProgress => {
+        const newProgress = new Map(allProgress);
+        return newProgress.set(params.textDocument.uri, params.processing);
+    }, []);
+    const curUri = useEventResult(ec.events.changedCursorLocation, loc => loc?.uri);
+    useClientNotificationEffect('textDocument/didClose', (params) => {
+        if (ec.events.changedCursorLocation.current &&
+            ec.events.changedCursorLocation.current.uri === params.textDocument.uri) {
+            ec.events.changedCursorLocation.fire(undefined);
+        }
+    }, []);
+    const serverVersion = useEventResult(ec.events.serverRestarted, result => new ServerVersion(result.serverInfo?.version ?? ''));
+    const serverStoppedResult = useEventResult(ec.events.serverStopped);
+    // NB: the cursor may temporarily become `undefined` when a file is closed. In this case
+    // it's important not to reconstruct the `WithBlah` wrappers below since they contain state
+    // that we want to persist.
+    let ret;
+    if (!serverVersion) {
+        ret = _jsx("p", { children: "Waiting for Lean server to start..." });
+    }
+    else if (serverStoppedResult) {
+        ret = (_jsxs("div", { children: [_jsx("p", { children: serverStoppedResult.message }), _jsx("p", { className: "error", children: serverStoppedResult.reason })] }));
+    }
+    else {
+        ret = (_jsxs("div", { className: "ma1", children: [_jsx(Infos, {}), curUri && (_jsx("div", { className: "mv2", children: _jsx(AllMessages, { uri: curUri }) })), curUri && (_jsx(VSCodeButton, { className: "restart-file-button", onClick: _ => ec.api.restartFile(curUri), title: "Restarts this file, rebuilding all of its outdated dependencies.", children: "Restart File" }))] }));
+    }
+    return (_jsx(ConfigContext.Provider, { value: config, children: _jsx(VersionContext.Provider, { value: serverVersion, children: _jsx(WithRpcSessions, { children: _jsx(WithLspDiagnosticsContext, { children: _jsx(ProgressContext.Provider, { value: allProgress, children: ret }) }) }) }) }));
+}
+/**
+ * Render the Lean infoview into the DOM element `uiElement`.
+ *
+ * @param editorApi is a collection of methods which the infoview needs to be able to invoke
+ * on the editor in order to function correctly (such as inserting text or moving the cursor).
+ * @returns a collection of methods which must be invoked when the relevant editor events occur.
+ */
+export function renderInfoview(editorApi, uiElement) {
+    const editorEvents = {
+        initialize: new EventEmitter(),
+        gotServerNotification: new EventEmitter(),
+        sentClientNotification: new EventEmitter(),
+        serverRestarted: new EventEmitter(),
+        serverStopped: new EventEmitter(),
+        changedCursorLocation: new EventEmitter(),
+        changedInfoviewConfig: new EventEmitter(),
+        runTestScript: new EventEmitter(),
+        requestedAction: new EventEmitter(),
+        goToDefinition: new EventEmitter(),
+    };
+    // Challenge: write a type-correct fn from `Eventify<T>` to `T` without using `any`
+    const infoviewApi = {
+        initialize: async (l) => editorEvents.initialize.fire(l),
+        gotServerNotification: async (method, params) => {
+            editorEvents.gotServerNotification.fire([method, params]);
+        },
+        sentClientNotification: async (method, params) => {
+            editorEvents.sentClientNotification.fire([method, params]);
+        },
+        serverRestarted: async (r) => editorEvents.serverRestarted.fire(r),
+        serverStopped: async (serverStoppedReason) => {
+            editorEvents.serverStopped.fire(serverStoppedReason);
+        },
+        changedCursorLocation: async (loc) => editorEvents.changedCursorLocation.fire(loc),
+        changedInfoviewConfig: async (conf) => editorEvents.changedInfoviewConfig.fire(conf),
+        requestedAction: async (action) => editorEvents.requestedAction.fire(action, action.kind),
+        goToDefinition: async (id) => editorEvents.goToDefinition.fire(id, id),
+        // See https://rollupjs.org/guide/en/#avoiding-eval
+        // eslint-disable-next-line @typescript-eslint/no-implied-eval
+        runTestScript: async (script) => new Function(script)(),
+        getInfoviewHtml: async () => document.body.innerHTML,
+    };
+    const ec = new EditorConnection(editorApi, editorEvents);
+    editorEvents.initialize.on((loc) => ec.events.changedCursorLocation.fire(loc));
+    const root = ReactDOM.createRoot(uiElement);
+    root.render(_jsx(React.StrictMode, { children: _jsx(EditorContext.Provider, { value: ec, children: _jsx(Main, {}) }) }));
+    return infoviewApi;
+}

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

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { Diagnostic, DocumentUri } from 'vscode-languageserver-protocol';
+import { InteractiveDiagnostic } from '@leanprover/infoview-api';
+/** Shows the given messages assuming they are for the given file. */
+export declare const MessagesList: any;
+/** Displays all messages for the specified file. Can be paused. */
+export declare function AllMessages({ uri: uri0 }: {
+    uri: DocumentUri;
+}): any;
+/**
+ * Provides a `LspDiagnosticsContext` which stores the latest version of the
+ * diagnostics as sent by the publishDiagnostics notification.
+ */
+export declare function WithLspDiagnosticsContext({ children }: React.PropsWithChildren<{}>): any;
+/** Embeds a non-interactive diagnostic into the type `InteractiveDiagnostic`. */
+export declare function lspDiagToInteractive(diag: Diagnostic): InteractiveDiagnostic;

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

@@ -0,0 +1,151 @@
+import { createElement as _createElement } from "react";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import * as React from 'react';
+import fastIsEqual from 'react-fast-compare';
+import { DiagnosticSeverity, } from 'vscode-languageserver-protocol';
+import { RpcErrorCode } from '@leanprover/infoview-api';
+import { getInteractiveDiagnostics } from '@leanprover/infoview-api';
+import { Details } from './collapsing';
+import { ConfigContext, EditorContext, EnvPosContext, LspDiagnosticsContext } from './contexts';
+import { RpcContext, useRpcSessionAtPos } from './rpcSessions';
+import { InteractiveMessage } from './traceExplorer';
+import { addUniqueKeys, basename, DocumentPosition, escapeHtml, useEvent, usePausableState, useServerNotificationState, } from './util';
+const MessageView = React.memo(({ uri, diag }) => {
+    const ec = React.useContext(EditorContext);
+    const fname = escapeHtml(basename(uri));
+    const { line, character } = diag.range.start;
+    const loc = { uri, range: diag.range };
+    /* We grab the text contents of the message from `node.innerText`. */
+    const node = React.useRef(null);
+    const severityClass = diag.severity
+        ? {
+            [DiagnosticSeverity.Error]: 'error',
+            [DiagnosticSeverity.Warning]: 'warning',
+            [DiagnosticSeverity.Information]: 'information',
+            [DiagnosticSeverity.Hint]: 'hint',
+        }[diag.severity]
+        : '';
+    const title = `${fname}:${line + 1}:${character}`;
+    const startPos = React.useMemo(() => ({ uri, ...(diag.fullRange?.start || diag.range.start) }), [uri, diag.fullRange, diag.range]);
+    return (_jsxs("details", { open: true, children: [_jsxs("summary", { className: severityClass + ' mv2 pointer', children: [title, _jsxs("span", { className: "fr", onClick: e => e.preventDefault(), children: [_jsx("a", { className: "link pointer mh2 dim codicon codicon-go-to-file", onClick: _ => {
+                                    void ec.revealLocation(loc);
+                                }, title: "reveal file location" }), _jsx("a", { className: "link pointer mh2 dim codicon codicon-quote", "data-id": "copy-to-comment", onClick: _ => {
+                                    if (node.current)
+                                        void ec.copyToComment(node.current.innerText);
+                                }, title: "copy message to comment" }), _jsx("a", { className: "link pointer mh2 dim codicon codicon-clippy", onClick: _ => {
+                                    if (node.current)
+                                        void ec.api.copyToClipboard(node.current.innerText);
+                                }, title: "copy message to clipboard" })] })] }), _jsx("div", { className: "ml1", ref: node, children: _jsx("pre", { className: "font-code pre-wrap", children: _jsx(EnvPosContext.Provider, { value: startPos, children: _jsx(InteractiveMessage, { fmt: diag.message }) }) }) })] }));
+}, fastIsEqual);
+function mkMessageViewProps(uri, messages) {
+    const views = messages
+        .sort((msga, msgb) => {
+        const a = msga.fullRange?.end || msga.range.end;
+        const b = msgb.fullRange?.end || msgb.range.end;
+        return a.line === b.line ? a.character - b.character : a.line - b.line;
+    })
+        .map(m => {
+        return { uri, diag: m };
+    });
+    return addUniqueKeys(views, v => DocumentPosition.toString({ uri: v.uri, ...v.diag.range.start }));
+}
+/** Shows the given messages assuming they are for the given file. */
+export const MessagesList = React.memo(({ uri, messages }) => {
+    const should_hide = messages.length === 0;
+    if (should_hide) {
+        return _jsx(_Fragment, { children: "No messages." });
+    }
+    return (_jsx("div", { className: "ml1", children: mkMessageViewProps(uri, messages).map(m => (_createElement(MessageView, { ...m, key: m.key }))) }));
+});
+function lazy(f) {
+    let state;
+    return () => {
+        if (!state)
+            state = { t: f() };
+        return state.t;
+    };
+}
+/** Displays all messages for the specified file. Can be paused. */
+export function AllMessages({ uri: uri0 }) {
+    const ec = React.useContext(EditorContext);
+    const rs0 = useRpcSessionAtPos({ uri: uri0, line: 0, character: 0 });
+    const dc = React.useContext(LspDiagnosticsContext);
+    const config = React.useContext(ConfigContext);
+    const diags0 = React.useMemo(() => dc.get(uri0) || [], [dc, uri0]);
+    const iDiags0 = React.useMemo(() => lazy(async () => {
+        // The last line for which we have received diagnostics so far.
+        // Providing a line range to `getInteractiveDiagnostics`
+        // ensures that the call doesn't block until the whole file is elaborated.
+        const maxLine = diags0.reduce((ln, d) => Math.max(ln, d.range.end.line), 0) + 1;
+        try {
+            const diags = await getInteractiveDiagnostics(rs0, { start: 0, end: maxLine });
+            if (diags.length > 0) {
+                return diags;
+            }
+        }
+        catch (err) {
+            if (err?.code === RpcErrorCode.ContentModified) {
+                // Document has been changed since we made the request. This can happen
+                // while typing quickly. When the server catches up on next edit, it will
+                // send new diagnostics to which the infoview responds by calling
+                // `getInteractiveDiagnostics` again.
+            }
+            else {
+                console.log('getInteractiveDiagnostics error ', err);
+            }
+        }
+        return diags0.map(d => ({ ...d, message: { text: d.message } }));
+    }), [rs0, diags0]);
+    const [{ isPaused, setPaused }, [uri, rs, diags, iDiags], _] = usePausableState(false, [uri0, rs0, diags0, iDiags0]);
+    // Fetch interactive diagnostics when we're entering the paused state
+    // (if they haven't already been fetched before)
+    React.useEffect(() => {
+        if (isPaused) {
+            void iDiags();
+        }
+    }, [iDiags, isPaused]);
+    const setOpenRef = React.useRef();
+    useEvent(ec.events.requestedAction, _ => {
+        if (setOpenRef.current !== undefined) {
+            setOpenRef.current(t => !t);
+        }
+    }, [setOpenRef], 'toggleAllMessages');
+    // The number of actually displayed messages, or `undefined` if the panel is collapsed.
+    // When `undefined`, we can approximate it by `diags.length`.
+    const [numDiags, setNumDiags] = React.useState(undefined);
+    return (_jsx(RpcContext.Provider, { value: rs, children: _jsxs(Details, { setOpenRef: r => (setOpenRef.current = r), initiallyOpen: !config.autoOpenShowsGoal, children: [_jsxs("summary", { className: "mv2 pointer", children: ["All Messages (", numDiags ?? diags.length, ")", _jsx("span", { className: "fr", onClick: e => {
+                                e.preventDefault();
+                            }, children: _jsx("a", { className: 'link pointer mh2 dim codicon ' +
+                                    (isPaused ? 'codicon-debug-continue' : 'codicon-debug-pause'), onClick: _ => {
+                                    setPaused(p => !p);
+                                }, title: isPaused ? 'continue updating' : 'pause updating' }) })] }), _jsx(AllMessagesBody, { uri: uri, messages: iDiags, setNumDiags: setNumDiags })] }) }));
+}
+/** We factor out the body of {@link AllMessages} which lazily fetches its contents only when expanded. */
+function AllMessagesBody({ uri, messages, setNumDiags }) {
+    const [msgs, setMsgs] = React.useState(undefined);
+    React.useEffect(() => {
+        const fn = async () => {
+            const msgs = await messages();
+            setMsgs(msgs);
+            setNumDiags(msgs.length);
+        };
+        void fn();
+    }, [messages, setNumDiags]);
+    React.useEffect(() => () => /* Called on unmount. */ setNumDiags(undefined), [setNumDiags]);
+    if (msgs === undefined)
+        return _jsx(_Fragment, { children: "Loading messages..." });
+    else
+        return _jsx(MessagesList, { uri: uri, messages: msgs });
+}
+/**
+ * Provides a `LspDiagnosticsContext` which stores the latest version of the
+ * diagnostics as sent by the publishDiagnostics notification.
+ */
+export function WithLspDiagnosticsContext({ children }) {
+    const [allDiags, _0] = useServerNotificationState('textDocument/publishDiagnostics', new Map(), async (params) => diags => new Map(diags).set(params.uri, params.diagnostics), []);
+    return _jsx(LspDiagnosticsContext.Provider, { value: allDiags, children: children });
+}
+/** Embeds a non-interactive diagnostic into the type `InteractiveDiagnostic`. */
+export function lspDiagToInteractive(diag) {
+    return { ...diag, message: { text: diag.message } };
+}

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

@@ -0,0 +1,21 @@
+import { RpcSessionAtPos } from '@leanprover/infoview-api';
+import * as React from 'react';
+import type { TextDocumentPositionParams } from 'vscode-languageserver-protocol';
+import { DocumentPosition } from './util';
+/**
+ * Provides a {@link RpcSessionsContext} to the children.
+ * The {@link RpcSessions} object stored there manages RPC sessions in the Lean server.
+ */
+export declare function WithRpcSessions({ children }: {
+    children: React.ReactNode;
+}): any;
+export declare function useRpcSessionAtTdpp(pos: TextDocumentPositionParams): RpcSessionAtPos;
+export declare function useRpcSessionAtPos(pos: DocumentPosition): RpcSessionAtPos;
+/** @deprecated use {@link useRpcSession} instead */
+export declare const RpcContext: any;
+/**
+ * Retrieve an RPC session at {@link EnvPosContext},
+ * if the context is set.
+ * Otherwise return a dummy session that throws on any RPC call.
+ */
+export declare function useRpcSession(): RpcSessionAtPos;

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

@@ -0,0 +1,67 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RpcSessions } from '@leanprover/infoview-api';
+import * as React from 'react';
+import { EditorContext, EnvPosContext } from './contexts';
+import { DocumentPosition, useClientNotificationEffect, useEvent } from './util';
+const RpcSessionsContext = React.createContext(undefined);
+/**
+ * Provides a {@link RpcSessionsContext} to the children.
+ * The {@link RpcSessions} object stored there manages RPC sessions in the Lean server.
+ */
+export function WithRpcSessions({ children }) {
+    const ec = React.useContext(EditorContext);
+    const [sessions] = React.useState(() => new RpcSessions({
+        createRpcSession: (uri) => ec.api.createRpcSession(uri),
+        closeRpcSession: (uri) => ec.api.closeRpcSession(uri),
+        call: (params) => ec.api.sendClientRequest(params.textDocument.uri, '$/lean/rpc/call', params),
+        release: (params) => void ec.api.sendClientNotification(params.uri, '$/lean/rpc/release', params),
+    }));
+    React.useEffect(() => {
+        // Clean up the sessions on unmount
+        return () => sessions.dispose();
+    }, [sessions]);
+    useClientNotificationEffect('textDocument/didClose', (params) => {
+        sessions.closeSessionForFile(params.textDocument.uri);
+    }, [sessions]);
+    // TODO: only restart files for the server that stopped
+    useEvent(ec.events.serverRestarted, () => sessions.closeAllSessions());
+    return _jsx(RpcSessionsContext.Provider, { value: sessions, children: children });
+}
+const noCtxRpcSession = {
+    call: async () => {
+        throw new Error('no RPC context set');
+    },
+};
+const noPosRpcSession = {
+    call: async () => {
+        throw new Error('no position context set');
+    },
+};
+export function useRpcSessionAtTdpp(pos) {
+    return React.useContext(RpcSessionsContext)?.connect(pos) || noCtxRpcSession;
+}
+export function useRpcSessionAtPos(pos) {
+    return useRpcSessionAtTdpp(DocumentPosition.toTdpp(pos));
+}
+/** @deprecated use {@link useRpcSession} instead */
+/*
+ * NOTE(WN): This context cannot be removed as of 2024-05-27 since existing widgets use it.
+ * For backwards compatibility, it must be set to the correct value by infoview code.
+ * A future major release of @leanprover/infoview could remove this context
+ * after it has been deprecated for a sufficiently long time.
+ */
+export const RpcContext = React.createContext(noCtxRpcSession);
+/**
+ * Retrieve an RPC session at {@link EnvPosContext},
+ * if the context is set.
+ * Otherwise return a dummy session that throws on any RPC call.
+ */
+export function useRpcSession() {
+    const pos = React.useContext(EnvPosContext);
+    const rsc = React.useContext(RpcSessionsContext);
+    if (!pos)
+        return noPosRpcSession;
+    if (!rsc)
+        return noCtxRpcSession;
+    return rsc.connect(DocumentPosition.toTdpp(pos));
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Keeps track of the Lean server version and available features.
+ * @module
+ */
+export declare class ServerVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    constructor(version: string);
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Keeps track of the Lean server version and available features.
+ * @module
+ */
+export class ServerVersion {
+    major;
+    minor;
+    patch;
+    constructor(version) {
+        const vs = version.split('.');
+        if (vs.length === 2) {
+            this.major = parseInt(vs[0]);
+            this.minor = parseInt(vs[1]);
+            this.patch = 0;
+        }
+        else if (vs.length === 3) {
+            this.major = parseInt(vs[0]);
+            this.minor = parseInt(vs[1]);
+            this.patch = parseInt(vs[2]);
+        }
+        else {
+            throw new Error(`cannot parse Lean server version '${version}'`);
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+import * as React from 'react';
+export type TooltipProps = React.PropsWithChildren<React.HTMLProps<HTMLDivElement>> & {
+    reference: HTMLElement | null;
+};
+export declare function Tooltip(props_: TooltipProps): any;
+export declare const WithToggleableTooltip: React.ForwardRefExoticComponent<any>;
+/** Hover state of an element. The pointer can be
+ * - elsewhere (`off`)
+ * - over the element (`over`)
+ * - over the element with Ctrl or Meta (⌘ on Mac) held (`ctrlOver`)
+ */
+export type HoverState = 'off' | 'over' | 'ctrlOver';
+/** 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 declare const DetectHoverSpan: React.ForwardRefExoticComponent<any>;
+/** 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 declare const WithTooltipOnHover: React.ForwardRefExoticComponent<any>;