lean4monaco 1.0.46 → 1.1.0

package/dist/vscode-lean4/vscode-lean4/src/utils/leanEditorProvider.js

@@ -0,0 +1,323 @@
+import { commands, EventEmitter, window, workspace, } from 'vscode';
+import { isExtUri, toExtUriOrError } from './exturi';
+import { groupByKey, groupByUniqueKey } from './groupBy';
+export class LeanDocument {
+    doc;
+    extUri;
+    constructor(doc, extUri) {
+        this.doc = doc;
+        this.extUri = extUri;
+    }
+    equals(other) {
+        return this.doc === other.doc;
+    }
+    equalsTextDocument(other) {
+        return this.doc === other;
+    }
+    static equalsWithUndefined(a, b) {
+        if (a === undefined) {
+            return b === undefined;
+        }
+        if (b === undefined) {
+            return a === undefined;
+        }
+        return a.equals(b);
+    }
+}
+export class LeanEditor {
+    editor;
+    documentExtUri;
+    constructor(editor, documentExtUri) {
+        this.editor = editor;
+        this.documentExtUri = documentExtUri;
+    }
+    equals(other) {
+        return this.editor === other.editor;
+    }
+    equalsTextEditor(other) {
+        return this.editor === other;
+    }
+    static equalsWithUndefined(a, b) {
+        if (a === undefined) {
+            return b === undefined;
+        }
+        if (b === undefined) {
+            return a === undefined;
+        }
+        return a.equals(b);
+    }
+}
+class LeanDocumentIndex {
+    docsByUri;
+    /**
+     * Assumes that `docs` only contains at most one `LeanDocument` per URI.
+     * This is given for `TextDocument`s from VS Code.
+     * */
+    constructor(docs) {
+        this.docsByUri = groupByUniqueKey(docs, doc => doc.extUri.toString());
+    }
+    get(uri) {
+        return this.docsByUri.get(uri.toString());
+    }
+}
+class LeanEditorIndex {
+    editorsByUri;
+    constructor(editors) {
+        this.editorsByUri = groupByKey(editors, editor => editor.documentExtUri.toString());
+    }
+    get(uri) {
+        return this.editorsByUri.get(uri.toString());
+    }
+}
+export function isLeanDocument(doc) {
+    return isExtUri(doc.uri) && doc.languageId === 'lean4';
+}
+export function asLeanDocument(doc) {
+    if (isLeanDocument(doc)) {
+        return new LeanDocument(doc, toExtUriOrError(doc.uri));
+    }
+    return undefined;
+}
+export function filterLeanDocuments(docs) {
+    return docs.map(doc => asLeanDocument(doc)).filter(doc => doc !== undefined);
+}
+export function filterLeanDocument(doc) {
+    if (doc === undefined) {
+        return undefined;
+    }
+    return asLeanDocument(doc);
+}
+export function isLeanEditor(editor) {
+    return isLeanDocument(editor.document);
+}
+export function asLeanEditor(editor) {
+    if (isLeanEditor(editor)) {
+        return new LeanEditor(editor, toExtUriOrError(editor.document.uri));
+    }
+    return undefined;
+}
+export function filterLeanEditors(editors) {
+    return editors.map(editor => asLeanEditor(editor)).filter(editor => editor !== undefined);
+}
+export function filterLeanEditor(editor) {
+    if (editor === undefined) {
+        return undefined;
+    }
+    return asLeanEditor(editor);
+}
+export class LeanEditorProvider {
+    subscriptions = [];
+    _visibleLeanEditors;
+    visibleLeanEditorsByUri;
+    onDidChangeVisibleLeanEditorsEmitter = new EventEmitter();
+    onDidChangeVisibleLeanEditors = this.onDidChangeVisibleLeanEditorsEmitter.event;
+    _activeLeanEditor;
+    onDidChangeActiveLeanEditorEmitter = new EventEmitter();
+    onDidChangeActiveLeanEditor = this.onDidChangeActiveLeanEditorEmitter.event;
+    _lastActiveLeanEditor;
+    onDidChangeLastActiveLeanEditorEmitter = new EventEmitter();
+    onDidChangeLastActiveLeanEditor = this.onDidChangeLastActiveLeanEditorEmitter.event;
+    _leanDocuments;
+    leanDocumentsByUri;
+    onDidChangeLeanDocumentsEmitter = new EventEmitter();
+    onDidChangeLeanDocuments = this.onDidChangeLeanDocumentsEmitter.event;
+    onDidOpenLeanDocumentEmitter = new EventEmitter();
+    onDidOpenLeanDocument = this.onDidOpenLeanDocumentEmitter.event;
+    onDidCloseLeanDocumentEmitter = new EventEmitter();
+    onDidCloseLeanDocument = this.onDidCloseLeanDocumentEmitter.event;
+    _lastActiveLeanDocument;
+    onDidChangeLastActiveLeanDocumentEmitter = new EventEmitter();
+    onDidChangeLastActiveLeanDocument = this.onDidChangeLastActiveLeanDocumentEmitter.event;
+    onDidRevealLeanEditorEmitter = new EventEmitter();
+    onDidRevealLeanEditor = this.onDidRevealLeanEditorEmitter.event;
+    onDidConcealLeanEditorEmitter = new EventEmitter();
+    onDidConcealLeanEditor = this.onDidConcealLeanEditorEmitter.event;
+    onDidChangeLeanEditorSelectionEmitter = new EventEmitter();
+    onDidChangeLeanEditorSelection = this.onDidChangeLeanEditorSelectionEmitter.event;
+    constructor() {
+        this._visibleLeanEditors = filterLeanEditors(window.visibleTextEditors);
+        this.visibleLeanEditorsByUri = new LeanEditorIndex(this._visibleLeanEditors);
+        this.subscriptions.push(window.onDidChangeVisibleTextEditors(editors => this.updateVisibleTextEditors(editors)));
+        this._activeLeanEditor = filterLeanEditor(window.activeTextEditor);
+        this.subscriptions.push(window.onDidChangeActiveTextEditor(editor => this.updateActiveTextEditor(editor)));
+        this._leanDocuments = filterLeanDocuments(workspace.textDocuments);
+        this.leanDocumentsByUri = new LeanDocumentIndex(this._leanDocuments);
+        this.subscriptions.push(workspace.onDidOpenTextDocument(doc => {
+            this.updateLeanDocuments(workspace.textDocuments);
+            this.openLeanDocument(doc);
+            // Update visible and active editors in case this `onDidOpenTextDocument` call was
+            // triggered by a changed language ID.
+            this.updateVisibleTextEditors(window.visibleTextEditors);
+            this.updateActiveTextEditor(window.activeTextEditor);
+        }));
+        this.subscriptions.push(workspace.onDidCloseTextDocument(doc => {
+            // Update visible and active editors in case this `onDidCloseTextDocument` call was
+            // triggered by a changed language ID.
+            this.updateVisibleTextEditors(window.visibleTextEditors);
+            this.updateActiveTextEditor(window.activeTextEditor);
+            this.updateLeanDocuments(workspace.textDocuments);
+            this.closeLeanDocument(doc);
+            this.invalidateClosedLastActiveLeanDocument(doc);
+        }));
+        this.subscriptions.push(window.onDidChangeTextEditorSelection(event => this.updateTextEditorSelection(event)));
+    }
+    updateVisibleTextEditors(visibleTextEditors) {
+        const oldVisibleLeanEditors = [...this._visibleLeanEditors];
+        this.updateVisibleLeanEditors(visibleTextEditors);
+        this.invalidateInvisibleLastActiveLeanEditor(visibleTextEditors);
+        this.revealLeanEditors(oldVisibleLeanEditors, visibleTextEditors);
+        this.concealLeanEditors(oldVisibleLeanEditors, visibleTextEditors);
+    }
+    updateActiveTextEditor(activeTextEditor) {
+        this.updateActiveLeanEditor(activeTextEditor);
+        this.updateLastActiveLeanEditor(activeTextEditor);
+        this.updateLastActiveLeanDocument(activeTextEditor);
+    }
+    updateVisibleLeanEditors(visibleTextEditors) {
+        const newVisibleLeanEditors = filterLeanEditors(visibleTextEditors);
+        if (newVisibleLeanEditors.length === this._visibleLeanEditors.length &&
+            newVisibleLeanEditors.every((newVisibleLeanEditor, i) => newVisibleLeanEditor.equals(this._visibleLeanEditors[i]))) {
+            return;
+        }
+        this._visibleLeanEditors = newVisibleLeanEditors;
+        this.visibleLeanEditorsByUri = new LeanEditorIndex(newVisibleLeanEditors);
+        this.onDidChangeVisibleLeanEditorsEmitter.fire(newVisibleLeanEditors);
+    }
+    revealLeanEditors(oldVisibleLeanEditors, newVisibleTextEditors) {
+        const oldVisibleLeanEditorsIndex = new Set(oldVisibleLeanEditors.map(leanEditor => leanEditor.editor));
+        const newVisibleLeanEditors = filterLeanEditors(newVisibleTextEditors);
+        const revealedLeanEditors = newVisibleLeanEditors.filter(newVisibleLeanEditor => !oldVisibleLeanEditorsIndex.has(newVisibleLeanEditor.editor));
+        for (const revealedLeanEditor of revealedLeanEditors) {
+            this.onDidRevealLeanEditorEmitter.fire(revealedLeanEditor);
+        }
+    }
+    concealLeanEditors(oldVisibleLeanEditors, newVisibleTextEditors) {
+        const newVisibleLeanEditors = filterLeanEditors(newVisibleTextEditors);
+        const newVisibleLeanEditorsIndex = new Set(newVisibleLeanEditors.map(leanEditor => leanEditor.editor));
+        const concealedLeanEditors = oldVisibleLeanEditors.filter(newVisibleLeanEditor => !newVisibleLeanEditorsIndex.has(newVisibleLeanEditor.editor));
+        for (const concealedLeanEditor of concealedLeanEditors) {
+            this.onDidConcealLeanEditorEmitter.fire(concealedLeanEditor);
+        }
+    }
+    updateActiveLeanEditor(activeTextEditor) {
+        const newActiveLeanEditor = filterLeanEditor(activeTextEditor);
+        if (LeanEditor.equalsWithUndefined(newActiveLeanEditor, this._activeLeanEditor)) {
+            return;
+        }
+        this._activeLeanEditor = newActiveLeanEditor;
+        this.onDidChangeActiveLeanEditorEmitter.fire(newActiveLeanEditor);
+    }
+    invalidateInvisibleLastActiveLeanEditor(visibleTextEditors) {
+        if (this._lastActiveLeanEditor !== undefined &&
+            !visibleTextEditors.includes(this._lastActiveLeanEditor.editor)) {
+            this._lastActiveLeanEditor = undefined;
+            this.onDidChangeLastActiveLeanEditorEmitter.fire(undefined);
+        }
+    }
+    updateLastActiveLeanEditor(activeTextEditor) {
+        const newLastActiveLeanEditor = filterLeanEditor(activeTextEditor);
+        if (newLastActiveLeanEditor === undefined) {
+            return;
+        }
+        if (LeanEditor.equalsWithUndefined(newLastActiveLeanEditor, this._lastActiveLeanEditor)) {
+            return;
+        }
+        this._lastActiveLeanEditor = newLastActiveLeanEditor;
+        this.onDidChangeLastActiveLeanEditorEmitter.fire(newLastActiveLeanEditor);
+    }
+    updateLeanDocuments(textDocuments) {
+        const newLeanDocuments = filterLeanDocuments(textDocuments);
+        if (newLeanDocuments.length === this._leanDocuments.length &&
+            newLeanDocuments.every((newLeanDocument, i) => newLeanDocument.equals(this._leanDocuments[i]))) {
+            return;
+        }
+        this._leanDocuments = newLeanDocuments;
+        this.leanDocumentsByUri = new LeanDocumentIndex(newLeanDocuments);
+        this.onDidChangeLeanDocumentsEmitter.fire(newLeanDocuments);
+    }
+    openLeanDocument(textDocument) {
+        const leanTextDocument = filterLeanDocument(textDocument);
+        if (leanTextDocument === undefined) {
+            return;
+        }
+        this.onDidOpenLeanDocumentEmitter.fire(leanTextDocument);
+    }
+    closeLeanDocument(textDocument) {
+        const leanTextDocument = filterLeanDocument(textDocument);
+        if (leanTextDocument === undefined) {
+            return;
+        }
+        this.onDidCloseLeanDocumentEmitter.fire(leanTextDocument);
+    }
+    invalidateClosedLastActiveLeanDocument(closedTextDocument) {
+        if (this._lastActiveLeanDocument?.doc === closedTextDocument) {
+            this._lastActiveLeanDocument = undefined;
+            this.onDidChangeLastActiveLeanDocumentEmitter.fire(undefined);
+        }
+    }
+    updateLastActiveLeanDocument(activeTextEditor) {
+        const newLastActiveLeanDocument = filterLeanDocument(activeTextEditor?.document);
+        if (newLastActiveLeanDocument === undefined) {
+            return;
+        }
+        if (LeanDocument.equalsWithUndefined(newLastActiveLeanDocument, this._lastActiveLeanDocument)) {
+            return;
+        }
+        this._lastActiveLeanDocument = newLastActiveLeanDocument;
+        this.onDidChangeLastActiveLeanDocumentEmitter.fire(newLastActiveLeanDocument);
+    }
+    updateTextEditorSelection(event) {
+        if (!isLeanEditor(event.textEditor)) {
+            return;
+        }
+        this.onDidChangeLeanEditorSelectionEmitter.fire(event);
+    }
+    get visibleLeanEditors() {
+        return this._visibleLeanEditors;
+    }
+    get activeLeanEditor() {
+        return this._activeLeanEditor;
+    }
+    get lastActiveLeanEditor() {
+        return this._lastActiveLeanEditor;
+    }
+    get leanDocuments() {
+        return this._leanDocuments;
+    }
+    get lastActiveLeanDocument() {
+        return this._lastActiveLeanDocument;
+    }
+    getVisibleLeanEditorsByUri(uri) {
+        return this.visibleLeanEditorsByUri.get(uri) ?? [];
+    }
+    getLeanDocumentByUri(uri) {
+        return this.leanDocumentsByUri.get(uri);
+    }
+    registerLeanEditorCommand(command, callback, thisArg) {
+        return commands.registerTextEditorCommand(command, (editor, edit, ...args) => {
+            const leanEditor = filterLeanEditor(editor);
+            if (leanEditor === undefined) {
+                return;
+            }
+            callback(leanEditor, edit, ...args);
+        }, thisArg);
+    }
+    dispose() {
+        for (const s of this.subscriptions) {
+            s.dispose();
+        }
+    }
+}
+export let lean;
+/** Must be called at the very start when the extension is activated so that `lean` is defined. */
+export function registerLeanEditorProvider(context) {
+    lean = new LeanEditorProvider();
+    context.subscriptions.push(lean);
+    context.subscriptions.push({
+        dispose: () => {
+            const u = undefined;
+            // Implicit invariant: When the extension deactivates, `lean` is not called after this assignment.
+            lean = u;
+        },
+    });
+}

