lean4monaco 1.1.3 → 1.1.5

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

@@ -1,129 +0,0 @@
-/**
- * For LSP communication, we need a way to translate between LSP types and corresponding VSCode types.
- * By default this translation is provided as a bunch of methods on a `LanguageClient`, but this is
- * awkward to use in multi-client workspaces wherein we need to look up specific clients. In fact the
- * conversions are *not* stateful, so having them depend on the client is unnecessary. Instead, we
- * provide global converters here.
- *
- * Some of the conversions are patched to support extended Lean-specific structures.
- *
- * @module
- */
-import * as code from 'vscode';
-import { createConverter as createC2PConverter } from 'vscode-languageclient/lib/common/codeConverter';
-import { createConverter as createP2CConverter } from 'vscode-languageclient/lib/common/protocolConverter';
-import * as async from 'vscode-languageclient/lib/common/utils/async';
-import * as ls from 'vscode-languageserver-protocol';
-import { automaticallyBuildDependencies } from '../config';
-var SnippetTextEdit;
-(function (SnippetTextEdit) {
-    function is(value) {
-        if (!ls.TextEdit.is(value))
-            return false;
-        if (!('leanExtSnippet' in value))
-            return false;
-        const snip = value.leanExtSnippet;
-        if (snip === null || typeof snip !== 'object')
-            return false;
-        if (!('value' in snip))
-            return false;
-        if (typeof snip.value !== 'string' && !(snip.value instanceof String))
-            return false;
-        return true;
-    }
-    SnippetTextEdit.is = is;
-})(SnippetTextEdit || (SnippetTextEdit = {}));
-export function setDependencyBuildMode(params, dependencyBuildMode) {
-    const updatedParams = params;
-    updatedParams.dependencyBuildMode = automaticallyBuildDependencies() ? 'always' : dependencyBuildMode;
-    return updatedParams;
-}
-export const p2cConverter = createP2CConverter(undefined, true, true);
-export const c2pConverter = createC2PConverter(undefined);
-export function patchConverters(p2cConverter, c2pConverter) {
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const oldP2cAsDiagnostic = p2cConverter.asDiagnostic;
-    p2cConverter.asDiagnostic = function (protDiag) {
-        if (!protDiag.message) {
-            // Fixes: Notification handler 'textDocument/publishDiagnostics' failed with message: message must be set
-            protDiag.message = ' ';
-        }
-        const diag = oldP2cAsDiagnostic.apply(this, [protDiag]);
-        diag.fullRange = p2cConverter.asRange(protDiag.fullRange);
-        return diag;
-    };
-    // The original definition refers to `asDiagnostic` as a local function
-    // rather than as a member of `Protocol2CodeConverter`,
-    // so we need to overwrite it, too.
-    p2cConverter.asDiagnostics = async (diags, token) => async.map(diags, d => p2cConverter.asDiagnostic(d), token);
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const oldC2pAsDiagnostic = c2pConverter.asDiagnostic;
-    c2pConverter.asDiagnostic = function (diag) {
-        const protDiag = oldC2pAsDiagnostic.apply(this, [diag]);
-        protDiag.fullRange = c2pConverter.asRange(diag.fullRange);
-        return protDiag;
-    };
-    c2pConverter.asDiagnostics = async (diags, token) => async.map(diags, d => c2pConverter.asDiagnostic(d), token);
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const oldC2pAsOpenTextDocumentParams = c2pConverter.asOpenTextDocumentParams;
-    c2pConverter.asOpenTextDocumentParams = doc => {
-        const params = oldC2pAsOpenTextDocumentParams.apply(this, [doc]);
-        return setDependencyBuildMode(params, 'never');
-    };
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const oldP2CAsWorkspaceEdit = p2cConverter.asWorkspaceEdit;
-    p2cConverter.asWorkspaceEdit = async function (item, token) {
-        if (item === undefined || item === null)
-            return undefined;
-        if (item.documentChanges) {
-            // 1. Preprocess `documentChanges` by filtering out snippet edits
-            // which we support as a Lean-specific extension.
-            // 2. Create a `WorkspaceEdit` using the default function
-            // which does not take snippet edits into account.
-            // 3. Append the snippet edits.
-            // Note that this may permute the relative ordering of snippet edits and text edits,
-            // so users cannot rely on it;
-            // but a mix of both doesn't seem to work in VSCode anyway as of 1.84.2.
-            const snippetChanges = [];
-            const documentChanges = await async.map(item.documentChanges, change => {
-                if (!ls.TextDocumentEdit.is(change))
-                    return true;
-                const uri = code.Uri.parse(change.textDocument.uri);
-                const snippetEdits = [];
-                const edits = change.edits.filter(edit => {
-                    if (!SnippetTextEdit.is(edit))
-                        return true;
-                    const range = p2cConverter.asRange(edit.range);
-                    snippetEdits.push(new code.SnippetTextEdit(range, new code.SnippetString(edit.leanExtSnippet.value)));
-                    return false;
-                });
-                snippetChanges.push([uri, snippetEdits]);
-                return { ...change, edits };
-            }, token);
-            const newItem = { ...item, documentChanges };
-            const result = await oldP2CAsWorkspaceEdit.apply(this, [newItem, token]);
-            for (const [uri, snippetEdits] of snippetChanges)
-                result.set(uri, snippetEdits);
-            return result;
-        }
-        return oldP2CAsWorkspaceEdit.apply(this, [item, token]);
-    };
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const oldP2cAsCodeAction = p2cConverter.asCodeAction;
-    p2cConverter.asCodeAction = async function (item, token) {
-        if (item === undefined || item === null)
-            return undefined;
-        if (item.edit || item.diagnostics) {
-            const result = await oldP2cAsCodeAction.apply(this, [item, token]);
-            if (item.diagnostics !== undefined)
-                result.diagnostics = await p2cConverter.asDiagnostics(item.diagnostics, token);
-            if (item.edit)
-                result.edit = await p2cConverter.asWorkspaceEdit(item.edit, token);
-        }
-        return oldP2cAsCodeAction.apply(this, [item, token]);
-    };
-    // Note: as of 2023-12-10, there is no c2pConverter.asWorkspaceEdit.
-    // This is possibly because code.WorkspaceEdit supports features
-    // that cannot be encoded in ls.WorkspaceEdit.
-}
-patchConverters(p2cConverter, c2pConverter);

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

