windmill-components 1.138.4 → 1.138.6

package/package/components/FlowGraphViewer.svelte

@@ -6,10 +6,10 @@ import { Badge, Button, Drawer, DrawerContent } from './common';
 import { Highlight } from 'svelte-highlight';
 import ObjectViewer from './propertyPicker/ObjectViewer.svelte';
 import typescript from 'svelte-highlight/languages/typescript';
-import { cleanExpr } from './flows/utils';
 import FlowPathViewer from './flows/content/FlowPathViewer.svelte';
 import SchemaViewer from './SchemaViewer.svelte';
 import { scriptPathToHref } from '../scripts';
+import { cleanExpr } from '../utils';
 export let flow;
 export let overflowAuto = false;
 export let noSide = false;

package/package/components/InputTransformForm.svelte

@@ -2,14 +2,14 @@
 import ArgInput from './ArgInput.svelte';
 import FieldHeader from './FieldHeader.svelte';
 import DynamicInputHelpBox from './flows/content/DynamicInputHelpBox.svelte';
-import { codeToStaticTemplate, getDefaultExpr, isCodeInjection } from './flows/utils';
+import { codeToStaticTemplate, getDefaultExpr } from './flows/utils';
 import SimpleEditor from './SimpleEditor.svelte';
 import { Button } from './common';
 import ToggleButtonGroup from './common/toggleButton-v2/ToggleButtonGroup.svelte';
 import ToggleButton from './common/toggleButton-v2/ToggleButton.svelte';
 import { ResourceService } from '../gen';
 import TemplateEditor from './TemplateEditor.svelte';
-import { setInputCat as computeInputCat } from '../utils';
+import { setInputCat as computeInputCat, isCodeInjection } from '../utils';
 import { Code, Plug } from 'lucide-svelte';
 import { workspaceStore } from '../stores';
 export let schema;

package/package/components/InputTransformsViewer.svelte

@@ -1,5 +1,5 @@
-<script>import ObjectViewer from './propertyPicker/ObjectViewer.svelte';
-import { cleanExpr } from './flows/utils';
+<script>import { cleanExpr } from '../utils';
+import ObjectViewer from './propertyPicker/ObjectViewer.svelte';
 export let inputTransforms;
 $: entries = Object.entries(inputTransforms);
 </script>

package/package/components/LightweightArgInput.svelte

