windmill-components 1.542.4 → 1.550.0

package/package/stores.d.ts

@@ -50,6 +50,7 @@ export declare const copilotInfo: import("svelte/store").Writable<{
     defaultModel?: AIProviderModel;
     aiModels: AIProviderModel[];
     customPrompts?: Record<string, string>;
+    maxTokensPerModel?: Record<string, number>;
 }>;
 export declare function loadCopilot(workspace: string): Promise<void>;
 export declare function setCopilotInfo(aiConfig: AIConfig): void;

package/package/stores.js

@@ -62,7 +62,8 @@ export const copilotInfo = writable({
     codeCompletionModel: undefined,
     defaultModel: undefined,
     aiModels: [],
-    customPrompts: {}
+    customPrompts: {},
+    maxTokensPerModel: {}
 });
 export async function loadCopilot(workspace) {
     workspaceAIClients.init(workspace);
@@ -90,7 +91,8 @@ export function setCopilotInfo(aiConfig) {
             codeCompletionModel: aiConfig.code_completion_model,
             defaultModel: aiConfig.default_model,
             aiModels: aiModels,
-            customPrompts: aiConfig.custom_prompts ?? {}
+            customPrompts: aiConfig.custom_prompts ?? {},
+            maxTokensPerModel: aiConfig.max_tokens_per_model ?? {}
         });
     }
     else {
@@ -100,7 +102,8 @@ export function setCopilotInfo(aiConfig) {
             codeCompletionModel: undefined,
             defaultModel: undefined,
             aiModels: [],
-            customPrompts: {}
+            customPrompts: {},
+            maxTokensPerModel: {}
         });
     }
 }

package/package/timelineCompute.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { DurationStatus } from './components/graph/model';
+export type TimelineItems = Record<string, Array<{
+    created_at?: number;
+    started_at?: number;
+    duration_ms?: number;
+    id: string;
+}>>;
+export declare class TimelineCompute {
+    #private;
+    min: number | undefined;
+    max: number | undefined;
+    total: number | undefined;
+    items: TimelineItems | undefined;
+    now: number;
+    constructor(flowModules: string[], durationStatuses: Record<string, DurationStatus>, flowDone?: boolean);
+    reset(): void;
+    updateInputs(flowModules: string[], durationStatuses: Record<string, DurationStatus>, flowDone?: boolean): void;
+    setFlowDone(flowDone: boolean): void;
+    destroy(): void;
+    private computeItems;
+}

package/package/timelineCompute.svelte.js