@@ -1,3 +0,0 @@
-import { OutputChannel } from 'vscode';
-import { ExecutionResult } from './batch';
-export declare function elanSelfUpdate(channel: OutputChannel): Promise<ExecutionResult>;

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

@@ -1,4 +0,0 @@
-import { batchExecuteWithProgress } from './batch';
-export async function elanSelfUpdate(channel) {
-    return await batchExecuteWithProgress('elan', ['self', 'update'], 'Updating Elan', { channel });
-}

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

@@ -1,21 +0,0 @@
-/// <reference types="node" />
-/** Platform independent interface to work with the PATH variable. */
-export declare class PATH {
-    paths: string[];
-    constructor(paths: string[]);
-    static empty(): PATH;
-    static ofEnvPath(envPath: string): PATH;
-    static ofEnv(env: NodeJS.ProcessEnv): PATH;
-    static ofProcessEnv(): PATH;
-    toEnvPath(): string;
-    setInEnv(env: NodeJS.ProcessEnv): void;
-    setInProcessEnv(): void;
-    prepend(path: string): PATH;
-    join(other: PATH): PATH;
-    length(): number;
-    isEmpty(): boolean;
-    includes(path: string): boolean;
-    filter(p: (path: string) => boolean): PATH;
-}
-export declare function setPATH(env: NodeJS.ProcessEnv, path: PATH): void;
-export declare function setProcessEnvPATH(path: PATH): void;

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

@@ -1,53 +0,0 @@
-import * as path from 'path';
-/** Platform independent interface to work with the PATH variable. */
-export class PATH {
-    paths;
-    constructor(paths) {
-        this.paths = paths;
-    }
-    static empty() {
-        return new PATH([]);
-    }
-    static ofEnvPath(envPath) {
-        return new PATH(envPath.split(path.delimiter));
-    }
-    static ofEnv(env) {
-        return PATH.ofEnvPath(env.PATH ?? '');
-    }
-    static ofProcessEnv() {
-        return PATH.ofEnv(process.env);
-    }
-    toEnvPath() {
-        return this.paths.join(path.delimiter);
-    }
-    setInEnv(env) {
-        env.PATH = this.toEnvPath();
-    }
-    setInProcessEnv() {
-        this.setInEnv(process.env);
-    }
-    prepend(path) {
-        return new PATH([path].concat(this.paths));
-    }
-    join(other) {
-        return new PATH(this.paths.concat(other.paths));
-    }
-    length() {
-        return this.paths.length;
-    }
-    isEmpty() {
-        return this.length() === 0;
-    }
-    includes(path) {
-        return this.paths.includes(path);
-    }
-    filter(p) {
-        return new PATH(this.paths.filter(p));
-    }
-}
-export function setPATH(env, path) {
-    path.setInEnv(env);
-}
-export function setProcessEnvPATH(path) {
-    setPATH(process.env, path);
-}

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