@@ -299,12 +299,14 @@ $: inputCat = computeInputCat(type, format, itemsType?.type, enum_, contentEncod
 					multiple={false}
 				/>
 			{:else if inputCat == 'resource-string'}
-				<ResourcePicker
-					bind:value
-					resourceType={format.split('-').length > 1
-						? format.substring('resource-'.length)
-						: undefined}
-				/>
+				<div class="flex flex-row gap-x-1 w-full">
+					<ResourcePicker
+						bind:value
+						resourceType={format.split('-').length > 1
+							? format.substring('resource-'.length)
+							: undefined}
+					/>
+				</div>
 			{:else if inputCat == 'string'}
 				<div class="flex flex-col w-full">
 					<div class="flex flex-row w-full items-center justify-between">

package/package/components/LightweightObjectResourceInput.svelte

@@ -0,0 +1,38 @@
+<script>import LightweightResourcePicker from './LightweightResourcePicker.svelte';
+export let format;
+export let value;
+export let disablePortal = false;
+function isString(value) {
+    return typeof value === 'string' || value instanceof String;
+}
+let path = '';
+function resourceToValue() {
+    if (path) {
+        value = `$res:${path}`;
+    }
+    else {
+        value = undefined;
+    }
+}
+function isResource() {
+    return isString(value) && value.length >= '$res:'.length;
+}
+function valueToPath() {
+    if (isResource()) {
+        path = value.substr('$res:'.length);
+    }
+}
+$: value && valueToPath();
+</script>
+
+<div class="flex flex-row w-full flex-wrap gap-x-2 gap-y-0.5">
+	<LightweightResourcePicker
+		{disablePortal}
+		on:change={(e) => {
+			path = e.detail
+			resourceToValue()
+		}}
+		bind:value={path}
+		resourceType={format.split('-').length > 1 ? format.substring('resource-'.length) : undefined}
+	/>
+</div>

package/package/components/LightweightObjectResourceInput.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        format: string;
+        value: any;
+        disablePortal?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type LightweightObjectResourceInputProps = typeof __propDef.props;
+export type LightweightObjectResourceInputEvents = typeof __propDef.events;
+export type LightweightObjectResourceInputSlots = typeof __propDef.slots;
+export default class LightweightObjectResourceInput extends SvelteComponentTyped<LightweightObjectResourceInputProps, LightweightObjectResourceInputEvents, LightweightObjectResourceInputSlots> {
+}
+export {};

package/package/components/LightweightResourcePicker.svelte

@@ -0,0 +1,78 @@
+<script>import { ResourceService } from '../gen';
+import { workspaceStore } from '../stores';
+import { createEventDispatcher, onMount } from 'svelte';
+import Select from './apps/svelte-select/lib/index';
+import { SELECT_INPUT_DEFAULT_STYLE } from '../defaults';
+import DarkModeObserver from './DarkModeObserver.svelte';
+const dispatch = createEventDispatcher();
+export let initialValue = undefined;
+export let value = initialValue;
+export let resourceType = undefined;
+export let disablePortal = false;
+let valueSelect = initialValue || value
+    ? {
+        value: value ?? initialValue,
+        label: value ?? initialValue
+    }
+    : undefined;
+let collection = [valueSelect];
+async function loadResources(resourceType) {
+    const nc = (await ResourceService.listResource({
+        workspace: $workspaceStore,
+        resourceType
+    })).map((x) => ({
+        value: x.path,
+        label: x.path
+    }));
+    // TODO check if this is needed
+    if (!nc.find((x) => x.value == value) && (initialValue || value)) {
+        nc.push({ value: value ?? initialValue, label: value ?? initialValue });
+    }
+    collection = nc;
+}
+$: {
+    if ($workspaceStore) {
+        loadResources(resourceType);
+    }
+}
+$: dispatch('change', value);
+let darkMode = false;
+function onThemeChange() {
+    if (document.documentElement.classList.contains('dark')) {
+        darkMode = true;
+    }
+    else {
+        darkMode = false;
+    }
+}
+onMount(() => {
+    onThemeChange();
+});
+</script>
+
+<DarkModeObserver on:change={onThemeChange} />
+
+<Select
+	portal={!disablePortal}
+	value={valueSelect}
+	on:change={(e) => {
+		value = e.detail.value
+		valueSelect = e.detail
+	}}
+	on:clear={() => {
+		value = undefined
+		valueSelect = undefined
+	}}
+	items={collection}
+	class="text-clip grow min-w-0"
+	placeholder="{resourceType ?? 'any'} resource"
+	inputStyles={SELECT_INPUT_DEFAULT_STYLE.inputStyles}
+	containerStyles={darkMode
+		? SELECT_INPUT_DEFAULT_STYLE.containerStylesDark
+		: SELECT_INPUT_DEFAULT_STYLE.containerStyles}
+/>
+
+<style>
+	:global(.svelte-select-list) {
+		font-size: small !important;
+	}</style>

package/package/components/LightweightResourcePicker.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        initialValue?: string | undefined;
+        value?: string | undefined;
+        resourceType?: string | undefined;
+        disablePortal?: boolean | undefined;
+    };
+    events: {
+        change: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type LightweightResourcePickerProps = typeof __propDef.props;
+export type LightweightResourcePickerEvents = typeof __propDef.events;
+export type LightweightResourcePickerSlots = typeof __propDef.slots;
+export default class LightweightResourcePicker extends SvelteComponentTyped<LightweightResourcePickerProps, LightweightResourcePickerEvents, LightweightResourcePickerSlots> {
+}
+export {};

package/package/components/apps/components/display/AppText.svelte

@@ -1,9 +1,8 @@
-<script>import { isCodeInjection } from '../../../flows/utils';
-import Tooltip from '../../../Tooltip.svelte';
+<script>import Tooltip from '../../../Tooltip.svelte';
 import { Clipboard } from 'lucide-svelte';
 import { getContext } from 'svelte';
 import { twMerge } from 'tailwind-merge';
-import { copyToClipboard } from '../../../../utils';
+import { copyToClipboard, isCodeInjection } from '../../../../utils';
 import Button from '../../../common/button/Button.svelte';
 import { initConfig, initOutput } from '../../editor/appUtils';
 import { components } from '../../editor/component';

package/package/components/apps/components/helpers/InputValue.svelte

@@ -1,9 +1,9 @@
-<script>import { isCodeInjection } from '../../../flows/utils';
-import { createEventDispatcher, getContext, onDestroy, tick } from 'svelte';
+<script>import { createEventDispatcher, getContext, onDestroy, tick } from 'svelte';
 import { accessPropertyByPath } from '../../utils';
 import { computeGlobalContext, eval_like } from './eval';
 import deepEqualWithOrderedArray from './deepEqualWithOrderedArray';
 import { deepEqual } from 'fast-equals';
+import { isCodeInjection } from '../../../../utils';
 export let input;
 export let value;
 export let id = undefined;

package/package/components/flows/utils.d.ts

@@ -4,12 +4,10 @@ import type { FlowModuleState } from './flowState';
 import type { PickableProperties } from './previousResults';
 export declare function evalValue(k: string, mod: FlowModule, testStepStore: Record<string, any>, pickableProperties: PickableProperties | undefined, showError: boolean): any;
 export declare function cleanInputs(flow: Flow | any): Flow;
-export declare function cleanExpr(expr: string): string;
 export declare function loadSchemaFromModule(module: FlowModule): Promise<{
     input_transforms: Record<string, InputTransform>;
     schema: Schema;
 }>;
-export declare function isCodeInjection(expr: string | undefined): boolean;
 export declare function getDefaultExpr(key: string | undefined, previousModuleId: string | undefined, previousExpr?: string): string;
 export declare function jobsToResults(jobs: Job[]): any;
 export declare function runFlowPreview(args: Record<string, any>, flow: Flow): Promise<string>;

package/package/components/flows/utils.js

@@ -1,8 +1,8 @@
 import { JobService, ScriptService } from '../../gen';
-import { inferArgs } from '../../infer';
-import { loadSchema, loadSchemaFlow } from '../../scripts';
+import { inferArgs, loadSchemaFromPath } from '../../infer';
+import { loadSchemaFlow } from '../../scripts';
 import { workspaceStore } from '../../stores';
-import { emptySchema } from '../../utils';
+import { cleanExpr, emptySchema } from '../../utils';
 import { get } from 'svelte/store';
 import { NEVER_TESTED_THIS_FAR } from './models';
 import { sendUserToast } from '../../toast';
@@ -70,12 +70,6 @@ export function cleanInputs(flow) {
     });
     return newFlow;
 }