@@ -0,0 +1,113 @@
+import { debounce, readFieldsRecursively } from './utils';
+import { untrack } from 'svelte';
+import { getDbClockNow } from './forLater';
+export class TimelineCompute {
+    #flowModules = $state([]);
+    #durationStatuses = $state({});
+    #flowDone = $state(false);
+    #interval = undefined;
+    #debounceInstance;
+    min = $state(undefined);
+    max = $state(undefined);
+    total = $state(undefined);
+    items = $state(undefined);
+    now = $state(getDbClockNow().getTime());
+    constructor(flowModules, durationStatuses, flowDone = false) {
+        this.#flowModules = flowModules;
+        this.#durationStatuses = durationStatuses;
+        this.#flowDone = flowDone;
+        this.#debounceInstance = debounce(() => this.computeItems(this.#durationStatuses), 30);
+        // Set up reactivity using $effect
+        $effect(() => {
+            readFieldsRecursively(this.#durationStatuses);
+            this.#flowDone != undefined &&
+                this.#durationStatuses &&
+                untrack(() => this.#debounceInstance.debounced());
+        });
+        // Set up interval for updating now and total for running jobs
+        this.#interval = setInterval(() => {
+            if (!this.max) {
+                this.now = getDbClockNow().getTime();
+            }
+            if (this.min && (!this.max || this.total == undefined)) {
+                this.total = this.max ? this.max - this.min : Math.max(this.now - this.min, 2000);
+            }
+        }, 30);
+    }
+    reset() {
+        this.min = undefined;
+        this.max = undefined;
+        this.#flowDone = false;
+        this.items = this.computeItems(this.#durationStatuses);
+    }
+    updateInputs(flowModules, durationStatuses, flowDone = false) {
+        this.#flowModules = flowModules;
+        this.#durationStatuses = durationStatuses;
+        this.#flowDone = flowDone;
+    }
+    setFlowDone(flowDone) {
+        this.#flowDone = flowDone;
+    }
+    destroy() {
+        if (this.#interval) {
+            clearInterval(this.#interval);
+        }
+        this.#debounceInstance.clearDebounce();
+    }
+    computeItems(durationStatuses) {
+        let nmin = undefined;
+        let nmax = undefined;
+        let isStillRunning = false;
+        let cnt = 0;
+        let nitems = {};
+        Object.entries(durationStatuses).forEach(([k, o]) => {
+            Object.values(o.byJob).forEach((v) => {
+                cnt++;
+                if (v.started_at) {
+                    if (!nmin) {
+                        nmin = v.started_at;
+                    }
+                    else {
+                        nmin = Math.min(nmin, v.started_at);
+                    }
+                }
+                if (!this.#flowDone && v.duration_ms == undefined) {
+                    isStillRunning = true;
+                }
+                if (!isStillRunning) {
+                    if (v.started_at && v.duration_ms != undefined) {
+                        let lmax = v.started_at + v.duration_ms;
+                        if (!nmax) {
+                            nmax = lmax;
+                        }
+                        else {
+                            nmax = Math.max(nmax, lmax);
+                        }
+                    }
+                }
+            });
+            let arr = Object.entries(o.byJob).map(([k, v]) => ({ ...v, id: k }));
+            arr.sort((x, y) => {
+                if (!x.started_at) {
+                    return -1;
+                }
+                else if (!y.started_at) {
+                    return 1;
+                }
+                else {
+                    return x.started_at - y.started_at;
+                }
+            });
+            nitems[k] = arr;
+        });
+        this.items = nitems;
+        this.min = nmin;
+        this.max =
+            isStillRunning || (cnt < this.#flowModules.length && !this.#flowDone) ? undefined : nmax;
+        if (this.max && this.min) {
+            this.total = this.max - this.min;
+            this.total = Math.max(this.total, 2000);
+        }
+        return nitems;
+    }
+}

package/package/utils.d.ts

@@ -1,6 +1,6 @@
 import { type UserExt } from './stores';
 import { sendUserToast } from './toast';
-import type { Job, Script, ScriptLang } from './gen';
+import type { Job, RunnableKind, Script, ScriptLang } from './gen';
 import type { EnumType, SchemaProperty } from './common';
 import type { Schema } from './common';
 export { sendUserToast };
@@ -45,6 +45,7 @@ export declare function displaySize(sizeInBytes: number | undefined): string | u
 export declare function msToSec(ms: number | undefined, maximumFractionDigits?: number): string;
 export declare function removeTriggerKindIfUnused(length: number, triggerKind: TriggerKind, usedTriggerKinds: string[]): string[];
 export declare function msToReadableTime(ms: number | undefined, maximumFractionDigits?: number): string;
+export declare function msToReadableTimeShort(ms: number | undefined, maximumFractionDigits?: number): string;
 export declare function getToday(): Date;
 export declare function truncateHash(hash: string): string;
 export declare function sleep(ms: number): Promise<void>;
@@ -55,6 +56,7 @@ interface ClickOutsideOptions {
     exclude?: (() => Promise<HTMLElement[]>) | HTMLElement[] | undefined;
     stopPropagation?: boolean;
     customEventName?: string;
+    eventToListenName?: 'click' | 'pointerdown';
     onClickOutside?: (event: MouseEvent) => void;
 }
 export declare function clickOutside(node: Node, options?: ClickOutsideOptions | boolean): {
@@ -100,13 +102,13 @@ export declare function isString(value: any): value is string | String;
 export type InputCat = 'string' | 'email' | 'number' | 'boolean' | 'list' | 'resource-object' | 'enum' | 'date' | 'base64' | 'resource-string' | 'object' | 'sql' | 'yaml' | 'currency' | 'oneOf' | 'dynamic' | 'json-schema' | 'ai-provider';
 export declare namespace DynamicInput {
     type HelperScript = {
-        type: 'inline';
-        path?: string;
-        lang: Script['language'];
-        code: string;
+        source: 'deployed';
+        path: string;
+        runnable_kind: RunnableKind;
     } | {
-        type: 'hash';
-        hash: string;
+        source: 'inline';
+        code: string;
+        lang: ScriptLang;
     };
     const generatePythonFnTemplate: (functionName: string) => string;
     const generateJsFnTemplate: (functionName: string) => string;
@@ -153,7 +155,7 @@ export declare function tryEvery({ tryCode, timeoutCode, interval, timeout }: {
     interval: number;
     timeout: number;
 }): Promise<void>;
-export declare function roughSizeOfObject(object: object | string): number;
+export declare function roughSizeOfObject(object: object | string | any): number;
 export type Value = {
     language?: Script['language'];
     content?: string;
@@ -230,3 +232,8 @@ export declare function isS3Uri(uri: string): uri is S3Uri;
 export declare function uniqueBy<T>(array: T[], key: (t: T) => any): T[];
 export declare function pruneNullishArray<T>(array: (T | null | undefined)[]): T[];
 export declare function assert(msg: string, condition: boolean, value?: any): void;
+export declare function createCache<Keys extends Record<string, any>, T, InitialKeys extends Keys = Keys>(compute: (keys: Keys) => T, params?: {
+    maxSize?: number;
+    initial?: InitialKeys;
+    invalidateMs?: number;
+}): (keys: Keys) => T;

package/package/utils.js

@@ -220,6 +220,26 @@ export function msToReadableTime(ms, maximumFractionDigits) {
         return `${msToSec(ms, maximumFractionDigits)}s`;
     }
 }
+export function msToReadableTimeShort(ms, maximumFractionDigits) {
+    if (ms === undefined)
+        return '?';
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) {
+        return `${days}d`;
+    }
+    else if (hours > 0) {
+        return `${hours}h`;
+    }
+    else if (minutes > 0) {
+        return `${minutes}m`;
+    }
+    else {
+        return `${msToSec(ms, maximumFractionDigits)}s`;
+    }
+}
 export function getToday() {
     var today = new Date();
     return today;
@@ -286,13 +306,14 @@ export function clickOutside(node, options) {
         }
     };
     const capture = typeof options === 'boolean' ? options : (options?.capture ?? true);
-    document.addEventListener('click', handleClick, capture ?? true);
+    const eventToListenName = (typeof options === 'object' && options.eventToListenName) || 'click';
+    document.addEventListener(eventToListenName, handleClick, capture ?? true);
     return {
         update(newOptions) {
             options = newOptions;
         },
         destroy() {
-            document.removeEventListener('click', handleClick, capture ?? true);
+            document.removeEventListener(eventToListenName, handleClick, capture ?? true);
         }
     };
 }
@@ -890,14 +911,14 @@ export async function tryEvery({ tryCode, timeoutCode, interval, timeout }) {
     }
 }
 export function roughSizeOfObject(object) {
-    if (typeof object == 'string') {
+    if (typeof object === 'string') {
         return object.length * 2;
     }
-    var objectList = [];
-    var stack = [object];
-    var bytes = 0;
+    const visited = new Set();
+    const stack = [object];
+    let bytes = 0;
     while (stack.length) {
-        let value = stack.pop();
+        const value = stack.pop();
         if (typeof value === 'boolean') {
             bytes += 4;
         }
@@ -907,11 +928,11 @@ export function roughSizeOfObject(object) {
         else if (typeof value === 'number') {
             bytes += 8;
         }
-        else if (typeof value === 'object' && objectList.indexOf(value) === -1) {
-            objectList.push(value);
-            for (var i in value) {
-                bytes += 2 * i.length;
-                stack.push(value[i]);
+        else if (typeof value === 'object' && value !== null && !visited.has(value)) {
+            visited.add(value);
+            for (const key in value) {
+                bytes += 2 * key.length;
+                stack.push(value[key]);
             }
         }
     }
@@ -1307,3 +1328,32 @@ export function assert(msg, condition, value) {
         console.error(m);
     }
 }
+export function createCache(compute, params) {
+    let cache = new Map();
+    const maxSize = params?.maxSize ?? 15;
+    if (params?.initial) {
+        let key = JSON.stringify(params.initial, Object.keys(params.initial).sort());
+        let value = compute(params.initial);
+        cache.set(key, { value, timestamp: Date.now() });
+    }
+    return (keys) => {
+        if (typeof params?.invalidateMs === 'number') {
+            for (const [key, entry] of cache.entries()) {
+                if (Date.now() - entry.timestamp > params.invalidateMs) {
+                    cache.delete(key);
+                }
+            }
+        }
+        let key = JSON.stringify(keys, Object.keys(keys).sort());
+        if (!cache.get(key)) {
+            let value = compute(keys);
+            cache.set(key, { value, timestamp: Date.now() });
+            if (cache.size > maxSize) {
+                // remove the oldest entry (first inserted)
+                const oldestKey = cache.keys().next().value;
+                cache.delete(oldestKey);
+            }
+        }
+        return cache.get(key).value;
+    };
+}

package/package/workspace_settings.d.ts

@@ -1,15 +1,20 @@
 import type { GetSettingsResponse, LargeFileStorage } from './gen';
-type s3type = 's3' | 'azure_blob' | 's3_aws_oidc' | 'azure_workload_identity' | 'gcloud_storage';
-type s3ResourceSettingsItem = {
-    resourceType: s3type;
+type S3type = 's3' | 'azure_blob' | 's3_aws_oidc' | 'azure_workload_identity' | 'gcloud_storage';
+export type S3ResourceSettingsItem = {
+    resourceType: S3type;
     resourcePath: string | undefined;
     publicResource: boolean | undefined;
+    advancedPermissions?: {
+        pattern: string;
+        allow: ('read' | 'write' | 'delete' | 'list')[];
+    }[];
 };
-export type S3ResourceSettings = s3ResourceSettingsItem & {
-    secondaryStorage: [string, s3ResourceSettingsItem][] | undefined;
+export type S3ResourceSettings = S3ResourceSettingsItem & {
+    secondaryStorage: [string, S3ResourceSettingsItem][] | undefined;
 };
-export declare function convertBackendSettingsToFrontendSettings(large_file_storage: GetSettingsResponse['large_file_storage']): S3ResourceSettings;
-export declare function convertBackendSettingsToFrontendSettingsItem(large_file_storage: GetSettingsResponse['large_file_storage']): s3ResourceSettingsItem;
+export declare function convertBackendSettingsToFrontendSettings(large_file_storage: GetSettingsResponse['large_file_storage'], isEnterprise: boolean): S3ResourceSettings;
+export declare function convertBackendSettingsToFrontendSettingsItem(large_file_storage: GetSettingsResponse['large_file_storage'], isEnterprise: boolean): S3ResourceSettingsItem;
 export declare function convertFrontendToBackendSetting(s3ResourceSettings: S3ResourceSettings): LargeFileStorage | undefined;
-export declare function convertFrontendToBackendettingsItem(s3ResourceSettings: s3ResourceSettingsItem): LargeFileStorage | undefined;
+export declare function convertFrontendToBackendettingsItem(s3ResourceSettings: S3ResourceSettingsItem): LargeFileStorage | undefined;
+export declare function defaultS3AdvancedPermissions(isEnterprise: boolean): S3ResourceSettingsItem['advancedPermissions'];
 export {};

package/package/workspace_settings.js

@@ -1,50 +1,65 @@
 import { emptyString } from './utils';
-export function convertBackendSettingsToFrontendSettings(large_file_storage) {
-    let settings = convertBackendSettingsToFrontendSettingsItem(large_file_storage);
-    settings.secondaryStorage = Object.entries(large_file_storage?.secondary_storage ?? {}).map(([key, value]) => [key, convertBackendSettingsToFrontendSettingsItem(value)]);
+export function convertBackendSettingsToFrontendSettings(large_file_storage, isEnterprise) {
+    let settings = convertBackendSettingsToFrontendSettingsItem(large_file_storage, isEnterprise);
+    settings.secondaryStorage = Object.entries(large_file_storage?.secondary_storage ?? {}).map(([key, value]) => [key, convertBackendSettingsToFrontendSettingsItem(value, isEnterprise)]);
     return settings;
 }
-export function convertBackendSettingsToFrontendSettingsItem(large_file_storage) {
+export function convertBackendSettingsToFrontendSettingsItem(large_file_storage, isEnterprise) {
+    let advancedPermissions = large_file_storage?.advanced_permissions
+        ? large_file_storage.advanced_permissions.map((rule) => ({
+            ...rule,
+            allow: rule.allow
+                ?.split(',')
+                .filter((rule) => !!rule)
+                .map((rule) => rule)
+        }))
+        : undefined;
     if (large_file_storage?.type === 'S3Storage') {
         return {
             resourceType: 's3',
             resourcePath: large_file_storage?.s3_resource_path?.replace('$res:', ''),
-            publicResource: large_file_storage?.public_resource
+            publicResource: large_file_storage?.public_resource,
+            advancedPermissions
         };
     }
     else if (large_file_storage?.type === 'AzureBlobStorage') {
         return {
             resourceType: 'azure_blob',
             resourcePath: large_file_storage?.azure_blob_resource_path?.replace('$res:', ''),
-            publicResource: large_file_storage?.public_resource
+            publicResource: large_file_storage?.public_resource,
+            advancedPermissions
         };
     }
     else if (large_file_storage?.type === 'AzureWorkloadIdentity') {
         return {
             resourceType: 'azure_workload_identity',
             resourcePath: large_file_storage?.azure_blob_resource_path?.replace('$res:', ''),
-            publicResource: large_file_storage?.public_resource
+            publicResource: large_file_storage?.public_resource,
+            advancedPermissions
         };
     }
     else if (large_file_storage?.type === 'S3AwsOidc') {
         return {
             resourceType: 's3_aws_oidc',
             resourcePath: large_file_storage?.s3_resource_path?.replace('$res:', ''),
-            publicResource: large_file_storage?.public_resource
+            publicResource: large_file_storage?.public_resource,
+            advancedPermissions
         };
     }
     else if (large_file_storage?.type === 'GoogleCloudStorage') {
         return {
             resourceType: 'gcloud_storage',
             resourcePath: large_file_storage?.gcs_resource_path?.replace('$res:', ''),
-            publicResource: large_file_storage?.public_resource
+            publicResource: large_file_storage?.public_resource,
+            advancedPermissions
         };
     }
     else {
         return {
             resourceType: 's3',
             resourcePath: undefined,
-            publicResource: undefined
+            publicResource: undefined,
+            advancedPermissions: defaultS3AdvancedPermissions(isEnterprise)
         };
     }
 }
@@ -61,7 +76,15 @@ export function convertFrontendToBackendettingsItem(s3ResourceSettings) {
     if (!emptyString(s3ResourceSettings.resourcePath)) {
         let resourcePathWithPrefix = `$res:${s3ResourceSettings.resourcePath}`;
         let params = {
-            public_resource: s3ResourceSettings.publicResource
+            public_resource: s3ResourceSettings.publicResource,
+            ...(s3ResourceSettings.advancedPermissions
+                ? {
+                    advanced_permissions: s3ResourceSettings.advancedPermissions.map((rule) => ({
+                        ...rule,
+                        allow: rule.allow.join(',')
+                    }))
+                }
+                : {})
         };
         if (s3ResourceSettings.resourceType === 'azure_blob') {
             let typ = 'AzureBlobStorage';
@@ -91,3 +114,15 @@ export function convertFrontendToBackendettingsItem(s3ResourceSettings) {
         return params;
     }
 }
+export function defaultS3AdvancedPermissions(isEnterprise) {
+    if (!isEnterprise)
+        return undefined;
+    return [
+        { pattern: 'windmill_uploads/*', allow: ['read', 'write', 'delete'] },
+        { pattern: 'u/{username}/**/*', allow: ['read', 'write', 'delete', 'list'] },
+        { pattern: 'g/{group}/**/*', allow: ['read', 'write', 'delete', 'list'] },
+        { pattern: 'f/{folder_write}/**/*', allow: ['read', 'write', 'delete', 'list'] },
+        { pattern: 'f/{folder_read}/**/*', allow: ['read', 'list'] },
+        { pattern: '**/*', allow: [] }
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "windmill-components",
-	"version": "1.542.4",
+	"version": "1.550.0",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build",
@@ -151,7 +151,7 @@
 		"windmill-parser-wasm-ts": "1.538.0",
 		"windmill-parser-wasm-yaml": "1.510.1",
 		"windmill-sql-datatype-parser-wasm": "1.512.0",
-		"windmill-utils-internal": "^1.3.0",
+		"windmill-utils-internal": "^1.3.1",
 		"xterm": "^5.3.0",
 		"xterm-readline": "^1.1.2",
 		"y-monaco": "^0.1.4",