windmill-components 1.655.0 → 1.655.2

package/dist/sharedUtils/svelte5Utils.svelte.d.ts

@@ -1,4 +1,6 @@
-import type { StateStore } from './utils';
+import { type StateStore } from './utils';
+import * as runed from 'runed/kit';
+import type z from 'zod';
 export declare function withProps<Component, Props>(component: Component, props: Props): {
     component: Component;
     props: Props;
@@ -30,6 +32,9 @@ export type UsePromiseOptions = {
     loadInit?: boolean;
     clearValueOnRefresh?: boolean;
 };
+/**
+ * @deprecated Use `resource` from `runed` instead
+ */
 export declare function usePromise<T>(createPromise: () => Promise<T>, { loadInit, clearValueOnRefresh }?: UsePromiseOptions): UsePromiseResult<T>;
 /**
  * Generic change tracker class that monitors changes in state using deep equality comparison
@@ -47,3 +52,29 @@ export declare class ChangeTracker<T> {
      */
     track(value: T): boolean;
 }
+/**
+ * This allows using async resources that only fetch missing data based on a set of keys.
+ * It maintains a Record of the fetched data and only calls the fetcher for keys that
+ * are not already present in the map.
+ * The fetcher takes a record of keys to allow fetching multiple items in a single call.
+ */
+export declare class MapResource<U, T> {
+    private _cached;
+    private _fetcherResource;
+    constructor(getValues: () => Record<string, U>, fetcher: (toFetch: Record<string, U>) => Promise<Record<string, T>>);
+    get current(): Record<string, T> | undefined;
+    get loading(): boolean;
+    get error(): Error | undefined;
+}
+export declare class ChangeOnDeepInequality<T> {
+    private _cached;
+    constructor(compute: () => T);
+    get value(): T;
+}
+export declare function useSearchParams<S extends z.ZodType>(schema: S, options?: runed.SearchParamsOptions): runed.ReturnUseSearchParams<S>;
+export declare class StaleWhileLoading<T> {
+    private _current;
+    private _currentTimeout;
+    constructor(getter: () => T, timeout?: number);
+    get current(): T | undefined;
+}

package/dist/sharedUtils/utils.d.ts

@@ -38,7 +38,7 @@ export declare function validateUsername(username: string): string;
 export declare function parseQueryParams(url: string | undefined): Record<string, string>;
 export declare function displayDateOnly(dateString: string | Date | undefined): string;
 export declare function retrieveCommonWorkerPrefix(workerName: string): string;
-export declare function subtractDaysFromDateString(dateString: string | undefined, days: number): string | undefined;
+export declare function subtractDaysFromDateString(dateString: string | null, days: number): string | undefined;
 export declare function displayDate(dateString: string | Date | undefined, displaySecond?: boolean, displayDate?: boolean): string;
 export declare function displayTime(dateString: string | Date | undefined): string;
 export declare function displaySize(sizeInBytes: number | undefined): string | undefined;
@@ -63,6 +63,7 @@ export declare function clickOutside(node: Node, options?: ClickOutsideOptions |
     destroy(): void;
     update(newOptions: ClickOutsideOptions | boolean): void;
 };
