lean4monaco 1.0.36 → 1.0.37

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/viewColumn.d.ts

@@ -0,0 +1,3 @@
+import { ViewColumn } from 'vscode';
+export declare function viewColumnOfInfoView(): ViewColumn;
+export declare function viewColumnOfActiveTextEditor(): ViewColumn;

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

@@ -0,0 +1,22 @@
+import { TabInputWebview, ViewColumn, window } from 'vscode';
+export function viewColumnOfInfoView() {
+    for (const tabGroup of window.tabGroups.all) {
+        const tab = tabGroup.tabs.find(tab => tab.input instanceof TabInputWebview && tab.input.viewType === 'mainThreadWebview-lean4_infoview');
+        if (tab !== undefined) {
+            return tabGroup.viewColumn;
+        }
+    }
+    // We do not use `ViewColumn.Beside` here because `ViewColumn.Beside` will never
+    // add a tab to a locked tab group.
+    // This is especially problematic because locking the tab group of the InfoView
+    // is a workaround for https://github.com/microsoft/vscode/issues/212679
+    // and using `ViewColumn.Beside` will retain an empty locked tab group when restarting VS Code.
+    const activeColumn = window.activeTextEditor?.viewColumn;
+    if (activeColumn === undefined) {
+        return ViewColumn.Two;
+    }
+    return activeColumn + 1;
+}
+export function viewColumnOfActiveTextEditor() {
+    return window.activeTextEditor?.viewColumn ?? ViewColumn.One;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lean4monaco",
-  "version": "1.0.36",
+  "version": "1.0.37",
   "description": "Monaco Editor support for the Lean 4 theorem prover.",
   "keywords": [
     "lean",