package/dist/vscode-lean4/vscode-lean4/src/utils/leanInstaller.d.ts

@@ -1,21 +1,30 @@
 import { SemVer } from 'semver';
-import { OutputChannel } from 'vscode';
-import { ExtUri, FileUri } from './exturi';
-import { NotificationSeverity } from './notifs';
+import { Disposable, OutputChannel } from 'vscode';
+import { FileUri } from './exturi';
+import { NotificationSeverity, StickyInput, StickyNotificationOptions } from './notifs';
 export declare class LeanVersion {
     version: string;
     error: string | undefined;
 }
+export type UpdateElanMode = {
+    kind: 'Outdated';
+    versions: {
+        currentVersion: SemVer;
+        recommendedVersion: SemVer;
+    };
+} | {
+    kind: 'Manual';
+    versions: {
+        currentVersion: SemVer;
+    };
+};
 export declare class LeanInstaller {
     private leanInstallerLinux;
     private leanInstallerWindows;
     private outputChannel;
     private prompting;
-    private installing;
+    private pendingOperation;
     private freshInstallDefaultToolchain;
-    private elanDefaultToolchain;
-    private workspaceSuffix;
-    private defaultSuffix;
     private promptUser;
     private installChangedEmitter;
     installChanged: import("vscode").Event<FileUri>;
@@ -26,12 +35,32 @@ export declare class LeanInstaller {
     isPromptVisible(): boolean;
     private showRestartPromptAndRestart;
     handleLakeFileChanged(packageUri: FileUri): void;
-    private removeSuffix;
-    getElanDefaultToolchain(packageUri: ExtUri): Promise<string>;
-    elanListToolChains(packageUri: ExtUri): Promise<string[]>;
-    hasElan(): Promise<boolean>;
+    private installElanPrompt;
+    displayInstallElanPromptWithItems(severity: NotificationSeverity, reason: string | undefined, otherItems?: string[], defaultItem?: string | undefined): Promise<{
+        kind: 'InstallElan';
+        success: boolean;
+    } | {
+        kind: 'OtherItem';
+        choice: string;
+    } | undefined>;
     displayInstallElanPrompt(severity: NotificationSeverity, reason: string | undefined): Promise<boolean>;
-    displayUpdateElanPrompt(severity: NotificationSeverity, currentVersion: SemVer, recommendedVersion: SemVer): Promise<boolean>;
+    displayStickyInstallElanPrompt(severity: NotificationSeverity, reason: string | undefined, options: StickyNotificationOptions<'Install Elan' | string>, otherItems?: StickyInput<string>[]): Disposable;
+    private updateElanPrompt;
+    private displayElanUpdateSuccessfulPrompt;
+    private updateElan;
+    displayUpdateElanPromptWithItems(severity: NotificationSeverity, mode: UpdateElanMode, otherItems?: string[], defaultItem?: string | undefined): Promise<{
+        kind: 'UpdateElan';
+        success: boolean;
+    } | {
+        kind: 'OtherItem';
+        choice: string;
+    } | undefined>;
+    displayUpdateElanPrompt(severity: NotificationSeverity, mode: UpdateElanMode): Promise<boolean>;
+    displayStickyUpdateElanPrompt(severity: NotificationSeverity, mode: UpdateElanMode, options: StickyNotificationOptions<'Update Elan' | string>, otherItems?: StickyInput<string>[]): Disposable;
+    displayManualUpdateElanPrompt(): Promise<void>;
     private autoInstall;
+    private installElanAndDisplaySettingPrompt;
     private installElan;
+    uninstallElan(): Promise<void>;
+    private performOperation;
 }