+export declare function undefinedIfEmpty(obj: any): any;
 export declare function pointerDownOutside(node: Node, options?: ClickOutsideOptions): {
     destroy(): void;
     update(newOptions: ClickOutsideOptions): void;
@@ -136,6 +137,12 @@ export declare function throttle<T>(func: (...args: any[]) => T, wait: number):
 export declare function isMac(): boolean;
 export declare function getModifierKey(): string;
 export declare function isValidHexColor(color: string): boolean;
+/**
+ * Generates a text color with the same hue as the background but adjusted lightness for good contrast
+ * @param backgroundColor Hex color string (e.g., "#FF0000" or "#F00")
+ * @returns Hex color string with same hue but good contrast, or undefined if invalid
+ */
+export declare function getContrastTextColor(backgroundColor: string | null | undefined): string | undefined;
 export declare function sortObject<T>(o: T & object): T;
 export declare function sortArray<T>(array: T[], compareFn?: (a: T, b: T) => number): T[];
 export declare function generateRandomString(len?: number): string;
@@ -180,7 +187,7 @@ export declare function getSchemaFromProperties(properties: {
 }): Schema;
 export declare function validateFileExtension(ext: string): boolean;
 export declare function isFlowPreview(job_kind: Job['job_kind'] | undefined): job_kind is "flowpreview" | "flownode";
-export declare function isNotFlow(job_kind: Job['job_kind'] | undefined): job_kind is "script" | "aiagent" | "identity" | "preview" | "dependencies" | "flowdependencies" | "appdependencies" | "script_hub" | "deploymentcallback" | "flowscript" | "appscript" | undefined;
+export declare function isNotFlow(job_kind: Job['job_kind'] | undefined): job_kind is "script" | "aiagent" | "identity" | "preview" | "dependencies" | "flowdependencies" | "appdependencies" | "script_hub" | "deploymentcallback" | "flowscript" | "appscript" | "unassigned_script" | "unassigned_flow" | "unassigned_singlestepflow" | undefined;
 export declare function isScriptPreview(job_kind: Job['job_kind'] | undefined): job_kind is "preview" | "flowscript" | "appscript";
 export declare function conditionalMelt(node: HTMLElement, meltItem: AnyMeltElement | undefined): void | import("svelte/action").ActionReturn<undefined, Record<never, any>>;
 export type Item = {
@@ -195,6 +202,7 @@ export type Item = {
     hide?: boolean | undefined;
     extra?: Snippet;
     id?: string;
+    tooltip?: string;
 };
 export declare function isObjectTooBig(obj: any): boolean;
 export declare function localeConcatAnd(items: string[]): string;
@@ -202,11 +210,9 @@ export declare function formatDate(dateString: string | undefined): string;
 export declare function formatDateShort(dateString: string | undefined): string;
 export declare function toJsonStr(result: any): string;
 export declare function getOS(): "Windows" | "macOS" | "iOS" | "Android" | "Linux" | "Unknown OS";
-import { type ClassValue } from 'clsx';
 import type { Component, Snippet } from 'svelte';
 import { OpenAPIV2, type OpenAPI, type OpenAPIV3, type OpenAPIV3_1 } from 'openapi-types';
 import type { IPosition } from 'monaco-editor';
-export declare function cn(...inputs: ClassValue[]): string;
 export type StateStore<T> = {
     val: T;
 };
@@ -241,6 +247,7 @@ export declare function wait(ms: number): Promise<unknown>;
 export declare function validateRetryConfig(retry: Retry | undefined): string | null;
 export type CssColor = keyof (typeof tokensFile)['tokens']['light'];
 import tokensFile from './assets/tokens/tokens.json';
+import { Package } from 'lucide-svelte';
 export declare function getCssColor(color: CssColor, { alpha, format }: {
     alpha?: number;
     format?: 'css-var' | 'hex-dark' | 'hex-light';
@@ -248,3 +255,11 @@ export declare function getCssColor(color: CssColor, { alpha, format }: {
 export type IconType = Component<{
     size?: number;
 }> | typeof import('lucide-svelte').Dot;
+export declare function getJobKindIcon(jobKind: Job['job_kind']): import("svelte/legacy").LegacyComponentType | typeof Package | undefined;
+export declare function chunkBy<T>(array: T[], getKey: (key: T) => string): T[][];
+export declare function getQueryStmtCountHeuristic(query: string): number;
+export declare function countChars(str: string, char: string): number;
+export declare function buildReactiveObj<T extends object>(fields: {
+    [name in keyof T]: [() => T[name], (v: T[name]) => void];
+}): T;
+export declare function pick<T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K>;

package/package/components/custom_ui.d.ts

@@ -45,6 +45,7 @@ export type FlowBuilderWhitelabelCustomUi = {
     tagSelectNoLabel?: boolean;
     tagLabel?: string;
     aiAgent?: boolean;
+    aiSandbox?: boolean;
 };
 export type DisplayResultUi = {
     disableAiFix?: boolean;

package/package/components/flows/content/FlowInputs.svelte

@@ -251,7 +251,7 @@ let customUi = getContext('customUi');
 			{/each}
 		</div>
 
-		{#if !failureModule && !preprocessorModule}
+		{#if !failureModule && !preprocessorModule && customUi?.aiSandbox != false}
 			<h3 class="pb-2 pt-4">AI Sandbox</h3>
 			<div class="flex flex-row flex-wrap gap-2">
 				<FlowScriptPicker

package/package/components/flows/content/FlowInputsQuick.svelte

@@ -402,7 +402,7 @@ let aiLength = $derived(funcDesc?.length > 0 && !disableAi && selectedKind != 'f
 			{/await}
 			<div class="pb-1"></div>
 		{/if}
-		{#if selectedKind === 'script' && preFilter === 'all' && !selected}
+		{#if selectedKind === 'script' && preFilter === 'all' && !selected && customUi?.aiSandbox != false}
 			<div class="pb-0 text-2xs font-normal text-secondary ml-2">AI Sandbox</div>
 			<FlowScriptPickerQuick
 				eeRestricted={false}

package/package/components/flows/map/InsertModuleInner.svelte

@@ -159,6 +159,7 @@ let displayPath = $derived(width > 650 || height > 400);
 							}}
 						/>
 					{/if}
+					{#if customUi?.aiSandbox != false}
 					<TopLevelNode
 						label="AI Sandbox"
 						selected={selectedKind === 'aisandbox'}
@@ -167,6 +168,7 @@ let displayPath = $derived(width > 650 || height > 400);
 						}}
 					/>
 				{/if}
+				{/if}
 			</div>
 		{/if}
 

package/package/components/runs/RunBadges.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">import Tooltip from '../meltComponents/Tooltip.svelte';
 import PreprocessedArgsDisplay from './PreprocessedArgsDisplay.svelte';
 import { truncateHash } from '../../utils';
-import { base } from '$app/paths';
+import { base } from '../../base';
 import { truncateRev } from '../../utils';
 import { workspaceStore } from '../../stores';
 import Badge from '../common/badge/Badge.svelte';

package/package/components/runs/TimeframeSelect.svelte

@@ -1,35 +1,5 @@
-<script module lang="ts">function computeMinMaxInc(inc) {
-    let minTs = new Date(new Date().getTime() - inc).toISOString();
-    let maxTs = new Date().toISOString();
-    return { minTs, maxTs };
-}
-export function buildManualTimeframe(minTs, maxTs) {
-    return {
-        label: formatDateRange(minTs ?? undefined, maxTs ?? undefined),
-        minTs,
-        maxTs,
-        type: 'manual',
-        computeMinMax: () => ({ minTs, maxTs })
-    };
-}
-export const serviceLogsTimeframes = [
-    { label: '1000 last service logs', computeMinMax: () => ({ minTs: null, maxTs: null }) },
-    { label: 'Within last 5 minutes', computeMinMax: () => computeMinMaxInc(5 * 60 * 1000) },
-    { label: 'Within last 30 minutes', computeMinMax: () => computeMinMaxInc(30 * 60 * 1000) },
-    { label: 'Within last 24 hours', computeMinMax: () => computeMinMaxInc(24 * 60 * 60 * 1000) },
-    { label: 'Within last 7 days', computeMinMax: () => computeMinMaxInc(7 * 24 * 60 * 60 * 1000) },
-    { label: 'Within last month', computeMinMax: () => computeMinMaxInc(30 * 24 * 60 * 60 * 1000) }
-].map((item) => ({ ...item, type: 'dynamic' }));
-export const runsTimeframes = [
-    { label: 'Latest runs', computeMinMax: () => ({ minTs: null, maxTs: null }) },
-    { label: 'Within 30 seconds', computeMinMax: () => computeMinMaxInc(30 * 1000) },
-    { label: 'Within last minute', computeMinMax: () => computeMinMaxInc(60 * 1000) },
-    { label: 'Within last 5 minutes', computeMinMax: () => computeMinMaxInc(5 * 60 * 1000) },
-    { label: 'Within last 30 minutes', computeMinMax: () => computeMinMaxInc(30 * 60 * 1000) },
-    { label: 'Within last 24 hours', computeMinMax: () => computeMinMaxInc(24 * 60 * 60 * 1000) },
-    { label: 'Within last 7 days', computeMinMax: () => computeMinMaxInc(7 * 24 * 60 * 60 * 1000) },
-    { label: 'Within last month', computeMinMax: () => computeMinMaxInc(30 * 24 * 60 * 60 * 1000) }
-].map((item) => ({ ...item, type: 'dynamic' }));
+<script module lang="ts">export { buildManualTimeframe, serviceLogsTimeframes, runsTimeframes } from './timeframes';
+import { buildManualTimeframe } from './timeframes';
 export function useUrlSyncedTimeframe(timeframes) {
     let obj = $state({ timeframe: timeframes[0] });
     let timeframe = $derived(obj.timeframe);

package/package/components/runs/TimeframeSelect.svelte.d.ts

@@ -1,23 +1,5 @@
-export type Timeframe = {
-    label: string;
-    computeMinMax: () => {
-        minTs: string | null;
-        maxTs: string | null;
-    };
-    type: 'dynamic';
-} | {
-    label: string;
-    computeMinMax: () => {
-        minTs: string | null;
-        maxTs: string | null;
-    };
-    minTs: string | null;
-    maxTs: string | null;
-    type: 'manual';
-};
-export declare function buildManualTimeframe(minTs: string | null, maxTs: string | null): Timeframe;
-export declare const serviceLogsTimeframes: Timeframe[];
-export declare const runsTimeframes: Timeframe[];
+export { type Timeframe, buildManualTimeframe, serviceLogsTimeframes, runsTimeframes } from './timeframes';
+import { type Timeframe } from './timeframes';
 export declare function useUrlSyncedTimeframe(timeframes: Timeframe[]): {
     timeframe: Timeframe;
 };

package/package/components/runs/runsFilter.js

@@ -1,6 +1,6 @@
 import { Braces, Calendar, Clock, ServerCog, FileCode, FolderIcon, Hash, ListFilter, Lock, Tag, UserIcon, Zap, CirclePlayIcon } from 'lucide-svelte';
 import { triggerDisplayNamesMap } from '../triggers/utils';
-import { runsTimeframes } from './TimeframeSelect.svelte';
+import { runsTimeframes } from './timeframes';
 export function buildRunsFilterSearchbarSchema({ paths, usernames, folders, jobTriggerKinds, isSuperAdmin, isAdminsWorkspace }) {
     return {
         _default_: {

package/package/components/runs/timeframes.d.ts

@@ -0,0 +1,20 @@
+export type Timeframe = {
+    label: string;
+    computeMinMax: () => {
+        minTs: string | null;
+        maxTs: string | null;
+    };
+    type: 'dynamic';
+} | {
+    label: string;
+    computeMinMax: () => {
+        minTs: string | null;
+        maxTs: string | null;
+    };
+    minTs: string | null;
+    maxTs: string | null;
+    type: 'manual';
+};
+export declare function buildManualTimeframe(minTs: string | null, maxTs: string | null): Timeframe;
+export declare const serviceLogsTimeframes: Timeframe[];
+export declare const runsTimeframes: Timeframe[];

package/package/components/runs/timeframes.js

@@ -0,0 +1,33 @@
+import { formatDateRange } from '../../utils';
+function computeMinMaxInc(inc) {
+    let minTs = new Date(new Date().getTime() - inc).toISOString();
+    let maxTs = new Date().toISOString();
+    return { minTs, maxTs };
+}
+export function buildManualTimeframe(minTs, maxTs) {
+    return {
+        label: formatDateRange(minTs ?? undefined, maxTs ?? undefined),
+        minTs,
+        maxTs,
+        type: 'manual',
+        computeMinMax: () => ({ minTs, maxTs })
+    };
+}
+export const serviceLogsTimeframes = [
+    { label: '1000 last service logs', computeMinMax: () => ({ minTs: null, maxTs: null }) },
+    { label: 'Within last 5 minutes', computeMinMax: () => computeMinMaxInc(5 * 60 * 1000) },
+    { label: 'Within last 30 minutes', computeMinMax: () => computeMinMaxInc(30 * 60 * 1000) },
+    { label: 'Within last 24 hours', computeMinMax: () => computeMinMaxInc(24 * 60 * 60 * 1000) },
+    { label: 'Within last 7 days', computeMinMax: () => computeMinMaxInc(7 * 24 * 60 * 60 * 1000) },
+    { label: 'Within last month', computeMinMax: () => computeMinMaxInc(30 * 24 * 60 * 60 * 1000) }
+].map((item) => ({ ...item, type: 'dynamic' }));
+export const runsTimeframes = [
+    { label: 'Latest runs', computeMinMax: () => ({ minTs: null, maxTs: null }) },
+    { label: 'Within 30 seconds', computeMinMax: () => computeMinMaxInc(30 * 1000) },
+    { label: 'Within last minute', computeMinMax: () => computeMinMaxInc(60 * 1000) },
+    { label: 'Within last 5 minutes', computeMinMax: () => computeMinMaxInc(5 * 60 * 1000) },
+    { label: 'Within last 30 minutes', computeMinMax: () => computeMinMaxInc(30 * 60 * 1000) },
+    { label: 'Within last 24 hours', computeMinMax: () => computeMinMaxInc(24 * 60 * 60 * 1000) },
+    { label: 'Within last 7 days', computeMinMax: () => computeMinMaxInc(7 * 24 * 60 * 60 * 1000) },
+    { label: 'Within last month', computeMinMax: () => computeMinMaxInc(30 * 24 * 60 * 60 * 1000) }
+].map((item) => ({ ...item, type: 'dynamic' }));

package/package/components/runs/useJobsLoader.svelte.d.ts

@@ -1,6 +1,6 @@
 import { type Job, type CompletedJob, type ExtendedJobs } from '../../gen';
 import { type Tweened } from 'svelte/motion';
-import type { Timeframe } from './TimeframeSelect.svelte';
+import type { Timeframe } from './timeframes';
 import { type RunsFilterInstance } from './runsFilter';
 export declare function computeJobKinds(jobKindsCat: string | null): string;
 export interface UseJobLoaderArgs {

package/package/svelte5Utils.svelte.d.ts

@@ -0,0 +1,184 @@
+import type { StateStore } from './utils';
+export declare function withProps<Component, Props>(component: Component, props: Props): {
+    component: Component;
+    props: Props;
+};
+export declare function createState<T>(initialValue: T): T;
+export declare function stateSnapshot<T>(state: T): $state.Snapshot<T>;
+export declare function refreshStateStore<T>(store: StateStore<T>): void;
+export type UsePromiseResult<T> = ({
+    status: 'loading';
+    value?: undefined;
+    error?: undefined;
+} | {
+    status: 'error';
+    error: any;
+    value?: undefined;
+} | {
+    status: 'ok';
+    value: T;
+    error?: undefined;
+} | {
+    status: 'idle';
+    value?: undefined;
+    error?: undefined;
+}) & {
+    refresh: () => void;
+    clear: () => void;
+};
+export type UsePromiseOptions = {
+    loadInit?: boolean;
+    clearValueOnRefresh?: boolean;
+};
+/**
+ * @deprecated Use `resource` from `runed` instead
+ */
+export declare function usePromise<T>(createPromise: () => Promise<T>, { loadInit, clearValueOnRefresh }?: UsePromiseOptions): UsePromiseResult<T>;
+/**
+ * Generic change tracker class that monitors changes in state using deep equality comparison
+ * and provides a counter to trigger Svelte 5 reactivity. Similar to the pattern used in
+ * FlowGraphV2.svelte's onModulesChange2 function.
+ */
+export declare class ChangeTracker<T> {
+    #private;
+    counter: number;
+    constructor(initialValue?: T);
+    /**
+     * Check if the value has changed and update the counter to trigger reactivity
+     * @param value - The current value to check for changes
+     * @returns true if the value changed, false otherwise
+     */
+    track(value: T): boolean;
+}
+/**
+ * This allows using async resources that only fetch missing data based on a set of keys.
+ * It maintains a Record of the fetched data and only calls the fetcher for keys that
+ * are not already present in the map.
+ * The fetcher takes a record of keys to allow fetching multiple items in a single call.
+ */
+export declare class MapResource<U, T> {
+    private _cached;
+    private _fetcherResource;
+    constructor(getValues: () => Record<string, U>, fetcher: (toFetch: Record<string, U>) => Promise<Record<string, T>>);
+    get current(): Record<string, T> | undefined;
+    get loading(): boolean;
+    get error(): Error | undefined;
+}
+export declare class ChangeOnDeepInequality<T> {
+    private _cached;
+    constructor(compute: () => T);
+    get value(): T;
+}
+export declare function useReducedMotion(): {
+    val: boolean;
+};
+export declare class StaleWhileLoading<T> {
+    private _current;
+    private _currentTimeout;
+    constructor(getter: () => T, timeout?: number);
+    get current(): T | undefined;
+}
+export interface UseInfiniteQueryOptions<TData, TPageParam> {
+    queryFn: (pageParam: TPageParam) => Promise<TData>;
+    initialPageParam: TPageParam;
+    getNextPageParam: (lastPage: TData, allPages: TData[]) => TPageParam | undefined;
+}
+export interface UseInfiniteQueryReturn<TData> {
+    current: TData[];
+    isLoading: boolean;
+    isFetchingNextPage: boolean;
+    hasNextPage: boolean;
+    error: Error | undefined;
+    fetchNextPage: () => Promise<void>;
+    reset: () => void;
+}
+/**
+ * A Svelte 5 hook that detects when the user has scrolled to the bottom of an element
+ *
+ * @param selector - CSS selector for the element to monitor (if not provided, monitors window)
+ * @param threshold - Distance from bottom in pixels to trigger (default: 0)
+ * @returns Object with `current` getter that returns true when at bottom
+ *
+ * @example
+ * // Monitor a specific element
+ * const bottomDetector = useScrollToBottom('.my-scrollable-div', 100)
+ *
+ * // Monitor the window
+ * const windowBottomDetector = useScrollToBottom()
+ *
+ * $effect(() => {
+ *   if (bottomDetector.current) {
+ *     console.log('User scrolled to bottom!')
+ *   }
+ * })
+ */
+export declare function useScrollToBottom(selector: string, threshold?: number): {
+    current: boolean;
+};
+/**
+ * A Svelte 5 hook for infinite query/pagination functionality
+ *
+ * @example
+ * const query = useInfiniteQuery({
+ *   queryFn: async (page) => fetchItems(page),
+ *   initialPageParam: 0,
+ *   getNextPageParam: (lastPage, allPages) =>
+ *     lastPage.length > 0 ? allPages.length : undefined
+ * })
+ *
+ * // Access data
+ * query.current // All pages of data
+ * query.isLoading // Initial loading state
+ * query.isFetchingNextPage // Loading next page
+ * query.hasNextPage // Whether more pages exist
+ *
+ * // Fetch next page
+ * await query.fetchNextPage()
+ */
+export declare function useInfiniteQuery<TData, TPageParam = number>(options: UseInfiniteQueryOptions<TData, TPageParam>): UseInfiniteQueryReturn<TData>;
+export declare function useKeyPressed<Key extends string>(keys: Key[], params?: {
+    onKeyUp?: (key: Key, e: KeyboardEvent) => void;
+    onKeyDown?: (key: Key, e: KeyboardEvent) => void;
+}): Record<Key, boolean>;
+export declare function useTransformedSyncedValue<T, U>(source: [() => T, (val: T) => void], transform: (val: T) => U, inverseTransform: (val: U) => T): {
+    val: U;
+    reparse(): void;
+};
+/**
+ * Maintains a local copy of a value that syncs back to the parent state in a debounced way.
+ *
+ * Useful for inputs where you want immediate local reactivity but don't want to
+ * flood the parent with updates (e.g. text fields, sliders).
+ *
+ * @param getter - Reads the canonical value from the parent
+ * @param setter - Writes a new canonical value to the parent (called debounced)
+ * @param react - A function that reads the fields to react to.
+ * @param delay - Debounce delay in ms (default: 300)
+ *
+ * @example
+ * const debounced = new DebouncedTempValue(
+ *   () => props.value,
+ *   (v) => { props.value = v },
+ *   (t) => t, // react to the value itself
+ *   300
+ * )
+ * // Use debounced.current in the template; writes are debounced to the parent.
+ */
+export declare class DebouncedTempValue<T> {
+    #private;
+    private setter;
+    private delay;
+    current: T;
+    constructor(getter: () => T, setter: (val: T) => void, react: (t: T) => void, delay?: number);
+    /** Flush any pending debounced write immediately. */
+    flush(): void;
+}
+export declare function useLocalStorageValue<T>(key: string, defaultValue: T, typ?: 'string' | 'number' | 'boolean'): {
+    val: T;
+};
+export declare function onCustomEvent(node: any, { event, handler }: {
+    event: any;
+    handler: any;
+}): {
+    destroy: () => any;
+};

package/package.json

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