lean4monaco 1.0.45 → 1.0.46

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

@@ -1,323 +0,0 @@
-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

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

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

@@ -1,22 +0,0 @@
-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;
-}