-export function cleanExpr(expr) {
-    return expr
-        .split('\n')
-        .filter((x) => x != '' && !x.startsWith(`import `))
-        .join('\n');
-}
 export async function loadSchemaFromModule(module) {
     const mod = module.value;
     if (mod.type == 'rawscript' || mod.type === 'script' || mod.type === 'flow') {
@@ -85,7 +79,7 @@ export async function loadSchemaFromModule(module) {
             await inferArgs(mod.language, mod.content ?? '', schema);
         }
         else if (mod.type == 'script' && mod.path && mod.path != '') {
-            schema = await loadSchema(mod.path, mod.hash);
+            schema = await loadSchemaFromPath(mod.path, mod.hash);
         }
         else if (mod.type == 'flow' && mod.path && mod.path != '') {
             schema = await loadSchemaFlow(mod.path);
@@ -121,13 +115,6 @@ export async function loadSchemaFromModule(module) {
         schema: emptySchema()
     };
 }
-const dynamicTemplateRegex = new RegExp(/\$\{(.*)\}/);
-export function isCodeInjection(expr) {
-    if (!expr) {
-        return false;
-    }
-    return dynamicTemplateRegex.test(expr);
-}
 export function getDefaultExpr(key = 'myfield', previousModuleId, previousExpr) {
     return (previousExpr ?? (previousModuleId ? `results.${previousModuleId}.${key}` : `flow_input.${key}`));
 }

package/package/infer.d.ts

@@ -1,5 +1,6 @@
 import type { Schema, SupportedLanguage } from './common.js';
 export declare function inferArgs(language: SupportedLanguage, code: string, schema: Schema): Promise<void>;
+export declare function loadSchemaFromPath(path: string, hash?: string): Promise<Schema>;
 export declare function loadSchema(workspace: string, path: string, runType: 'script' | 'flow' | 'hubscript'): Promise<{
     schema: Schema;
     summary: string | undefined;

package/package/infer.js

@@ -1,9 +1,10 @@
-import { ScriptService, FlowService } from './gen';
+import { ScriptService, FlowService, Script } from './gen';
 import { get, writable } from 'svelte/store';
 import { emptySchema, sortObject } from './utils.js';
 import { tick } from 'svelte';
 import init, { parse_deno, parse_bash, parse_go, parse_python, parse_sql, parse_mysql, parse_bigquery } from 'windmill-parser-wasm';
 import wasmUrl from 'windmill-parser-wasm/windmill_parser_wasm_bg.wasm?url';
+import { workspaceStore } from './stores.js';
 init(wasmUrl);
 const loadSchemaLastRun = writable(undefined);
 export async function inferArgs(language, code, schema) {
@@ -179,6 +180,43 @@ function argSigToJsonSchemaType(t, oldS) {
         oldS.format = undefined;
     }
 }
+export async function loadSchemaFromPath(path, hash) {
+    if (path.startsWith('hub/')) {
+        const { content, language, schema } = await ScriptService.getHubScriptByPath({ path });
+        if (language == 'deno') {
+            const newSchema = emptySchema();
+            await inferArgs('deno', content ?? '', newSchema);
+            return newSchema;
+        }
+        else {
+            return schema ?? emptySchema();
+        }
+    }
+    else if (hash) {
+        const script = await ScriptService.getScriptByHash({
+            workspace: get(workspaceStore),
+            hash
+        });
+        return inferSchemaIfNecessary(script);
+    }
+    else {
+        const script = await ScriptService.getScriptByPath({
+            workspace: get(workspaceStore),
+            path: path ?? ''
+        });
+        return inferSchemaIfNecessary(script);
+    }
+}
+async function inferSchemaIfNecessary(script) {
+    if (script.schema) {
+        return script.schema;
+    }
+    else {
+        const newSchema = emptySchema();
+        await inferArgs(script.language, script.content ?? '', newSchema);
+        return newSchema;
+    }
+}
 export async function loadSchema(workspace, path, runType) {
     if (runType === 'script') {
         const script = await ScriptService.getScriptByPath({

package/package/scripts.d.ts

@@ -1,7 +1,6 @@
 import type { Schema, SupportedLanguage } from './common';
 import { Script } from './gen';
 export declare function scriptLangToEditorLang(lang: Script.language): "graphql" | "sql" | Script.language.GO | "typescript" | "python" | "shell";
-export declare function loadSchema(path: string, hash?: string): Promise<Schema>;
 export declare function loadSchemaFlow(path: string): Promise<Schema>;
 export declare function scriptPathToHref(path: string): string;
 export declare function getScriptByPath(path: string): Promise<{

package/package/scripts.js

@@ -1,8 +1,6 @@
 import { get } from 'svelte/store';
 import { FlowService, Script, ScriptService } from './gen';
-import { inferArgs } from './infer';
 import { workspaceStore, hubScripts } from './stores';
-import { emptySchema } from './utils';
 export function scriptLangToEditorLang(lang) {
     if (lang == 'deno') {
         return 'typescript';
@@ -37,43 +35,6 @@ export function scriptLangToEditorLang(lang) {
         return lang;
     }
 }
-export async function loadSchema(path, hash) {
-    if (path.startsWith('hub/')) {
-        const { content, language, schema } = await ScriptService.getHubScriptByPath({ path });
-        if (language == 'deno') {
-            const newSchema = emptySchema();
-            await inferArgs('deno', content ?? '', newSchema);
-            return newSchema;
-        }
-        else {
-            return schema ?? emptySchema();
-        }
-    }
-    else if (hash) {
-        const script = await ScriptService.getScriptByHash({
-            workspace: get(workspaceStore),
-            hash
-        });
-        return inferSchemaIfNecessary(script);
-    }
-    else {
-        const script = await ScriptService.getScriptByPath({
-            workspace: get(workspaceStore),
-            path: path ?? ''
-        });
-        return inferSchemaIfNecessary(script);
-    }
-}
-async function inferSchemaIfNecessary(script) {
-    if (script.schema) {
-        return script.schema;
-    }
-    else {
-        const newSchema = emptySchema();
-        await inferArgs(script.language, script.content ?? '', newSchema);
-        return newSchema;
-    }
-}
 export async function loadSchemaFlow(path) {
     const flow = await FlowService.getFlowByPath({
         workspace: get(workspaceStore),
@@ -99,7 +60,7 @@ export async function getScriptByPath(path) {
             description: '',
             tag: undefined,
             concurrent_limit: undefined,
-            concurrency_time_window_s: undefined,
+            concurrency_time_window_s: undefined
         };
     }
     else {
@@ -114,7 +75,7 @@ export async function getScriptByPath(path) {
             description: script.description,
             tag: script.tag,
             concurrent_limit: script.concurrent_limit,
-            concurrency_time_window_s: script.concurrency_time_window_s,
+            concurrency_time_window_s: script.concurrency_time_window_s
         };
     }
 }

package/package/utils.d.ts

@@ -89,3 +89,5 @@ export declare function isOwner(path: string, user: UserExt | undefined, workspa
 export declare function isObviousOwner(path: string, user?: UserExt): boolean;
 export declare function extractCustomProperties(styleStr: string): string;
 export declare function toCamel(s: string): string;
+export declare function cleanExpr(expr: string): string;
+export declare function isCodeInjection(expr: string | undefined): boolean;

package/package/utils.js

@@ -499,3 +499,16 @@ export function toCamel(s) {
         return $1.toUpperCase().replace('-', '').replace('_', '');
     });
 }
+export function cleanExpr(expr) {
+    return expr
+        .split('\n')
+        .filter((x) => x != '' && !x.startsWith(`import `))
+        .join('\n');
+}
+const dynamicTemplateRegex = new RegExp(/\$\{(.*)\}/);
+export function isCodeInjection(expr) {
+    if (!expr) {
+        return false;
+    }
+    return dynamicTemplateRegex.test(expr);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "windmill-components",
-	"version": "1.138.4",
+	"version": "1.138.6",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build",