windmill-components 1.35.42 → 1.35.43

package/components/ArgInput.svelte

@@ -83,7 +83,7 @@ function fileChanged(e, cb) {
     }
 }
 function validateInput(pattern, v) {
-    if (required && (v == undefined || v == null)) {
+    if (required && (v == undefined || v == null || v === '')) {
         error = 'This field is required';
         valid = false;
     }
@@ -108,8 +108,11 @@ function testRegex(pattern, value) {
     }
 }
 $: {
-    if (value == undefined) {
+    if (value == undefined || value == null) {
         value = defaultValue;
+        if ((defaultValue === undefined || defaultValue === null) && inputCat === 'string') {
+            value = '';
+        }
     }
 }
 export let inputCat = 'string';
@@ -156,25 +159,19 @@ $: inputCat = computeInputCat(type, format, itemsType?.type, enum_, contentEncod
 					</div>
 				{/if}
 			</div>
-			<span class="text-2xs">Preview:</span>
+			<span class="text-2xs">Input preview:</span>
 		{/if}
 
-		<div class="grid grid-cols-2">
-			{#if description || error}
-				<div class="text-sm italic pb-1">
-					{description}
-				</div>
-				<div class="text-right text-xs {error === '' ? 'text-white' : 'font-bold text-red-600'}">
-					{error === '' ? '...' : error}
-				</div>
-			{:else}
-				<div class="mt-1" />
-			{/if}
-		</div>
+		{#if description}
+			<div class="text-sm italic pb-1">
+				{description}
+			</div>
+		{/if}
 
 		<div class="flex space-x-1">
 			{#if inputCat == 'number'}
 				<input
+					on:focus
 					{disabled}
 					type="number"
 					class={valid
@@ -199,7 +196,7 @@ $: inputCat = computeInputCat(type, format, itemsType?.type, enum_, contentEncod
 			{:else if inputCat == 'list'}
 				<div>
 					<div>
-						{#each value ?? [] as v}
+						{#each value ?? [] as v, i}
 							<div class="flex flex-row max-w-md mt-1">
 								{#if itemsType?.type == 'number'}
 									<input type="number" bind:value={v} />
@@ -207,7 +204,7 @@ $: inputCat = computeInputCat(type, format, itemsType?.type, enum_, contentEncod
 									<input
 										type="file"
 										class="my-6"
-										on:change={(x) => fileChanged(x, (val) => (v = val))}
+										on:change={(x) => fileChanged(x, (val) => (value[i] = val))}
 										multiple={false}
 									/>
 								{:else}
@@ -319,7 +316,7 @@ $: inputCat = computeInputCat(type, format, itemsType?.type, enum_, contentEncod
 				/>
 			{/if}
 			{#if !required && inputCat != 'resource-object'}
-				<Tooltip placement="bottom" content="Reset to default value">
+				<!-- <Tooltip placement="bottom" content="Reset to default value">
 					<Button
 						on:click={() => (value = undefined)}
 						{disabled}
@@ -329,9 +326,12 @@ $: inputCat = computeInputCat(type, format, itemsType?.type, enum_, contentEncod
 					>
 						<Icon data={faArrowRotateLeft} />
 					</Button>
-				</Tooltip>
+				</Tooltip> -->
 			{/if}
 			<slot name="actions" />
 		</div>
+		<div class="text-right text-xs {error === '' ? 'text-white' : 'font-bold text-red-600'}">
+			{error === '' ? '...' : error}
+		</div>
 	</div>
 </div>

package/components/ArgInput.svelte.d.ts

@@ -32,8 +32,8 @@ declare const __propDef: {
         inputCat?: InputCat | undefined;
     };
     events: {
-        input: CustomEvent<any>;
         focus: CustomEvent<any>;
+        input: CustomEvent<any>;
         blur: CustomEvent<any>;
     } & {
         [evt: string]: CustomEvent<any>;

package/components/DisplayResult.svelte

@@ -47,74 +47,80 @@ function inferResultKind(result) {
 }
 </script>
 
-{#if result}
-	{#if typeof result == 'object' && Object.keys(result).length > 0}<div>
-			The result keys are: <b>{truncate(Object.keys(result).join(', '), 50)}</b>
-		</div>
-	{/if}
-	{#if resultKind == 'table-col'}
-		<div class="grid grid-flow-col-dense border border-gray-200 rounded-md ">
-			{#each Object.keys(result) as col}
-				<div class="flex flex-col max-h-40 min-w-full overflow-auto">
-					<div class="px-12 text-left uppercase border-b bg-gray-50 overflow-hidden rounded-t-md ">
-						{col}
+<div>
+	{#if result}
+		{#if typeof result == 'object' && Object.keys(result).length > 0}
+			<div>
+				The result keys are: <b>{truncate(Object.keys(result).join(', '), 50)}</b>
+			</div>{/if}{#if resultKind == 'table-col'}
+			<div class="grid grid-flow-col-dense border border-gray-200 rounded-md ">
+				{#each Object.keys(result) as col}
+					<div class="flex flex-col max-h-40 min-w-full overflow-auto">
+						<div
+							class="px-12 text-left uppercase border-b bg-gray-50 overflow-hidden rounded-t-md "
+						>
+							{col}
+						</div>
+						{#if Array.isArray(result[col])}
+							{#each result[col] as item}
+								<div class="px-12 text-left  whitespace-nowrap">
+									{typeof item === 'string' ? item : JSON.stringify(item)}
+								</div>
+							{/each}
+						{/if}
 					</div>
-					{#if Array.isArray(result[col])}
-						{#each result[col] as item}
-							<div class="px-12 text-left  whitespace-nowrap">
-								{typeof item === 'string' ? item : JSON.stringify(item)}
-							</div>
+				{/each}
+			</div>
+		{:else if resultKind == 'table-row'}<div
+				class="grid grid-flow-col-dense border border-gray-200 rounded-md "
+			>
+				<TableCustom>
+					<tbody slot="body">
+						{#each asListOfList(result) as row}
+							<tr>
+								{#each row as v}
+									<td>{truncate(JSON.stringify(v), 200) ?? ''}</td>
+								{/each}
+							</tr>
 						{/each}
-					{/if}
-				</div>
-			{/each}
-		</div>
-	{:else if resultKind == 'table-row'}<div
-			class="grid grid-flow-col-dense border border-gray-200 rounded-md "
-		>
-			<TableCustom>
-				<tbody slot="body">
-					{#each asListOfList(result) as row}
-						<tr>
-							{#each row as v}
-								<td>{truncate(JSON.stringify(v), 200) ?? ''}</td>
-							{/each}
-						</tr>
-					{/each}
-				</tbody>
-			</TableCustom>
-		</div>
-	{:else if resultKind == 'png'}
-		<div class="h-full">
-			Result is an image: <img
-				alt="png rendered"
-				class="w-auto h-full"
-				src="data:image/png;base64,{result.png}"
+					</tbody>
+				</TableCustom>
+			</div>
+		{:else if resultKind == 'png'}
+			<div class="h-full">
+				Result is an image: <img
+					alt="png rendered"
+					class="w-auto h-full"
+					src="data:image/png;base64,{result.png}"
+				/>
+			</div>
+		{:else if resultKind == 'jpeg'}
+			<div class="h-full">
+				Result is an image: <img
+					alt="jpeg rendered"
+					class="w-auto h-full"
+					src="data:image/jpeg;base64,{result.jpeg}"
+				/>
+			</div>
+		{:else if resultKind == 'gif'}
+			<div class="h-full">
+				Result is an image: <img
+					alt="gif rendered"
+					class="w-auto h-full"
+					src="data:image/gif;base64,{result.gif}"
+				/>
+			</div>
+		{:else if resultKind == 'file'}
+			<div>
+				Result is a file: <a
+					download="windmill.file"
+					href="data:application/octet-stream;base64,{result.file}">Download</a
+				>
+			</div>
+		{:else}<Highlight
+				language={json}
+				code={JSON.stringify(result, null, 4).replace(/\\n/g, '\n')}
 			/>
-		</div>
-	{:else if resultKind == 'jpeg'}
-		<div class="h-full">
-			Result is an image: <img
-				alt="jpeg rendered"
-				class="w-auto h-full"
-				src="data:image/jpeg;base64,{result.jpeg}"
-			/>
-		</div>
-	{:else if resultKind == 'gif'}
-		<div class="h-full">
-			Result is an image: <img
-				alt="gif rendered"
-				class="w-auto h-full"
-				src="data:image/gif;base64,{result.gif}"
-			/>
-		</div>
-	{:else if resultKind == 'file'}
-		<div>
-			Result is a file: <a
-				download="windmill.file"
-				href="data:application/octet-stream;base64,{result.file}">Download</a
-			>
-		</div>
-	{:else}<Highlight language={json} code={JSON.stringify(result, null, 4).replace(/\\n/g, '\n')} />
+		{/if}
 	{/if}
-{/if}
+</div>

package/components/Editor.svelte

@@ -22,13 +22,17 @@ import getMessageServiceOverride from 'vscode/service-override/messages';
 import { StandaloneServices } from 'vscode/services';
 import { DENO_INIT_CODE_CLEAR, PYTHON_INIT_CODE_CLEAR } from '../script_helpers';
 import { createHash as randomHash, editorConfig, langToExt, updateOptions } from '../editorUtils';
-StandaloneServices.initialize({
-    ...getMessageServiceOverride(document.body)
-});
+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 = randomHash();
 export let cmdEnterAction = undefined;
@@ -108,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
+                    })
                 },
-                connectionProvider: {
-                    get: () => {
-                        return Promise.resolve(transports);
+                markdown: {
+                    isTrusted: true
+                },
+                // 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 },
@@ -196,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();
@@ -326,21 +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 == 'python' || deno) {
-        reloadWebsocket();
-    }
+    reloadWebsocket();
     return () => {
         try {
             closeWebsockets();
@@ -351,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));