lean4monaco 1.0.35 → 1.0.37

package/dist/monaco-lean4/vscode-lean4/src/utils/leanInstaller.js

@@ -1,210 +0,0 @@
-import { EventEmitter, window } from 'vscode';
-import { getPowerShellPath, isRunningTest } from '../config';
-import { ExecutionExitCode, batchExecute, displayResultError } from './batch';
-import { elanSelfUpdate } from './elan';
-import { logger } from './logger';
-import { displayError, displayErrorWithOptionalInput, displayNotificationWithInput, } from './notifs';
-export class LeanVersion {
-    version;
-    error;
-}
-export class LeanInstaller {
-    leanInstallerLinux = 'https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh';
-    leanInstallerWindows = 'https://raw.githubusercontent.com/leanprover/elan/master/elan-init.ps1';
-    outputChannel;
-    prompting = false;
-    installing = false;
-    freshInstallDefaultToolchain;
-    elanDefaultToolchain = ''; // the default toolchain according to elan (toolchain marked with '(default)')
-    workspaceSuffix = '(workspace override)';
-    defaultSuffix = '(default)';
-    promptUser = true;
-    // This event is raised whenever a version change happens.
-    // The event provides the workspace Uri where the change happened.
-    installChangedEmitter = new EventEmitter();
-    installChanged = this.installChangedEmitter.event;
-    constructor(outputChannel, freshInstallDefaultToolchain) {
-        this.outputChannel = outputChannel;
-        this.freshInstallDefaultToolchain = freshInstallDefaultToolchain;
-        if (isRunningTest()) {
-            this.promptUser = false;
-            if (process.env.LEAN4_PROMPT_USER === 'true') {
-                this.promptUser = true;
-            }
-        }
-    }
-    getPromptUser() {
-        return this.promptUser;
-    }
-    getOutputChannel() {
-        return this.outputChannel;
-    }
-    handleVersionChanged(packageUri) {
-        void this.showRestartPromptAndRestart('Lean version changed', packageUri);
-    }
-    isPromptVisible() {
-        return this.prompting;
-    }
-    async showRestartPromptAndRestart(message, packageUri) {
-        if (!this.promptUser) {
-            this.installChangedEmitter.fire(packageUri);
-            return;
-        }
-        if (this.prompting) {
-            return;
-        }
-        this.prompting = true;
-        const finalizer = () => {
-            this.prompting = false;
-        };
-        displayErrorWithOptionalInput(message, 'Restart Lean', () => this.installChangedEmitter.fire(packageUri), finalizer);
-    }
-    handleLakeFileChanged(packageUri) {
-        void this.showRestartPromptAndRestart('Lake file configuration changed', packageUri);
-    }
-    removeSuffix(version) {
-        let s = version;
-        const suffixes = [this.defaultSuffix, this.workspaceSuffix];
-        suffixes.forEach(suffix => {
-            if (s.endsWith(suffix)) {
-                s = s.substr(0, s.length - suffix.length);
-            }
-        });
-        return s.trim();
-    }
-    async getElanDefaultToolchain(packageUri) {
-        if (this.elanDefaultToolchain) {
-            return this.elanDefaultToolchain;
-        }
-        const toolChains = await this.elanListToolChains(packageUri);
-        let result = '';
-        toolChains.forEach(s => {
-            if (s.endsWith(this.defaultSuffix)) {
-                result = this.removeSuffix(s);
-            }
-        });
-        this.elanDefaultToolchain = result;
-        return result;
-    }
-    async elanListToolChains(packageUri) {
-        try {
-            const cmd = 'elan';
-            const options = ['toolchain', 'list'];
-            const cwd = packageUri.scheme === 'file' ? packageUri.fsPath : undefined;
-            const stdout = (await batchExecute(cmd, options, cwd)).stdout;
-            if (!stdout) {
-                throw new Error('elan toolchain list returned no output.');
-            }
-            const result = [];
-            stdout.split(/\r?\n/).forEach(s => {
-                s = s.trim();
-                if (s !== '') {
-                    result.push(s);
-                }
-            });
-            return result;
-        }
-        catch (err) {
-            return [`${err}`];
-        }
-    }
-    async hasElan() {
-        try {
-            const options = ['--version'];
-            const result = await batchExecute('elan', options);
-            const filterVersion = /elan (\d+)\.\d+\..+/;
-            const match = filterVersion.exec(result.stdout);
-            return match !== null;
-        }
-        catch (err) {
-            return false;
-        }
-    }
-    async displayInstallElanPrompt(severity, reason) {
-        if (!this.getPromptUser()) {
-            // Used in tests
-            await this.autoInstall();
-            return true;
-        }
-        const reasonPrefix = reason ? reason + ' ' : '';
-        const installElanItem = 'Install Elan and Lean 4';
-        const installElanChoice = await displayNotificationWithInput(severity, reasonPrefix + "Do you want to install Lean's version manager Elan and a recent stable version of Lean 4?", installElanItem);
-        if (installElanChoice === undefined) {
-            return false;
-        }
-        await this.installElan();
-        return true;
-    }
-    async displayUpdateElanPrompt(severity, currentVersion, recommendedVersion) {
-        const updateElanItem = 'Update Elan';
-        const updateElanChoice = await displayNotificationWithInput(severity, `Lean's version manager Elan is outdated: the installed version is ${currentVersion.toString()}, but a version of ${recommendedVersion.toString()} is recommended. Do you want to update Elan?`, updateElanItem);
-        if (updateElanChoice === undefined) {
-            return false;
-        }
-        if (currentVersion.compare('3.1.0') === 0) {
-            // `elan self update` was broken in elan 3.1.0, so we need to take a different approach to updating elan here.
-            const installElanResult = await this.installElan();
-            return installElanResult === 'Success';
-        }
-        const elanSelfUpdateResult = await elanSelfUpdate(this.outputChannel);
-        if (elanSelfUpdateResult.exitCode !== ExecutionExitCode.Success) {
-            displayResultError(elanSelfUpdateResult, "Cannot update Elan. If you suspect that this is due to the way that you have set up Elan (e.g. from a package repository that ships an outdated version of Elan), you can disable these warnings using the 'Lean4: Show Setup Warnings' setting under 'File' > 'Preferences' > 'Settings'.");
-            return false;
-        }
-        return true;
-    }
-    async autoInstall() {
-        logger.log('[LeanInstaller] Installing Elan ...');
-        await this.installElan();
-        logger.log('[LeanInstaller] Elan installed');
-    }
-    async installElan() {
-        if (this.installing) {
-            displayError('Elan is already being installed. Please wait until the installation has finished.');
-            return 'PendingInstallation';
-        }
-        this.installing = true;
-        const terminalName = 'Lean installation via elan';
-        let terminalOptions = { name: terminalName };
-        if (process.platform === 'win32') {
-            terminalOptions = { name: terminalName, shellPath: getPowerShellPath() };
-        }
-        const terminal = window.createTerminal(terminalOptions);
-        terminal.show();
-        // We register a listener, to restart the Lean extension once elan has finished.
-        const resultPromise = new Promise(function (resolve, reject) {
-            window.onDidCloseTerminal(async (t) => {
-                if (t === terminal) {
-                    resolve(true);
-                }
-                else {
-                    logger.log('[LeanInstaller] ignoring terminal closed: ' + t.name + ', waiting for: ' + terminalName);
-                }
-            });
-        });
-        if (process.platform === 'win32') {
-            terminal.sendText(`Start-BitsTransfer -Source "${this.leanInstallerWindows}" -Destination "elan-init.ps1"\r\n` +
-                'Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope Process\r\n' +
-                `$rc = .\\elan-init.ps1 -NoPrompt 1 -DefaultToolchain ${this.freshInstallDefaultToolchain}\r\n` +
-                'Write-Host "elan-init returned [$rc]"\r\n' +
-                'del .\\elan-init.ps1\r\n' +
-                'if ($rc -ne 0) {\r\n' +
-                '    Read-Host -Prompt "Press ENTER to continue"\r\n' +
-                '}\r\n' +
-                'exit\r\n');
-        }
-        else {
-            const elanArgs = `-y --default-toolchain ${this.freshInstallDefaultToolchain}`;
-            const prompt = '(echo && read -n 1 -s -r -p "Install failed, press ENTER to continue...")';
-            terminal.sendText(`bash -c 'curl ${this.leanInstallerLinux} -sSf | sh -s -- ${elanArgs} || ${prompt}' && exit `);
-        }
-        const result = await resultPromise;
-        this.elanDefaultToolchain = this.freshInstallDefaultToolchain;
-        this.installing = false;
-        if (!result) {
-            displayError('Elan installation failed. Check the terminal output for details.');
-            return 'InstallationFailed';
-        }
-        return 'Success';
-    }
-}