@@ -1,35 +0,0 @@
-import { Uri } from 'vscode';
-export declare class FileUri {
-    scheme: 'file';
-    fsPath: string;
-    constructor(fsPath: string);
-    static fromUri(uri: Uri): FileUri | undefined;
-    static fromUriOrError(uri: Uri): FileUri;
-    asUri(): Uri;
-    equals(other: FileUri): boolean;
-    equalsUri(other: Uri): boolean;
-    toString(): string;
-    join(...pathSegments: string[]): FileUri;
-    isInFolder(folderUri: FileUri): boolean;
-}
-export declare function getWorkspaceFolderUri(uri: FileUri): FileUri | undefined;
-export declare class UntitledUri {
-    scheme: 'untitled';
-    path: string;
-    constructor(path?: string | undefined);
-    static fromUri(uri: Uri): UntitledUri | undefined;
-    static fromUriOrError(uri: Uri): UntitledUri;
-    asUri(): Uri;
-    equals(other: UntitledUri): boolean;
-    equalsUri(other: Uri): boolean;
-    toString(): string;
-}
-/** Uris supported by this extension. */
-export type ExtUri = FileUri | UntitledUri;
-export declare function isExtUri(uri: Uri): boolean;
-export declare function toExtUri(uri: Uri): ExtUri | undefined;
-export declare function toExtUriOrError(uri: Uri): ExtUri;
-export declare function parseExtUri(uriString: string): ExtUri | undefined;
-export declare function parseExtUriOrError(uriString: string): ExtUri;
-export declare function extUriEquals(a: ExtUri, b: ExtUri): boolean;
-export declare function extUriToCwdUri(uri: ExtUri): FileUri | undefined;

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

@@ -1,136 +0,0 @@
-import { Uri, workspace } from 'vscode';
-import { isFileInFolder } from './fsHelper';
-function unsupportedSchemeError(uri) {
-    return new Error(`Got URI with unsupported scheme '${uri.scheme}': '${uri}'`);
-}
-export class FileUri {
-    scheme;
-    fsPath;
-    constructor(fsPath) {
-        this.scheme = 'file';
-        this.fsPath = fsPath;
-    }
-    static fromUri(uri) {
-        if (uri.scheme !== 'file') {
-            return undefined;
-        }
-        return new FileUri(uri.fsPath);
-    }
-    static fromUriOrError(uri) {
-        const fileUri = FileUri.fromUri(uri);
-        if (fileUri === undefined) {
-            throw unsupportedSchemeError(uri);
-        }
-        return fileUri;
-    }
-    asUri() {
-        return Uri.file(this.fsPath);
-    }
-    equals(other) {
-        return this.fsPath === other.fsPath;
-    }
-    equalsUri(other) {
-        const otherFileUri = FileUri.fromUri(other);
-        if (otherFileUri === undefined) {
-            return false;
-        }
-        return this.equals(otherFileUri);
-    }
-    toString() {
-        return this.asUri().toString();
-    }
-    join(...pathSegments) {
-        return FileUri.fromUriOrError(Uri.joinPath(this.asUri(), ...pathSegments));
-    }
-    isInFolder(folderUri) {
-        return isFileInFolder(this.fsPath, folderUri.fsPath);
-    }
-}
-export function getWorkspaceFolderUri(uri) {
-    const folder = workspace.getWorkspaceFolder(uri.asUri());
-    if (folder === undefined) {
-        return undefined;
-    }
-    const folderUri = FileUri.fromUri(folder.uri);
-    if (folderUri === undefined) {
-        return undefined;
-    }
-    return folderUri;
-}
-export class UntitledUri {
-    scheme;
-    path;
-    constructor(path) {
-        this.scheme = 'untitled';
-        this.path = path ?? '';
-    }
-    static fromUri(uri) {
-        if (uri.scheme !== 'untitled') {
-            return undefined;
-        }
-        return new UntitledUri(uri.path);
-    }
-    static fromUriOrError(uri) {
-        const untitledUri = UntitledUri.fromUri(uri);
-        if (untitledUri === undefined) {
-            throw unsupportedSchemeError(uri);
-        }
-        return untitledUri;
-    }
-    asUri() {
-        return Uri.from({ scheme: 'untitled', path: this.path });
-    }
-    equals(other) {
-        return this.path === other.path;
-    }
-    equalsUri(other) {
-        const otherFileUri = UntitledUri.fromUri(other);
-        if (otherFileUri === undefined) {
-            return false;
-        }
-        return this.equals(otherFileUri);
-    }
-    toString() {
-        return this.asUri().toString();
-    }
-}
-export function isExtUri(uri) {
-    return uri.scheme === 'untitled' || uri.scheme === 'file';
-}
-export function toExtUri(uri) {
-    if (uri.scheme === 'untitled') {
-        return new UntitledUri(uri.path);
-    }
-    if (uri.scheme === 'file') {
-        return new FileUri(uri.fsPath);
-    }
-    return undefined;
-}
-export function toExtUriOrError(uri) {
-    const result = toExtUri(uri);
-    if (result === undefined) {
-        throw unsupportedSchemeError(uri);
-    }
-    return result;
-}
-export function parseExtUri(uriString) {
-    return toExtUri(Uri.parse(uriString));
-}
-export function parseExtUriOrError(uriString) {
-    return toExtUriOrError(Uri.parse(uriString));
-}
-export function extUriEquals(a, b) {
-    if (a.scheme === 'untitled' && b.scheme === 'untitled') {
-        return a.equals(b);
-    }
-    if (a.scheme === 'file' && b.scheme === 'file') {
-        return a.equals(b);
-    }
-    return false;
-}
-export function extUriToCwdUri(uri) {
-    if (uri.scheme === 'untitled') {
-        return undefined;
-    }
-    return uri;
-}

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

