windmill-components 1.35.1 → 1.35.43

package/components/Editor.svelte

@@ -1,9 +1,4 @@
 <script context="module">import * as monaco from 'monaco-editor';
-monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
-    target: monaco.languages.typescript.ScriptTarget.Latest,
-    allowNonTsExtensions: true,
-    noLib: true
-});
 monaco.languages.typescript.typescriptDefaults.setCompilerOptions({
     target: monaco.languages.typescript.ScriptTarget.Latest,
     allowNonTsExtensions: true,
@@ -14,40 +9,36 @@ monaco.languages.typescript.typescriptDefaults.setDiagnosticsOptions({
     noSuggestionDiagnostics: true,
     noSyntaxValidation: true
 });
-monaco.languages.json.jsonDefaults.setDiagnosticsOptions({
-    validate: true,
-    allowComments: false,
-    schemas: [],
-    enableSchemaRequest: true
-});
 </script>
 
 <script>import { browser, dev } from '$app/env';
 import { page } from '$app/stores';
 import { sendUserToast } from '../utils';
 import editorWorker from 'monaco-editor/esm/vs/editor/editor.worker?worker';
-import jsonWorker from 'monaco-editor/esm/vs/language/json/json.worker?worker';
 import tsWorker from 'monaco-editor/esm/vs/language/typescript/ts.worker?worker';
 import { buildWorkerDefinition } from 'monaco-editor-workers';
 import { createEventDispatcher, onDestroy, onMount } from 'svelte';
 import getMessageServiceOverride from 'vscode/service-override/messages';
 import { StandaloneServices } from 'vscode/services';
 import { DENO_INIT_CODE_CLEAR, PYTHON_INIT_CODE_CLEAR } from '../script_helpers';
-StandaloneServices.initialize({
-    ...getMessageServiceOverride(document.body)
-});
+import { createHash as randomHash, editorConfig, langToExt, updateOptions } from '../editorUtils';
+try {
+    StandaloneServices.initialize({
+        ...getMessageServiceOverride(document.body)
+    });
+}
+catch (e) {
+    console.error(e);
+}
 let divEl = null;
 let editor;
-export let deno = false;
-export let lang = deno ? 'typescript' : 'python';
+export let lang;
 export let code = '';
-export let hash = (Math.random() + 1).toString(36).substring(2);
+export let hash = randomHash();
 export let cmdEnterAction = undefined;
 export let formatAction = undefined;
 export let automaticLayout = true;
 export let websocketAlive = { pyright: false, black: false, deno: false };
-export let extraLib = '';
-export let extraLibPath = '';
 export let shouldBindKey = true;
 let websockets = [];
 let websocketInterval;
@@ -64,10 +55,7 @@ if (browser) {
         // @ts-ignore
         self.MonacoEnvironment = {
             getWorker: function (_moduleId, label) {
-                if (label === 'json') {
-                    return new jsonWorker();
-                }
-                else if (label === 'typescript' || label === 'javascript') {
+                if (label === 'typescript' || label === 'javascript') {
                     return new tsWorker();
                 }
                 else {
@@ -85,22 +73,6 @@ export function insertAtCursor(code) {
         editor.trigger('keyboard', 'type', { text: code });
     }
 }
-function langToExt(lang) {
-    switch (lang) {
-        case 'typescript':
-            return 'ts';
-        case 'python':
-            return 'py';
-        case 'javascript':
-            return 'js';
-        case 'json':
-            return 'json';
-        case 'sql':
-            return 'sql';
-        default:
-            return 'unknown';
-    }
-}
 export function insertAtBeginning(code) {
     if (editor) {
         const range = { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 1 };
@@ -140,87 +112,87 @@ let command = undefined;
 let monacoServices = undefined;
 export async function reloadWebsocket() {
     await closeWebsockets();
-    if (lang == 'python' || deno) {
-        const { MonacoLanguageClient } = await import('monaco-languageclient');
-        const { CloseAction, ErrorAction } = await import('vscode-languageclient');
-        const { toSocket, WebSocketMessageReader, WebSocketMessageWriter } = await import('vscode-ws-jsonrpc');
-        const vscode = await import('vscode');
-        const { RequestType } = await import('vscode-jsonrpc');
-        // install Monaco language client services
-        const { MonacoServices } = await import('monaco-languageclient');
-        monacoServices = MonacoServices.install();
-        function createLanguageClient(transports, name, initializationOptions) {
-            const client = new MonacoLanguageClient({
-                name: name,
-                clientOptions: {
-                    documentSelector: deno ? ['typescript'] : ['python'],
-                    errorHandler: {
-                        error: () => ({ action: ErrorAction.Continue }),
-                        closed: () => ({
-                            action: CloseAction.Restart
-                        })
-                    },
-                    markdown: {
-                        isTrusted: true
-                    },
-                    // workspaceFolder: { uri: Uri.parse(`/tmp/${name}`), name: 'tmp', index: 0 },
-                    initializationOptions,
-                    middleware: {
-                        workspace: {
-                            configuration: (params, token, configuration) => {
-                                return [
-                                    {
-                                        enable: true
-                                    }
-                                ];
-                            }
-                        }
-                    }
+    const { MonacoLanguageClient } = await import('monaco-languageclient');
+    const { CloseAction, ErrorAction } = await import('vscode-languageclient');
+    const { toSocket, WebSocketMessageReader, WebSocketMessageWriter } = await import('vscode-ws-jsonrpc');
+    const vscode = await import('vscode');
+    const { RequestType } = await import('vscode-jsonrpc');
+    // install Monaco language client services
+    const { MonacoServices } = await import('monaco-languageclient');
+    monacoServices = MonacoServices.install();
+    function createLanguageClient(transports, name, initializationOptions) {
+        const client = new MonacoLanguageClient({
+            name: name,
+            clientOptions: {
+                documentSelector: [lang],
+                errorHandler: {
+                    error: () => ({ action: ErrorAction.Continue }),
+                    closed: () => ({
+                        action: CloseAction.Restart
+                    })
+                },
+                markdown: {
+                    isTrusted: true
                 },
-                connectionProvider: {
-                    get: () => {
-                        return Promise.resolve(transports);
+                // workspaceFolder: { uri: Uri.parse(`/tmp/${name}`), name: 'tmp', index: 0 },
+                initializationOptions,
+                middleware: {
+                    workspace: {
+                        configuration: (params, token, configuration) => {
+                            return [
+                                {
+                                    enable: true
+                                }
+                            ];
+                        }
                     }
                 }
-            });
-            return client;
-        }
-        async function connectToLanguageServer(url, name, options) {
-            try {
-                const webSocket = new WebSocket(url);
-                webSocket.onopen = async () => {
-                    const socket = toSocket(webSocket);
-                    const reader = new WebSocketMessageReader(socket);
-                    const writer = new WebSocketMessageWriter(socket);
-                    const languageClient = createLanguageClient({ reader, writer }, name, options);
-                    websockets.push([languageClient, webSocket]);
-                    reader.onClose(async () => {
-                        try {
-                            console.log('CLOSE');
-                            websocketAlive[name] = false;
-                            await languageClient.stop();
-                        }
-                        catch (err) {
-                            console.error(err);
-                        }
-                    });
-                    socket.onClose((_code, _reason) => {
-                        websocketAlive[name] = false;
-                    });
+            },
+            connectionProvider: {
+                get: () => {
+                    return Promise.resolve(transports);
+                }
+            }
+        });
+        return client;
+    }
+    async function connectToLanguageServer(url, name, options) {
+        try {
+            const webSocket = new WebSocket(url);
+            webSocket.onopen = async () => {
+                const socket = toSocket(webSocket);
+                const reader = new WebSocketMessageReader(socket);
+                const writer = new WebSocketMessageWriter(socket);
+                const languageClient = createLanguageClient({ reader, writer }, name, options);
+                websockets.push([languageClient, webSocket]);
+                reader.onClose(async () => {
                     try {
-                        console.log('started client');
-                        await languageClient.start();
+                        console.log('CLOSE');
+                        websocketAlive[name] = false;
+                        await languageClient.stop();
                     }
                     catch (err) {
-                        console.log('err at client');
                         console.error(err);
-                        throw new Error(err);
                     }
-                    lastWsAttempt = new Date();
-                    nbWsAttempt = 0;
-                    if (name == 'deno') {
-                        command && command.dispose();
-                        command = undefined;
+                });
+                socket.onClose((_code, _reason) => {
+                    websocketAlive[name] = false;
+                });
+                try {
+                    console.log('started client');
+                    await languageClient.start();
+                }
+                catch (err) {
+                    console.log('err at client');
+                    console.error(err);
+                    throw new Error(err);
+                }
+                lastWsAttempt = new Date();
+                nbWsAttempt = 0;
+                if (name == 'deno') {
+                    command && command.dispose();
+                    command = undefined;
+                    try {
                         command = vscode.commands.registerCommand('deno.cache', (uris = []) => {
                             languageClient.sendRequest(new RequestType('deno/cache'), {
                                 referrer: { uri },
@@ -228,90 +200,92 @@ export async function reloadWebsocket() {
                             });
                         });
                     }
-                    websocketAlive[name] = true;
-                };
-            }
-            catch (err) {
-                console.error(`connection to ${name} language server failed`);
-            }
-        }
-        if (deno) {
-            await connectToLanguageServer(`wss://${$page.url.host}/ws/deno`, 'deno', {
-                certificateStores: null,
-                enablePaths: [],
-                config: null,
-                importMap: null,
-                internalDebug: false,
-                lint: false,
-                path: null,
-                tlsCertificate: null,
-                unsafelyIgnoreCertificateErrors: null,
-                unstable: true,
-                enable: true,
-                cache: null,
-                codeLens: {
-                    implementations: true,
-                    references: true
-                },
-                suggest: {
-                    autoImports: true,
-                    completeFunctionCalls: false,
-                    names: true,
-                    paths: true,
-                    imports: {
-                        autoDiscover: true,
-                        hosts: {
-                            'https://deno.land': true
-                        }
+                    catch (err) {
+                        console.error(err);
                     }
                 }
-            });
+                websocketAlive[name] = true;
+            };
         }
-        else {
-            await connectToLanguageServer(`wss://${$page.url.host}/ws/pyright`, 'pyright', {
-                executionEnvironments: [
-                    {
-                        root: '/tmp/pyright',
-                        pythonVersion: '3.7',
-                        pythonPlatform: 'platform',
-                        extraPaths: []
-                    }
-                ]
-            });
-            connectToLanguageServer(`wss://${$page.url.host}/ws/black`, 'black', {
-                formatters: {
-                    black: {
-                        command: 'black',
-                        args: ['--quiet', '-']
-                    }
-                },
-                formatFiletypes: {
-                    python: 'black'
-                }
-            });
+        catch (err) {
+            console.error(`connection to ${name} language server failed`);
         }
-        websocketInterval && clearInterval(websocketInterval);
-        websocketInterval = setInterval(() => {
-            console.log(websocketInterval, document.visibilityState, new Date().getTime() - lastWsAttempt.getTime(), nbWsAttempt);
-            if (document.visibilityState == 'visible') {
-                if (!lastWsAttempt ||
-                    (new Date().getTime() - lastWsAttempt.getTime() > 60000 && nbWsAttempt < 2)) {
-                    if (!websocketAlive.black && !websocketAlive.deno && !websocketAlive.pyright) {
-                        console.log('reconnecting to language servers');
-                        lastWsAttempt = new Date();
-                        nbWsAttempt++;
-                        reloadWebsocket();
-                    }
-                    else {
-                        if (nbWsAttempt >= 2) {
-                            sendUserToast('Giving up on establishing smart assistant connection', true);
-                            clearInterval(websocketInterval);
-                        }
+    }
+    if (lang == 'typescript') {
+        await connectToLanguageServer(`wss://${$page.url.host}/ws/deno`, 'deno', {
+            certificateStores: null,
+            enablePaths: [],
+            config: null,
+            importMap: null,
+            internalDebug: false,
+            lint: false,
+            path: null,
+            tlsCertificate: null,
+            unsafelyIgnoreCertificateErrors: null,
+            unstable: true,
+            enable: true,
+            cache: null,
+            codeLens: {
+                implementations: true,
+                references: true
+            },
+            suggest: {
+                autoImports: true,
+                completeFunctionCalls: false,
+                names: true,
+                paths: true,
+                imports: {
+                    autoDiscover: true,
+                    hosts: {
+                        'https://deno.land': true
                     }
                 }
             }
-        }, 5000);
+        });
+    }
+    else if (lang === 'python') {
+        await connectToLanguageServer(`wss://${$page.url.host}/ws/pyright`, 'pyright', {
+            executionEnvironments: [
+                {
+                    root: '/tmp/pyright',
+                    pythonVersion: '3.7',
+                    pythonPlatform: 'platform',
+                    extraPaths: []
+                }
+            ]
+        });
+        connectToLanguageServer(`wss://${$page.url.host}/ws/black`, 'black', {
+            formatters: {
+                black: {
+                    command: 'black',
+                    args: ['--quiet', '-']
+                }
+            },
+            formatFiletypes: {
+                python: 'black'
+            }
+        });
     }
+    websocketInterval && clearInterval(websocketInterval);
+    websocketInterval = setInterval(() => {
+        if (document.visibilityState == 'visible') {
+            if (!lastWsAttempt ||
+                (new Date().getTime() - lastWsAttempt.getTime() > 60000 && nbWsAttempt < 2)) {
+                if (!websocketAlive.black && !websocketAlive.deno && !websocketAlive.pyright) {
+                    console.log('reconnecting to language servers');
+                    lastWsAttempt = new Date();
+                    nbWsAttempt++;
+                    reloadWebsocket();
+                }
+                else {
+                    if (nbWsAttempt >= 2) {
+                        sendUserToast('Giving up on establishing smart assistant connection', true);
+                        clearInterval(websocketInterval);
+                    }
+                }
+            }
+        }
+    }, 5000);
 }
 async function closeWebsockets() {
     command && command.dispose();
@@ -336,28 +310,8 @@ async function closeWebsockets() {
 }
 async function loadMonaco() {
     const model = monaco.editor.createModel(code, lang, monaco.Uri.parse(uri));
-    model.updateOptions({ tabSize: 2, insertSpaces: true });
-    editor = monaco.editor.create(divEl, {
-        model: model,
-        value: code,
-        language: lang,
-        automaticLayout,
-        readOnly: false,
-        fixedOverflowWidgets: true,
-        autoDetectHighContrast: true,
-        //lineNumbers: 'off',
-        //lineDecorationsWidth: 0,
-        lineNumbersMinChars: 4,
-        lineNumbers: (ln) => '<span class="pr-4 text-gray-400">' + ln + '</span>',
-        folding: false,
-        scrollBeyondLastLine: false,
-        minimap: {
-            enabled: false
-        },
-        lightbulb: {
-            enabled: true
-        }
-    });
+    model.updateOptions(updateOptions);
+    editor = monaco.editor.create(divEl, editorConfig(model, code, lang, automaticLayout));
     if (shouldBindKey) {
         editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyS, function () {
             format();
@@ -378,29 +332,17 @@ async function loadMonaco() {
     });
     editor.onDidFocusEditorText(() => {
         dispatch('focus');
-        if (deno || lang == 'typescript') {
-            if (!websocketAlive.black &&
-                !websocketAlive.deno &&
-                !websocketAlive.pyright &&
-                !websocketInterval) {
-                reloadWebsocket();
-            }
+        if (!websocketAlive.black &&
+            !websocketAlive.deno &&
+            !websocketAlive.pyright &&
+            !websocketInterval) {
+            reloadWebsocket();
         }
     });
     editor.onDidBlurEditorText(() => {
         dispatch('blur');
     });
-    if (lang == 'javascript' && extraLib != '' && extraLibPath != '') {
-        monaco.languages.typescript.javascriptDefaults.setExtraLibs([
-            {
-                content: extraLib,
-                filePath: extraLibPath
-            }
-        ]);
-    }
-    if (lang == 'python' || deno) {
-        reloadWebsocket();
-    }
+    reloadWebsocket();
     return () => {
         try {
             closeWebsockets();
@@ -411,6 +353,17 @@ async function loadMonaco() {
         }
     };
 }
+export function addAction(id, label, callback, keybindings = []) {
+    editor.addAction({
+        id,
+        label,
+        keybindings,
+        contextMenuGroupId: 'navigation',
+        run: function (editor) {
+            callback(editor);
+        }
+    });
+}
 onMount(() => {
     if (browser) {
         loadMonaco().then((x) => (disposeMethod = x));
@@ -433,20 +386,5 @@ onDestroy(() => {
 		padding-left: 0px;
 		padding-right: 0px;
 		/* stylelint-disable-next-line unit-allowed-list */
-		height: 80vh;
-}
-
-	.small-editor {
-		/* stylelint-disable-next-line unit-allowed-list */
-		height: 26vh;
-	}
-
-	.few-lines-editor {
-		/* stylelint-disable-next-line unit-allowed-list */
-		height: 80px;
-	}
-
-	.two-lines-editor {
-		/* stylelint-disable-next-line unit-allowed-list */
-		height: 40px;
-	}</style>
+		height: 80vh
+}</style>

package/components/Editor.svelte.d.ts

@@ -1,9 +1,9 @@
 import { SvelteComponentTyped } from "svelte";
+import * as monaco from 'monaco-editor';
 declare const __propDef: {
     props: {
         [x: string]: any;
-        deno?: boolean | undefined;
-        lang?: string | undefined;
+        lang: 'typescript' | 'python' | 'go';
         code?: string | undefined;
         hash?: string | undefined;
         cmdEnterAction?: (() => void) | undefined;
@@ -14,8 +14,6 @@ declare const __propDef: {
             black: boolean;
             deno: boolean;
         } | undefined;
-        extraLib?: string | undefined;
-        extraLibPath?: string | undefined;
         shouldBindKey?: boolean | undefined;
         getCode?: (() => string) | undefined;
         insertAtCursor?: ((code: string) => void) | undefined;
@@ -23,6 +21,7 @@ declare const __propDef: {
         setCode?: ((ncode: string) => void) | undefined;
         clearContent?: (() => Promise<void>) | undefined;
         reloadWebsocket?: (() => Promise<void>) | undefined;
+        addAction?: ((id: string, label: string, callback: (editor: monaco.editor.IStandaloneCodeEditor) => void, keybindings?: number[]) => void) | undefined;
     };
     events: {
         change: CustomEvent<any>;
@@ -43,5 +42,6 @@ export default class Editor extends SvelteComponentTyped<EditorProps, EditorEven
     get setCode(): (ncode: string) => void;
     get clearContent(): () => Promise<void>;
     get reloadWebsocket(): () => Promise<void>;
+    get addAction(): (id: string, label: string, callback: (editor: monaco.editor.IStandaloneCodeEditor) => void, keybindings?: number[]) => void;
 }
 export {};