lean4monaco 1.0.45 → 1.1.0

package/dist/vscode-lean4/vscode-lean4/src/diagnostics/setupNotifs.js

@@ -1,5 +1,5 @@
 import { shouldShowSetupWarnings } from '../config';
-import { displayError, displayErrorWithInput, displayErrorWithOptionalInput, displayErrorWithOutput, displayErrorWithSetupGuide, displayModalWarning, displayModalWarningWithOutput, displayModalWarningWithSetupGuide, displayWarning, displayWarningWithInput, displayWarningWithOptionalInput, displayWarningWithOutput, displayWarningWithSetupGuide, } from '../utils/notifs';
+import { displayModalNotification, displayModalNotificationWithOutput, displayModalNotificationWithSetupGuide, displayNotification, displayNotificationWithInput, displayNotificationWithOptionalInput, displayNotificationWithOutput, displayNotificationWithSetupGuide, displayStickyNotificationWithOptionalInput, displayStickyNotificationWithOutput, displayStickyNotificationWithSetupGuide, } from '../utils/notifs';
 export function preconditionCheckResultToSeverity(result) {
     switch (result) {
         case 'Fulfilled':
@@ -29,105 +29,251 @@ export function worstPreconditionViolation(...results) {
     }
     return worstViolation;
 }
-export function displaySetupError(message, finalizer) {
-    displayError(message, finalizer);
-    return 'Fatal';
-}
-export async function displaySetupErrorWithInput(message, ...items) {
-    return await displayErrorWithInput(message, ...items);
-}
-export function displaySetupErrorWithOptionalInput(message, input, action, finalizer) {
-    displayErrorWithOptionalInput(message, input, action, finalizer);
-    return 'Fatal';
-}
-export function displaySetupErrorWithOutput(message, finalizer) {
-    displayErrorWithOutput(message, finalizer);
-    return 'Fatal';
-}
-export function displaySetupErrorWithSetupGuide(message, finalizer) {
-    displayErrorWithSetupGuide(message, finalizer);
-    return 'Fatal';
-}
-export function displayDependencySetupError(missingDeps) {
-    if (missingDeps.length === 0) {
-        throw new Error();
+const closeItem = 'Close';
+const proceedItem = 'Proceed';
+const proceedRegardlessItem = 'Proceed Regardless';
+const retryItem = {
+    input: 'Retry',
+    continueDisplaying: false,
+    action: async () => { },
+};
+export class SetupNotifier {
+    options;
+    subscriptions = [];
+    constructor(options) {
+        this.options = options;
     }
-    let missingDepMessage;
-    if (missingDeps.length === 1) {
-        missingDepMessage = `One of Lean's dependencies ('${missingDeps.at(0)}') is missing`;
+    async error(notifs) {
+        const m = this.options.errorMode;
+        if (m.mode === 'Modal') {
+            return await notifs.modal();
+        }
+        if (m.mode === 'NonModal') {
+            if (notifs.nonModal === undefined) {
+                return await notifs.modal();
+            }
+            return notifs.nonModal();
+        }
+        const r = await notifs.modal();
+        if (r !== 'Fatal') {
+            return r;
+        }
+        const options = {
+            onInput: async (_, continueDisplaying) => {
+                if (!continueDisplaying) {
+                    await m.retry();
+                }
+                return continueDisplaying;
+            },
+            onDisplay: async () => { },
+        };
+        const d = await notifs.sticky(options);
+        this.subscriptions.push(d);
+        return 'Fatal';
     }
-    else {
-        missingDepMessage = `Multiple of Lean's dependencies (${missingDeps.map(dep => `'${dep}'`).join(', ')}) are missing`;
+    async warning(notifs) {
+        if (!shouldShowSetupWarnings()) {
+            return 'Warning';
+        }
+        if (this.options.warningMode.modal || notifs.nonModal === undefined) {
+            if (this.options.warningMode.proceedByDefault) {
+                return await notifs.modalProceedByDefault();
+            }
+            else {
+                return await notifs.modalAskBeforeProceeding();
+            }
+        }
+        else {
+            return notifs.nonModal();
+        }
     }
-    const errorMessage = `${missingDepMessage}. Please read the Setup Guide on how to install missing dependencies and set up Lean 4.`;
-    displaySetupErrorWithSetupGuide(errorMessage);
-    return 'Fatal';
-}
-export async function displayElanSetupError(installer, reason) {
-    const isElanInstalled = await installer.displayInstallElanPrompt('Error', reason);
-    return isElanInstalled ? 'Fulfilled' : 'Fatal';
-}
-export async function displayElanOutdatedSetupError(installer, currentVersion, recommendedVersion) {
-    const isElanUpToDate = await installer.displayUpdateElanPrompt('Error', currentVersion, recommendedVersion);
-    return isElanUpToDate ? 'Fulfilled' : 'Fatal';
-}
-export async function displaySetupWarning(message, options = { modal: false }) {
-    if (!shouldShowSetupWarnings()) {
-        return 'Warning';
+    async displaySetupError(message) {
+        return await this.error({
+            modal: async () => {
+                await displayModalNotification('Error', message);
+                return 'Fatal';
+            },
+            nonModal: () => {
+                displayNotification('Error', message);
+                return 'Fatal';
+            },
+            sticky: async (options) => displayStickyNotificationWithOptionalInput('Error', message, options, [retryItem]),
+        });
     }
-    if (options.modal) {
-        const choice = await displayModalWarning(message);
-        return choice === 'Proceed' ? 'Warning' : 'Fatal';
+    async displaySetupWarning(message) {
+        return await this.warning({
+            modalProceedByDefault: async () => {
+                await displayModalNotification('Warning', message);
+                return 'Warning';
+            },
+            modalAskBeforeProceeding: async () => {
+                const choice = await displayNotificationWithInput('Warning', message, [proceedRegardlessItem]);
+                return choice === proceedRegardlessItem ? 'Warning' : 'Fatal';
+            },
+            nonModal: () => {
+                displayNotification('Warning', message);
+                return 'Warning';
+            },
+        });
     }
-    displayWarning(message, options.finalizer);
-    return 'Warning';
-}
-export async function displaySetupWarningWithInput(message, ...items) {
-    if (!shouldShowSetupWarnings()) {
-        return undefined;
+    async displaySetupErrorWithInput(message, inputs) {
+        return await this.error({
+            modal: async () => {
+                const choice = await displayNotificationWithInput('Error', message, inputs.map(i => i.input));
+                const chosenInput = inputs.find(i => i.input === choice);
+                await chosenInput?.action();
+                return 'Fatal';
+            },
+            nonModal: () => {
+                displayNotificationWithOptionalInput('Error', message, inputs);
+                return 'Fatal';
+            },
+            sticky: async (options) => displayStickyNotificationWithOptionalInput('Error', message, options, [retryItem, ...inputs]),
+        });
     }
-    return await displayWarningWithInput(message, ...items);
-}
-export function displaySetupWarningWithOptionalInput(message, input, action, finalizer) {
-    if (!shouldShowSetupWarnings()) {
-        return 'Warning';
+    async displaySetupWarningWithInput(message, inputs) {
+        return await this.warning({
+            modalProceedByDefault: async () => {
+                const choice = await displayNotificationWithInput('Warning', message, inputs.map(i => i.input), proceedItem);
+                const chosenInput = inputs.find(i => i.input === choice);
+                chosenInput?.action();
+                return 'Warning';
+            },
+            modalAskBeforeProceeding: async () => {
+                const choice = await displayNotificationWithInput('Warning', message, [
+                    ...inputs.map(i => i.input),
+                    proceedRegardlessItem,
+                ]);
+                const chosenInput = inputs.find(i => i.input === choice);
+                chosenInput?.action();
+                return choice === proceedRegardlessItem ? 'Warning' : 'Fatal';
+            },
+            nonModal: () => {
+                displayNotificationWithOptionalInput('Warning', message, inputs);
+                return 'Warning';
+            },
+        });
     }
-    displayWarningWithOptionalInput(message, input, action, finalizer);
-    return 'Warning';
-}
-export async function displaySetupWarningWithOutput(message, options = { modal: false }) {
-    if (!shouldShowSetupWarnings()) {
-        return 'Warning';
+    async displaySetupErrorWithOutput(message) {
+        return await this.error({
+            modal: async () => {
+                await displayModalNotificationWithOutput('Error', message, [], closeItem);
+                return 'Fatal';
+            },
+            nonModal: () => {
+                displayNotificationWithOutput('Error', message);
+                return 'Fatal';
+            },
+            sticky: async (options) => displayStickyNotificationWithOutput('Error', message, options, [retryItem]),
+        });
     }
-    if (options.modal) {
-        const choice = await displayModalWarningWithOutput(message);
-        return choice === 'Proceed' ? 'Warning' : 'Fatal';
+    async displaySetupWarningWithOutput(message) {
+        return await this.warning({
+            modalProceedByDefault: async () => {
+                await displayModalNotificationWithOutput('Warning', message, [], proceedItem);
+                return 'Warning';
+            },
+            modalAskBeforeProceeding: async () => {
+                const choice = await displayModalNotificationWithOutput('Warning', message, [proceedRegardlessItem]);
+                return choice === proceedRegardlessItem ? 'Warning' : 'Fatal';
+            },
+            nonModal: () => {
+                displayNotificationWithOutput('Warning', message);
+                return 'Warning';
+            },
+        });
     }
-    displayWarningWithOutput(message, options.finalizer);
-    return 'Warning';
-}
-export async function displaySetupWarningWithSetupGuide(message, options = { modal: false }) {
-    if (!shouldShowSetupWarnings()) {
-        return 'Warning';
+    async displaySetupErrorWithSetupGuide(message) {
+        return await this.error({
+            modal: async () => {
+                await displayModalNotificationWithSetupGuide('Error', message, [], closeItem);
+                return 'Fatal';
+            },
+            nonModal: () => {
+                displayNotificationWithSetupGuide('Error', message);
+                return 'Fatal';
+            },
+            sticky: async (options) => displayStickyNotificationWithSetupGuide('Error', message, options, [retryItem]),
+        });
     }
-    if (options.modal) {
-        const choice = await displayModalWarningWithSetupGuide(message);
-        return choice === 'Proceed' ? 'Warning' : 'Fatal';
+    async displaySetupWarningWithSetupGuide(message) {
+        return await this.warning({
+            modalProceedByDefault: async () => {
+                await displayModalNotificationWithSetupGuide('Warning', message, [], proceedItem);
+                return 'Warning';
+            },
+            modalAskBeforeProceeding: async () => {
+                const choice = await displayModalNotificationWithSetupGuide('Warning', message, [proceedRegardlessItem]);
+                return choice === proceedRegardlessItem ? 'Warning' : 'Fatal';
+            },
+            nonModal: () => {
+                displayNotificationWithSetupGuide('Warning', message);
+                return 'Warning';
+            },
+        });
     }
-    displayWarningWithSetupGuide(message, options.finalizer);
-    return 'Warning';
-}
-export async function displayElanSetupWarning(installer, reason) {
-    if (!shouldShowSetupWarnings()) {
-        return 'Warning';
+    async displayElanSetupError(installer, reason) {
+        return await this.error({
+            modal: async () => {
+                const isElanInstalled = await installer.displayInstallElanPrompt('Error', reason);
+                return isElanInstalled ? 'Fulfilled' : 'Fatal';
+            },
+            sticky: async (options) => installer.displayStickyInstallElanPrompt('Error', reason, options, [retryItem]),
+        });
     }
-    const isElanInstalled = await installer.displayInstallElanPrompt('Warning', reason);
-    return isElanInstalled ? 'Fulfilled' : 'Warning';
-}
-export async function displayElanOutdatedSetupWarning(installer, currentVersion, recommendedVersion) {
-    if (!shouldShowSetupWarnings()) {
-        return 'Warning';
+    async displayElanSetupWarning(installer, reason) {
+        return await this.warning({
+            modalProceedByDefault: async () => {
+                const r = await installer.displayInstallElanPromptWithItems('Warning', reason, [], proceedItem);
+                const success = r !== undefined && r.kind === 'InstallElan' && r.success;
+                return success ? 'Fulfilled' : 'Warning';
+            },
+            modalAskBeforeProceeding: async () => {
+                const r = await installer.displayInstallElanPromptWithItems('Warning', reason, [proceedRegardlessItem]);
+                if (r === undefined) {
+                    return 'Fatal';
+                }
+                if (r.kind === 'InstallElan') {
+                    return r.success ? 'Fulfilled' : 'Warning';
+                }
+                return 'Warning';
+            },
+        });
+    }
+    async displayElanOutdatedSetupError(installer, currentVersion, recommendedVersion) {
+        const mode = {
+            kind: 'Outdated',
+            versions: { currentVersion, recommendedVersion },
+        };
+        return await this.error({
+            modal: async () => {
+                const isElanUpToDate = await installer.displayUpdateElanPrompt('Error', mode);
+                return isElanUpToDate ? 'Fulfilled' : 'Fatal';
+            },
+            sticky: async (options) => installer.displayStickyUpdateElanPrompt('Error', mode, options, [retryItem]),
+        });
+    }
+    async displayElanOutdatedSetupWarning(installer, currentVersion, recommendedVersion) {
+        const mode = {
+            kind: 'Outdated',
+            versions: { currentVersion, recommendedVersion },
+        };
+        return await this.warning({
+            modalProceedByDefault: async () => {
+                const r = await installer.displayUpdateElanPromptWithItems('Warning', mode, [], proceedItem);
+                const success = r !== undefined && r.kind === 'UpdateElan' && r.success;
+                return success ? 'Fulfilled' : 'Warning';
+            },
+            modalAskBeforeProceeding: async () => {
+                const r = await installer.displayUpdateElanPromptWithItems('Warning', mode, [proceedRegardlessItem]);
+                if (r === undefined) {
+                    return 'Fatal';
+                }
+                if (r.kind === 'UpdateElan') {
+                    return r.success ? 'Fulfilled' : 'Warning';
+                }
+                return 'Warning';
+            },
+        });
     }
-    const isElanUpToDate = await installer.displayUpdateElanPrompt('Warning', currentVersion, recommendedVersion);
-    return isElanUpToDate ? 'Fulfilled' : 'Warning';
 }

package/dist/vscode-lean4/vscode-lean4/src/infoview.d.ts

@@ -1,22 +1,19 @@
-import { EditorApi, InfoviewApi, ServerStoppedReason } from '@leanprover/infoview-api';
-import { Disposable, DocumentSelector, Event, ExtensionContext, ViewColumn } from 'vscode';
+import { ServerStoppedReason } from '@leanprover/infoview-api';
+import { Disposable, ExtensionContext } from 'vscode';
+import * as ls from 'vscode-languageserver-protocol';
 import { LeanClient } from './leanclient';
-import { Rpc } from './rpc';
 import { LeanClientProvider } from './utils/clientProvider';
-export interface InfoWebview {
-    readonly api: InfoviewApi;
-    readonly rpc: Rpc;
-    readonly visible: boolean;
-    dispose(): any;
-    reveal(viewColumn?: ViewColumn, preserveFocus?: boolean): void;
-    onDidDispose: Event<void>;
-}
-export interface InfoWebviewFactory {
-    make(editorApi: EditorApi, stylesheet: string, column: number): InfoWebview;
+import { IFrameInfoWebviewFactory } from '../../../infowebview';
+export declare class RpcSessionAtPos implements Disposable {
+    sessionId: string;
+    uri: ls.DocumentUri;
+    keepAliveInterval?: NodeJS.Timeout;
+    client: LeanClient;
+    constructor(client: LeanClient, sessionId: string, uri: ls.DocumentUri);
+    dispose(): void;
 }
 export declare class InfoProvider implements Disposable {
-    private provider;
-    private readonly leanDocs;
+    private clientProvider;
     private context;
     private infoWebviewFactory;
     /** Instance of the panel, if it is open. Otherwise `undefined`. */
@@ -25,7 +22,6 @@ export declare class InfoProvider implements Disposable {
     private clientSubscriptions;
     private stylesheet;
     private autoOpened;
-    private clientProvider;
     private serverNotifSubscriptions;
     private clientNotifSubscriptions;
     private rpcSessions;
@@ -36,7 +32,7 @@ export declare class InfoProvider implements Disposable {
     private subscribeDiagnosticsNotification;
     private subscribeCustomNotification;
     private editorApi;
-    constructor(provider: LeanClientProvider, leanDocs: DocumentSelector, context: ExtensionContext, infoWebviewFactory: InfoWebviewFactory);
+    constructor(clientProvider: LeanClientProvider, context: ExtensionContext, infoWebviewFactory: IFrameInfoWebviewFactory);
     private onClientRestarted;
     private onClientAdded;
     onWorkerRestarted(uri: string): Promise<void>;
@@ -66,4 +62,6 @@ export declare class InfoProvider implements Disposable {
     private updateStatus;
     private revealEditorSelection;
     private handleInsertText;
+    private getLocalPath;
+    private initialHtml;
 }