@@ -1,17 +0,0 @@
-/// <reference types="node" />
-import { PathLike } from 'fs';
-/**
- * Returns true if `pathFile` exists and is a file
- */
-export declare function fileExists(pathFile: PathLike): Promise<boolean>;
-/**
- * Returns true if `pathFile` exists and is a directory
- */
-export declare function dirExists(pathFile: PathLike): Promise<boolean>;
-/**
- * This helper function is used to check if an specific file is in certain Folder.
- * @param file string that contains a file name that will be checked if it exists in a certain folder.
- * @param folder string that contains a folder name where it will check if a certain file exists
- * @returns a boolean that says if the file exists in folder
- */
-export declare function isFileInFolder(file: string, folder: string): boolean;

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

@@ -1,36 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { promises } from 'fs';
-import path from 'path';
-/**
- * Returns true if `pathFile` exists and is a file
- */
-export async function fileExists(pathFile) {
-    try {
-        return (await promises.stat(pathFile)).isFile();
-    }
-    catch (e) {
-        return false;
-    }
-}
-/**
- * Returns true if `pathFile` exists and is a directory
- */
-export async function dirExists(pathFile) {
-    try {
-        return (await promises.stat(pathFile)).isDirectory();
-    }
-    catch (e) {
-        return false;
-    }
-}
-/**
- * This helper function is used to check if an specific file is in certain Folder.
- * @param file string that contains a file name that will be checked if it exists in a certain folder.
- * @param folder string that contains a folder name where it will check if a certain file exists
- * @returns a boolean that says if the file exists in folder
- */
-export function isFileInFolder(file, folder) {
-    const relative = path.relative(folder, file);
-    const isSubdir = relative.length > 0 && !relative.startsWith('..') && !path.isAbsolute(relative);
-    return isSubdir;
-}

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

@@ -1,37 +0,0 @@
-import { SemVer } from 'semver';
-import { OutputChannel } from 'vscode';
-import { ExtUri, FileUri } from './exturi';
-import { NotificationSeverity } from './notifs';
-export declare class LeanVersion {
-    version: string;
-    error: string | undefined;
-}
-export declare class LeanInstaller {
-    private leanInstallerLinux;
-    private leanInstallerWindows;
-    private outputChannel;
-    private prompting;
-    private installing;
-    private freshInstallDefaultToolchain;
-    private elanDefaultToolchain;
-    private workspaceSuffix;
-    private defaultSuffix;
-    private promptUser;
-    private installChangedEmitter;
-    installChanged: import("vscode").Event<FileUri>;
-    constructor(outputChannel: OutputChannel, freshInstallDefaultToolchain: string);
-    getPromptUser(): boolean;
-    getOutputChannel(): OutputChannel;
-    handleVersionChanged(packageUri: FileUri): void;
-    isPromptVisible(): boolean;
-    private showRestartPromptAndRestart;
-    handleLakeFileChanged(packageUri: FileUri): void;
-    private removeSuffix;
-    getElanDefaultToolchain(packageUri: ExtUri): Promise<string>;
-    elanListToolChains(packageUri: ExtUri): Promise<string[]>;
-    hasElan(): Promise<boolean>;
-    displayInstallElanPrompt(severity: NotificationSeverity, reason: string | undefined): Promise<boolean>;
-    displayUpdateElanPrompt(severity: NotificationSeverity, currentVersion: SemVer, recommendedVersion: SemVer): Promise<boolean>;
-    private autoInstall;
-    private installElan;
-}