package/dist/monaco-lean4/vscode-lean4/src/utils/logger.d.ts

@@ -1,7 +0,0 @@
-declare class Logger {
-    private static now;
-    log(msg: string): void;
-    error(msg: string): void;
-}
-declare const logger: Logger;
-export { logger };

package/dist/monaco-lean4/vscode-lean4/src/utils/logger.js

@@ -1,20 +0,0 @@
-class Logger {
-    static now() {
-        const now = new Date();
-        return (String(now.getUTCHours()).padStart(2, '0') +
-            ':' +
-            String(now.getMinutes()).padStart(2, '0') +
-            ':' +
-            String(now.getUTCSeconds()).padStart(2, '0') +
-            '.' +
-            String(now.getMilliseconds()).padStart(3, '0'));
-    }
-    log(msg) {
-        console.log(Logger.now(), '-', msg);
-    }
-    error(msg) {
-        console.error(Logger.now(), '-', msg);
-    }
-}
-const logger = new Logger();
-export { logger };

package/dist/monaco-lean4/vscode-lean4/src/utils/notifs.d.ts

@@ -1,24 +0,0 @@
-export type NotificationSeverity = 'Information' | 'Warning' | 'Error';
-export declare function displayNotification(severity: NotificationSeverity, message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayNotificationWithInput<T extends string>(severity: NotificationSeverity, message: string, ...items: T[]): Promise<T | undefined>;
-export declare function displayNotificationWithOptionalInput<T extends string>(severity: NotificationSeverity, message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
-export declare function displayNotificationWithOutput(severity: NotificationSeverity, message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayNotificationWithSetupGuide(severity: NotificationSeverity, message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayError(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayErrorWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
-export declare function displayErrorWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
-export declare function displayErrorWithOutput(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayErrorWithSetupGuide(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayWarning(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayModalWarning(message: string): Promise<'Proceed' | 'Abort'>;
-export declare function displayWarningWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
-export declare function displayWarningWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
-export declare function displayWarningWithOutput(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayModalWarningWithOutput(message: string): Promise<'Proceed' | 'Abort'>;
-export declare function displayWarningWithSetupGuide(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayModalWarningWithSetupGuide(message: string): Promise<'Proceed' | 'Abort'>;
-export declare function displayInformation(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayInformationWithInput<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
-export declare function displayInformationWithOptionalInput<T extends string>(message: string, input: T, action: () => void, finalizer?: (() => void) | undefined): void;
-export declare function displayInformationWithOutput(message: string, finalizer?: (() => void) | undefined): void;
-export declare function displayInformationWithSetupGuide(message: string, finalizer?: (() => void) | undefined): void;

package/dist/monaco-lean4/vscode-lean4/src/utils/notifs.js

@@ -1,110 +0,0 @@
-import { commands, window } from 'vscode';
-function toNotif(severity) {
-    switch (severity) {
-        case 'Information':
-            return window.showInformationMessage;
-        case 'Warning':
-            return window.showWarningMessage;
-        case 'Error':
-            return window.showErrorMessage;
-    }
-}
-export function displayNotification(severity, message, finalizer) {
-    void (async () => {
-        await toNotif(severity)(message, {});
-        if (finalizer) {
-            finalizer();
-        }
-    })();
-}
-export async function displayNotificationWithInput(severity, message, ...items) {
-    return await toNotif(severity)(message, { modal: true }, ...items);
-}
-export function displayNotificationWithOptionalInput(severity, message, input, action, finalizer) {
-    void (async () => {
-        const choice = await toNotif(severity)(message, {}, input);
-        if (choice === input) {
-            action();
-        }
-        if (finalizer) {
-            finalizer();
-        }
-    })();
-}
-export function displayNotificationWithOutput(severity, message, finalizer) {
-    displayNotificationWithOptionalInput(severity, message, 'Show Output', () => commands.executeCommand('lean4.troubleshooting.showOutput'), finalizer);
-}
-export function displayNotificationWithSetupGuide(severity, message, finalizer) {
-    displayNotificationWithOptionalInput(severity, message, 'Open Setup Guide', () => commands.executeCommand('lean4.docs.showSetupGuide'), finalizer);
-}
-export function displayError(message, finalizer) {
-    displayNotification('Error', message, finalizer);
-}
-export async function displayErrorWithInput(message, ...items) {
-    return await displayNotificationWithInput('Error', message, ...items);
-}
-export function displayErrorWithOptionalInput(message, input, action, finalizer) {
-    displayNotificationWithOptionalInput('Error', message, input, action, finalizer);
-}
-export function displayErrorWithOutput(message, finalizer) {
-    displayNotificationWithOutput('Error', message, finalizer);
-}
-export function displayErrorWithSetupGuide(message, finalizer) {
-    displayNotificationWithSetupGuide('Error', message, finalizer);
-}
-export function displayWarning(message, finalizer) {
-    displayNotification('Warning', message, finalizer);
-}
-export async function displayModalWarning(message) {
-    const choice = await window.showWarningMessage(message, { modal: true }, 'Proceed Regardless');
-    return choice === 'Proceed Regardless' ? 'Proceed' : 'Abort';
-}
-export async function displayWarningWithInput(message, ...items) {
-    return await displayNotificationWithInput('Warning', message, ...items);
-}
-export function displayWarningWithOptionalInput(message, input, action, finalizer) {
-    displayNotificationWithOptionalInput('Warning', message, input, action, finalizer);
-}
-export function displayWarningWithOutput(message, finalizer) {
-    displayNotificationWithOutput('Warning', message, finalizer);
-}
-export async function displayModalWarningWithOutput(message) {
-    const choice = await window.showWarningMessage(message, 'Show Output', 'Proceed Regardless');
-    if (choice === undefined) {
-        return 'Abort';
-    }
-    if (choice === 'Proceed Regardless') {
-        return 'Proceed';
-    }
-    await commands.executeCommand('lean4.troubleshooting.showOutput');
-    return 'Abort';
-}
-export function displayWarningWithSetupGuide(message, finalizer) {
-    displayNotificationWithSetupGuide('Warning', message, finalizer);
-}
-export async function displayModalWarningWithSetupGuide(message) {
-    const choice = await window.showWarningMessage(message, 'Open Setup Guide', 'Proceed Regardless');
-    if (choice === undefined) {
-        return 'Abort';
-    }
-    if (choice === 'Proceed Regardless') {
-        return 'Proceed';
-    }
-    await commands.executeCommand('lean4.docs.showSetupGuide');
-    return 'Abort';
-}
-export function displayInformation(message, finalizer) {
-    displayNotification('Information', message, finalizer);
-}
-export async function displayInformationWithInput(message, ...items) {
-    return await displayNotificationWithInput('Information', message, ...items);
-}
-export function displayInformationWithOptionalInput(message, input, action, finalizer) {
-    displayNotificationWithOptionalInput('Information', message, input, action, finalizer);
-}
-export function displayInformationWithOutput(message, finalizer) {
-    displayNotificationWithOutput('Information', message, finalizer);
-}
-export function displayInformationWithSetupGuide(message, finalizer) {
-    displayNotificationWithSetupGuide('Information', message, finalizer);
-}

package/dist/monaco-lean4/vscode-lean4/src/utils/projectInfo.d.ts

@@ -1,9 +0,0 @@
-import { ExtUri, FileUri } from './exturi';
-export declare function isCoreLean4Directory(path: FileUri): Promise<boolean>;
-export declare function findLeanProjectRootInfo(uri: FileUri): Promise<[FileUri, FileUri | undefined]>;
-export declare function findLeanProjectRoot(uri: FileUri): Promise<FileUri>;
-export declare function findLeanProjectInfo(uri: FileUri): Promise<[FileUri, string | undefined]>;
-export declare function readLeanToolchain(projectUri: FileUri): Promise<string | undefined>;
-export declare function isValidLeanProject(projectFolder: FileUri): Promise<boolean>;
-export declare function checkParentFoldersForLeanProject(folder: FileUri): Promise<FileUri | undefined>;
-export declare function willUseLakeServer(folder: ExtUri): Promise<boolean>;

package/dist/monaco-lean4/vscode-lean4/src/utils/projectInfo.js

@@ -1,125 +0,0 @@
-import * as fs from 'fs';
-import { FileUri, getWorkspaceFolderUri } from './exturi';
-import { dirExists, fileExists } from './fsHelper';
-import path from 'path';
-// Detect lean4 root directory (works for both lean4 repo and nightly distribution)
-export async function isCoreLean4Directory(path) {
-    const licensePath = path.join('LICENSE').fsPath;
-    const licensesPath = path.join('LICENSES').fsPath;
-    const srcPath = path.join('src').fsPath;
-    const isCoreLean4RootDirectory = (await fileExists(licensePath)) && (await fileExists(licensesPath)) && (await dirExists(srcPath));
-    if (isCoreLean4RootDirectory) {
-        return true;
-    }
-    const initPath = path.join('Init.lean').fsPath;
-    const leanPath = path.join('Lean.lean').fsPath;
-    const kernelPath = path.join('kernel').fsPath;
-    const runtimePath = path.join('runtime').fsPath;
-    const isCoreLean4SrcDirectory = (await fileExists(initPath)) &&
-        (await fileExists(leanPath)) &&
-        (await dirExists(kernelPath)) &&
-        (await dirExists(runtimePath));
-    return isCoreLean4SrcDirectory;
-}
-// Find the root of a Lean project and the Uri for the 'lean-toolchain' file found there.
-export async function findLeanProjectRootInfo(uri) {
-    const toolchainFileName = 'lean-toolchain';
-    let path = uri;
-    const containingWsFolderUri = getWorkspaceFolderUri(uri);
-    // then start searching from the directory containing this document.
-    // The given uri may already be a folder Uri in some cases.
-    if (fs.lstatSync(path.fsPath).isFile()) {
-        path = uri.join('..');
-    }
-    let bestFolder = path;
-    let bestLeanToolchain;
-    while (true) {
-        const leanToolchain = path.join(toolchainFileName);
-        if (await fileExists(leanToolchain.fsPath)) {
-            bestFolder = path;
-            bestLeanToolchain = leanToolchain;
-        }
-        else if (await isCoreLean4Directory(path)) {
-            bestFolder = path;
-            bestLeanToolchain = undefined;
-            // Stop searching in case users accidentally created a lean-toolchain file above the core directory
-            break;
-        }
-        if (containingWsFolderUri !== undefined && path.equals(containingWsFolderUri)) {
-            if (bestLeanToolchain === undefined) {
-                // If we haven't found a toolchain yet, prefer the workspace folder as the project scope for the file,
-                // but keep looking in case there is a lean-toolchain above the workspace folder
-                // (New users sometimes accidentally open sub-folders of projects)
-                bestFolder = path;
-            }
-            else {
-                // Stop looking above the barrier if we have a toolchain. This is necessary for the nested lean-toolchain setup of core.
-                break;
-            }
-        }
-        const parent = path.join('..');
-        if (parent.equals(path)) {
-            // no project file found.
-            break;
-        }
-        path = parent;
-    }
-    return [bestFolder, bestLeanToolchain];
-}
-export async function findLeanProjectRoot(uri) {
-    const [projectRootUri, _] = await findLeanProjectRootInfo(uri);
-    return projectRootUri;
-}
-export async function findLeanProjectInfo(uri) {
-    const [projectUri, toolchainUri] = await findLeanProjectRootInfo(uri);
-    if (!toolchainUri) {
-        return [projectUri, undefined];
-    }
-    return [projectUri, await readLeanToolchainFile(toolchainUri)];
-}
-export async function readLeanToolchain(projectUri) {
-    const toolchainFileName = 'lean-toolchain';
-    const leanToolchain = projectUri.join(toolchainFileName);
-    if (!fs.existsSync(leanToolchain.fsPath)) {
-        return undefined;
-    }
-    return await readLeanToolchainFile(leanToolchain);
-}
-async function readLeanToolchainFile(toolchainFileUri) {
-    try {
-        return (await fs.promises.readFile(toolchainFileUri.fsPath, { encoding: 'utf-8' })).trim();
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function isValidLeanProject(projectFolder) {
-    try {
-        const leanToolchainPath = projectFolder.join('lean-toolchain').fsPath;
-        const isLeanProject = await fileExists(leanToolchainPath);
-        const isLeanItself = await isCoreLean4Directory(projectFolder);
-        return isLeanProject || isLeanItself;
-    }
-    catch {
-        return false;
-    }
-}
-export async function checkParentFoldersForLeanProject(folder) {
-    let childFolder;
-    do {
-        childFolder = folder;
-        folder = new FileUri(path.dirname(folder.fsPath));
-        if (await isValidLeanProject(folder)) {
-            return folder;
-        }
-    } while (!childFolder.equals(folder));
-    return undefined;
-}
-export async function willUseLakeServer(folder) {
-    if (folder.scheme !== 'file') {
-        return false;
-    }
-    const lakefileLean = folder.join('lakefile.lean');
-    const lakefileToml = folder.join('lakefile.toml');
-    return (await fileExists(lakefileLean.fsPath)) || (await fileExists(lakefileToml.fsPath));
-}

package/dist/vscode.css

@@ -1,7 +0,0 @@
-:root {
-    --vscode-font-weight:normal;
-    --vscode-font-size:13px;
-    --vscode-editor-font-family: 'JuliaMono', 'Source Code Pro', 'STIX Two Math', monospace;
-    --vscode-editor-font-weight:normal;
-    --vscode-editor-font-size:15px;
-  }