lean4monaco 1.0.45 → 1.1.0

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

@@ -1,4 +1,6 @@
-import { commands, window } from 'vscode';
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
+import { Disposable, commands, window } from 'vscode';
+import { lean } from './leanEditorProvider';
 function toNotif(severity) {
     switch (severity) {
         case 'Information':
@@ -9,6 +11,78 @@ function toNotif(severity) {
             return window.showErrorMessage;
     }
 }
+export async function setStickyNotificationActiveButHidden(isActiveButHidden) {
+    await commands.executeCommand('setContext', 'lean4.isStickyNotificationActiveButHidden', isActiveButHidden);
+}
+let activeStickyNotification;
+let nextStickyNotification;
+let activeDisplayFn;
+function makeSticky(n) {
+    if (activeStickyNotification !== undefined) {
+        nextStickyNotification = n;
+        return Disposable.from();
+    }
+    activeStickyNotification = n;
+    let isDisplaying = false;
+    // eslint-disable-next-line prefer-const
+    let d;
+    const display = async () => {
+        if (isDisplaying) {
+            return;
+        }
+        await setStickyNotificationActiveButHidden(false);
+        isDisplaying = true;
+        try {
+            await activeStickyNotification?.options.onDisplay();
+            let gotNewStickyNotification = false;
+            let r;
+            let continueDisplaying;
+            do {
+                gotNewStickyNotification = false;
+                r = await activeStickyNotification?.displayNotification();
+                continueDisplaying =
+                    r === undefined || ((await activeStickyNotification?.options.onInput(r, true)) ?? false);
+                if (nextStickyNotification !== undefined) {
+                    activeStickyNotification = nextStickyNotification;
+                    nextStickyNotification = undefined;
+                    gotNewStickyNotification = true;
+                }
+            } while ((r !== undefined && continueDisplaying) || gotNewStickyNotification);
+            if (!continueDisplaying) {
+                activeStickyNotification = undefined;
+                await setStickyNotificationActiveButHidden(false);
+                d?.dispose();
+            }
+            else {
+                await setStickyNotificationActiveButHidden(true);
+            }
+        }
+        catch (e) {
+            activeStickyNotification = undefined;
+            nextStickyNotification = undefined;
+            await setStickyNotificationActiveButHidden(false);
+            d?.dispose();
+            console.log(e);
+        }
+        finally {
+            isDisplaying = false;
+        }
+    };
+    activeDisplayFn = display;
+    d = Disposable.from(lean.onDidRevealLeanEditor(async () => await display()), {
+        dispose: () => {
+            activeStickyNotification = undefined;
+            activeDisplayFn = undefined;
+        },
+    });
+    void display();
+    return d;
+}
+export function displayActiveStickyNotification() {
+    if (activeDisplayFn !== undefined) {
+        void activeDisplayFn();
+    }
+}
 export function displayNotification(severity, message, finalizer) {
     void (async () => {
         await toNotif(severity)(message, {});
@@ -17,94 +91,115 @@ export function displayNotification(severity, message, finalizer) {
         }
     })();
 }
-export async function displayNotificationWithInput(severity, message, ...items) {
-    return await toNotif(severity)(message, { modal: true }, ...items);
-}
-export function displayNotificationWithOptionalInput(severity, message, input, action, finalizer) {
+export function displayStickyNotification(severity, message, options) {
+    return makeSticky({
+        displayNotification: async () => (await toNotif(severity)(message, {})),
+        options,
+    });
+}
+export async function displayNotificationWithInput(severity, message, items, defaultItem) {
+    if (defaultItem === undefined) {
+        // VS Code renders buttons for modal notifications in the reverse order (which it doesn't do for non-modal notifications),
+        // so we reverse them for consistency.
+        // The close button is placed to the left of the primary button.
+        return await toNotif(severity)(message, { modal: true }, ...[...items].reverse());
+    }
+    let notif;
+    switch (severity) {
+        case 'Information':
+            notif = window.showInformationMessage;
+            break;
+        case 'Warning':
+            notif = window.showWarningMessage;
+            break;
+        case 'Error':
+            notif = window.showErrorMessage;
+            break;
+    }
+    const messageItems = items.map(item => ({
+        title: item,
+        isCloseAffordance: false,
+    }));
+    // VS Code always moves the `isCloseAffordance: true` button to the left of the primary button.
+    messageItems.push({
+        title: defaultItem,
+        isCloseAffordance: true,
+    });
+    messageItems.reverse();
+    const choice = await notif(message, { modal: true }, ...messageItems);
+    return choice?.title;
+}
+export async function displayModalNotification(severity, message) {
+    await displayNotificationWithInput(severity, message, [], 'Close');
+}
+export function displayNotificationWithOptionalInput(severity, message, inputs, finalizer) {
     void (async () => {
-        const choice = await toNotif(severity)(message, {}, input);
-        if (choice === input) {
-            action();
+        const choice = await toNotif(severity)(message, {}, ...inputs.map(i => i.input));
+        const chosenInput = inputs.find(i => i.input === choice);
+        if (chosenInput !== undefined) {
+            chosenInput.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';
+export function displayStickyNotificationWithOptionalInput(severity, message, options, inputs) {
+    const updatedOptions = {
+        ...options,
+        onInput: async (lastChoice, continueDisplaying) => {
+            const chosenInput = inputs.find(i => i.input === lastChoice);
+            if (chosenInput !== undefined) {
+                await chosenInput.action();
+                continueDisplaying = chosenInput.continueDisplaying;
+            }
+            return options.onInput(lastChoice, continueDisplaying);
+        },
+    };
+    return makeSticky({
+        displayNotification: async () => await toNotif(severity)(message, {}, ...inputs.map(i => i.input)),
+        options: updatedOptions,
+    });
+}
+export function displayNotificationWithOutput(severity, message, otherInputs = [], finalizer) {
+    displayNotificationWithOptionalInput(severity, message, [
+        { input: 'Show Output', action: () => commands.executeCommand('lean4.troubleshooting.showOutput') },
+        ...otherInputs,
+    ], finalizer);
+}
+export async function displayModalNotificationWithOutput(severity, message, otherItems = [], defaultItem) {
+    const choice = await displayNotificationWithInput(severity, message, ['Show Output', ...otherItems], defaultItem);
+    if (choice === 'Show Output') {
+        await commands.executeCommand('lean4.troubleshooting.showOutput');
     }
-    if (choice === 'Proceed Regardless') {
-        return 'Proceed';
+    return choice;
+}
+export function displayStickyNotificationWithOutput(severity, message, options, otherInputs = []) {
+    const showOutputItem = {
+        input: 'Show Output',
+        continueDisplaying: true,
+        action: async () => await commands.executeCommand('lean4.troubleshooting.showOutput'),
+    };
+    return displayStickyNotificationWithOptionalInput(severity, message, options, [showOutputItem, ...otherInputs]);
+}
+export function displayNotificationWithSetupGuide(severity, message, otherInputs = [], finalizer) {
+    displayNotificationWithOptionalInput(severity, message, [
+        { input: 'Open Setup Guide', action: () => commands.executeCommand('lean4.docs.showSetupGuide') },
+        ...otherInputs,
+    ], finalizer);
+}
+export function displayStickyNotificationWithSetupGuide(severity, message, options, otherInputs = []) {
+    const openSetupGuideItem = {
+        input: 'Open Setup Guide',
+        continueDisplaying: true,
+        action: async () => await commands.executeCommand('lean4.docs.showSetupGuide'),
+    };
+    return displayStickyNotificationWithOptionalInput(severity, message, options, [openSetupGuideItem, ...otherInputs]);
+}
+export async function displayModalNotificationWithSetupGuide(severity, message, otherItems = [], defaultItem) {
+    const choice = await displayNotificationWithInput(severity, message, ['Open Setup Guide', ...otherItems], defaultItem);
+    if (choice === 'Open Setup Guide') {
+        await commands.executeCommand('lean4.docs.showSetupGuide');
     }
-    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);
+    return choice;
 }

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

@@ -2,10 +2,14 @@ import { ExtUri, FileUri } from './exturi';
 export declare function isCoreLean4Directory(path: FileUri): Promise<boolean>;
 type ProjectRootInfo = {
     kind: 'Success';
-    projectRootUri: FileUri;
+    projectRootUri: ExtUri;
     toolchainUri: FileUri | undefined;
 } | {
     kind: 'FileNotFound';
+} | {
+    kind: 'LakefileWithoutToolchain';
+    projectRootUri: FileUri;
+    lakefileUri: FileUri;
 };
 type ToolchainInfo = {
     uri: FileUri;
@@ -13,13 +17,16 @@ type ToolchainInfo = {
 };
 type ProjectInfo = {
     kind: 'Success';
-    projectRootUri: FileUri;
+    projectRootUri: ExtUri;
     toolchainInfo: ToolchainInfo | undefined;
 } | {
     kind: 'FileNotFound';
+} | {
+    kind: 'LakefileWithoutToolchain';
+    projectRootUri: FileUri;
+    lakefileUri: FileUri;
 };
-export declare function findLeanProjectRootInfo(uri: FileUri): Promise<ProjectRootInfo>;
-export declare function findLeanProjectRoot(uri: FileUri): Promise<FileUri | 'FileNotFound'>;
+export declare function findLeanProjectRootInfo(uri: ExtUri): Promise<ProjectRootInfo>;
 export declare function findLeanProjectInfo(uri: FileUri): Promise<ProjectInfo>;
 export declare function isValidLeanProject(projectFolder: FileUri): Promise<boolean>;
 export declare function checkParentFoldersForLeanProject(folder: FileUri): Promise<FileUri | undefined>;

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

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
-import { FileUri, getWorkspaceFolderUri } from './exturi';
-import { dirExists, fileExists } from './fsHelper';
 import path from 'path';
+import { FileUri, isWorkspaceFolder, UntitledUri } from './exturi';
+import { dirExists, fileExists } from './fsHelper';
 // Detect lean4 root directory (works for both lean4 repo and nightly distribution)
 export async function isCoreLean4Directory(path) {
     const licensePath = path.join('LICENSE').fsPath;
@@ -23,9 +23,10 @@ export async function isCoreLean4Directory(path) {
 }
 // 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';
+    if (uri.scheme === 'untitled') {
+        return { kind: 'Success', projectRootUri: new UntitledUri(), toolchainUri: undefined };
+    }
     let path = uri;
-    const containingWsFolderUri = getWorkspaceFolderUri(uri);
     try {
         if ((await fs.promises.stat(path.fsPath)).isFile()) {
             path = uri.join('..');
@@ -37,7 +38,9 @@ export async function findLeanProjectRootInfo(uri) {
     let bestFolder = path;
     let bestLeanToolchain;
     while (true) {
-        const leanToolchain = path.join(toolchainFileName);
+        const leanToolchain = path.join('lean-toolchain');
+        const lakefileLean = path.join('lakefile.lean');
+        const lakefileToml = path.join('lakefile.toml');
         if (await fileExists(leanToolchain.fsPath)) {
             bestFolder = path;
             bestLeanToolchain = leanToolchain;
@@ -48,7 +51,13 @@ export async function findLeanProjectRootInfo(uri) {
             // Stop searching in case users accidentally created a lean-toolchain file above the core directory
             break;
         }
-        if (containingWsFolderUri !== undefined && path.equals(containingWsFolderUri)) {
+        else if (await fileExists(lakefileLean.fsPath)) {
+            return { kind: 'LakefileWithoutToolchain', projectRootUri: path, lakefileUri: lakefileLean };
+        }
+        else if (await fileExists(lakefileToml.fsPath)) {
+            return { kind: 'LakefileWithoutToolchain', projectRootUri: path, lakefileUri: lakefileToml };
+        }
+        if (isWorkspaceFolder(path)) {
             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
@@ -69,15 +78,6 @@ export async function findLeanProjectRootInfo(uri) {
     }
     return { kind: 'Success', projectRootUri: bestFolder, toolchainUri: bestLeanToolchain };
 }
-export async function findLeanProjectRoot(uri) {
-    const info = await findLeanProjectRootInfo(uri);
-    switch (info.kind) {
-        case 'Success':
-            return info.projectRootUri;
-        case 'FileNotFound':
-            return 'FileNotFound';
-    }
-}
 export async function findLeanProjectInfo(uri) {
     const info = await findLeanProjectRootInfo(uri);
     switch (info.kind) {
@@ -88,7 +88,9 @@ export async function findLeanProjectInfo(uri) {
             }
             return { kind: 'Success', projectRootUri: info.projectRootUri, toolchainInfo };
         case 'FileNotFound':
-            return { kind: 'FileNotFound' };
+            return info;
+        case 'LakefileWithoutToolchain':
+            return info;
     }
 }
 async function readLeanToolchainFile(toolchainFileUri) {

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

@@ -0,0 +1 @@
+export declare const semVerRegex: RegExp;

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

@@ -0,0 +1,2 @@
+// Suggested at https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+export const semVerRegex = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;

package/dist/vscode-lean4/vscode-lean4/tsconfig.json

@@ -8,8 +8,9 @@
         "lib": ["es6", "ES2021", "es2020.string"],
         "sourceMap": true,
         "alwaysStrict": true,
-        "rootDir": "./",
+        "rootDir": "../..",
         "noImplicitAny": true,
+        "noFallthroughCasesInSwitch": true,
         "strictNullChecks": true,
         "esModuleInterop": true
     },

package/dist/vscode-lean4/vscode-lean4/webview/tsconfig.json

@@ -5,7 +5,9 @@
         "strict": true,
         "lib": ["dom", "es6"],
         "rootDir": "../",
-        "sourceMap": true
+        "sourceMap": true,
+        "module": "esnext",
+        "moduleResolution": "bundler"
     },
     "include": ["./**/*"]
 }

package/dist/vscode.css

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lean4monaco",
-  "version": "1.0.45",
+  "version": "1.1.0",
   "description": "Monaco Editor support for the Lean 4 theorem prover.",
   "keywords": [
     "lean",
@@ -42,12 +42,16 @@
     "test": "npm run demo:setup && concurrently --hide 0 --kill-others \"npm start\" \"wait-on http://localhost:5173 && cypress run\" -n server,cypress -s command-cypress"
   },
   "dependencies": {
-    "lean4": "file:./src/vscode-lean4/vscode-lean4",
+    "@leanprover/infoview": "~0.8.5",
+    "@leanprover/infoview-api": "~0.7.0",
+    "@leanprover/unicode-input": "~0.1.4",
+    "@leanprover/unicode-input-component": "~0.1.4",
     "concurrently": "^8.2.2",
     "import-meta-resolve": "^4.1.0",
     "memfs": "^4.9.3",
     "monaco-editor-wrapper": "^5.3.1",
-    "semver": "^7.6.2"
+    "semver": "^7.6.2",
+    "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/node": "^22.1.0",

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../src/index.ts"],"errors":true,"version":"5.8.2"}