windmill-components 1.473.1 → 1.493.2

package/package/components/flows/propPicker/PropPickerWrapper.svelte

@@ -1,7 +1,7 @@
-<script context="module">export const CONNECT = 'connect';
+<script context="module" lang="ts">export const CONNECT = 'connect';
 </script>
 
-<script>import PropPicker from '../../propertyPicker/PropPicker.svelte';
+<script lang="ts">import PropPicker from '../../propertyPicker/PropPicker.svelte';
 import PropPickerResult from '../../propertyPicker/PropPickerResult.svelte';
 import { clickOutside } from '../../../utils';
 import { createEventDispatcher, getContext, setContext } from 'svelte';
@@ -84,7 +84,7 @@ async function getPropPickerElements() {
 			<AnimatedButton
 				animate={$propPickerConfig?.insertionMode == 'connect'}
 				baseRadius="4px"
-				wrapperClasses="h-full w-full pt-2 !bg-surface "
+				wrapperClasses="prop-picker-inputs h-full w-full pt-1 !bg-surface "
 				marginWidth="3px"
 				ringColor={$propPickerConfig?.insertionMode == 'insert' ||
 				$propPickerConfig?.insertionMode == 'append'

package/package/components/flows/propPicker/PropPickerWrapper.svelte.d.ts

@@ -1,4 +1,3 @@
-import { SvelteComponent } from "svelte";
 type SelectCallback = (path: string) => boolean;
 export declare const CONNECT: "connect";
 export type PropPickerConfig = {
@@ -18,32 +17,44 @@ export type PropPickerWrapperContext = {
 };
 import { type Writable } from 'svelte/store';
 import type { PickableProperties } from '../previousResults';
-declare const __propDef: {
-    props: {
-        pickableProperties: PickableProperties | undefined;
-        result?: any;
-        extraResults?: any;
-        flow_input?: any;
-        error?: boolean | undefined;
-        displayContext?: boolean | undefined;
-        notSelectable?: boolean | undefined;
-        noPadding?: boolean | undefined;
-        alwaysOn?: boolean | undefined;
-        paneClass?: string | undefined;
-        noFlowPlugConnect?: boolean | undefined;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    events: {
-        select: CustomEvent<any>;
-    } & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type PropPickerWrapperProps = typeof __propDef.props;
-export type PropPickerWrapperEvents = typeof __propDef.events;
-export type PropPickerWrapperSlots = typeof __propDef.slots;
-export default class PropPickerWrapper extends SvelteComponent<PropPickerWrapperProps, PropPickerWrapperEvents, PropPickerWrapperSlots> {
+    z_$$bindings?: Bindings;
 }
-export {};
+type $$__sveltets_2_PropsWithChildren<Props, Slots> = Props & (Slots extends {
+    default: any;
+} ? Props extends Record<string, never> ? any : {
+    children?: any;
+} : {});
+declare const PropPickerWrapper: $$__sveltets_2_IsomorphicComponent<$$__sveltets_2_PropsWithChildren<{
+    pickableProperties: PickableProperties | undefined;
+    result?: any;
+    extraResults?: any;
+    flow_input?: any;
+    error?: boolean;
+    displayContext?: boolean;
+    notSelectable?: boolean;
+    noPadding?: boolean;
+    alwaysOn?: boolean;
+    paneClass?: string;
+    noFlowPlugConnect?: boolean;
+}, {
+    default: {};
+}>, {
+    select: CustomEvent<any>;
+} & {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}, {}, string>;
+type PropPickerWrapper = InstanceType<typeof PropPickerWrapper>;
+export default PropPickerWrapper;

package/package/components/flows/propPicker/StepHistory.svelte

@@ -0,0 +1,129 @@
+<script module lang="ts">export {};
+</script>
+
+<script lang="ts">import InfiniteList from '../../InfiniteList.svelte';
+import { JobService } from '../../../gen';
+import { workspaceStore } from '../../../stores';
+import { getContext, createEventDispatcher } from 'svelte';
+import { Pin } from 'lucide-svelte';
+import { Cell } from '../../table';
+import JobPickerLight from './JobPickerLight.svelte';
+export let selected = undefined;
+export let moduleId = '';
+export let getLogs = false;
+export let mockValue = undefined;
+export let mockEnabled = false;
+export let path = '';
+export let staticInputs = undefined;
+export let noHistory = undefined;
+const { pathStore } = getContext('FlowEditorContext') ?? {};
+const dispatch = createEventDispatcher();
+let infiniteList = undefined;
+let loadInputsPageFn = undefined;
+function initLoadInputs() {
+    loadInputsPageFn = async (page, perPage) => {
+        if (staticInputs)
+            return staticInputs;
+        const previousJobs = await JobService.listCompletedJobs({
+            workspace: $workspaceStore,
+            scriptPathExact: path === '' ? $pathStore + '/' + moduleId : path,
+            jobKinds: ['preview', 'script', 'flowpreview', 'flow', 'flowscript'].join(','),
+            page,
+            perPage
+        });
+        return previousJobs.map((job) => ({
+            id: job.id,
+            created_at: job.created_at,
+            created_by: job.created_by,
+            success: job.success,
+            getFullJob: async () => await getJobResultAndLogs(job.id, !getLogs)
+        }));
+    };
+    infiniteList?.setLoader(loadInputsPageFn);
+}
+$: staticInputs && infiniteList?.loadData('forceRefresh');
+async function getJobResultAndLogs(jobId, noLogs) {
+    try {
+        const job = await JobService.getJob({
+            workspace: $workspaceStore ?? '',
+            id: jobId ?? '',
+            noLogs
+        });
+        return job;
+    }
+    catch (error) {
+        console.error('Error getting job result and logs', error);
+        return undefined;
+    }
+}
+$: infiniteList && !noHistory && initLoadInputs();
+function handleSelect(e) {
+    if (e.detail === 'extraRow') {
+        if (selected === 'extraRow') {
+            deselect();
+            return;
+        }
+        selected = 'extraRow';
+        dispatch('select', 'mock');
+        return;
+    }
+    if (selected === e.detail.id) {
+        deselect();
+        return;
+    }
+    selected = e.detail.id;
+    dispatch('select', { ...e.detail });
+}
+export function deselect() {
+    selected = undefined;
+    dispatch('select', undefined);
+}
+</script>
+
+<InfiniteList
+	bind:this={infiniteList}
+	selectedItemId={selected}
+	on:error
+	on:select={handleSelect}
+	rounded={false}
+	noBorder
+	extraRowClasses={{
+		bgSelected: 'bg-blue-200 dark:bg-blue-900/40',
+		bgHover: 'hover:bg-blue-100 dark:hover:bg-blue-600/40',
+		class: 'bg-blue-50 dark:bg-blue-700/40'
+	}}
+>
+	<svelte:fragment slot="extra-row">
+		{#if mockValue}
+			<Cell wrap colspan="2">
+				<div
+					class="text-blue-700 dark:text-blue-100 w-full flex flex-row items-center gap-2 px-2 py-1"
+				>
+					<Pin size={14} />
+
+					<span class=" grow">
+						{mockEnabled ? 'Pin' : 'Last pin'}
+					</span>
+				</div>
+			</Cell>
+		{/if}
+	</svelte:fragment>
+	<svelte:fragment slot="columns">
+		<colgroup>
+			<col class="w-28" />
+			<col />
+		</colgroup>
+	</svelte:fragment>
+	<svelte:fragment let:item>
+		<JobPickerLight job={item} />
+	</svelte:fragment>
+	<svelte:fragment slot="empty">
+		<div class="text-center text-tertiary text-xs py-2 px-2">
+			{noHistory === 'isLoop'
+				? 'History is not available with loops.'
+				: noHistory === 'isInsideLoop'
+					? 'History is not available inside loops.'
+					: 'No run in history for this step'}
+		</div>
+	</svelte:fragment>
+</InfiniteList>

package/package/components/flows/propPicker/StepHistory.svelte.d.ts

@@ -0,0 +1,39 @@
+export type StepHistoryData = {
+    id: string;
+    created_at: string;
+    created_by: string;
+    success: boolean;
+};
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const StepHistory: $$__sveltets_2_IsomorphicComponent<{
+    selected?: string | undefined;
+    moduleId?: string;
+    getLogs?: boolean;
+    mockValue?: any;
+    mockEnabled?: boolean;
+    path?: string;
+    staticInputs?: undefined | StepHistoryData[];
+    noHistory?: "isLoop" | "isInsideLoop" | undefined;
+    deselect?: () => void;
+}, {
+    error: CustomEvent<any>;
+    select: CustomEvent<any>;
+} & {
+    [evt: string]: CustomEvent<any>;
+}, {}, {
+    deselect: () => void;
+}, string>;
+type StepHistory = InstanceType<typeof StepHistory>;
+export default StepHistory;

package/package/components/flows/scheduleUtils.d.ts

@@ -1,7 +1,7 @@
-/// <reference types="svelte" />
 import { type Schedule, type TriggersCount } from '../../gen';
 import type { ScheduleTrigger } from '../triggers';
 import type { Writable } from 'svelte/store';
 export declare function loadSchedule(path: string, workspace: string): Promise<ScheduleTrigger>;
-export declare function loadSchedules(forceRefresh: boolean, path: string, isFlow: boolean, schedules: Writable<Schedule[] | undefined>, primarySchedule: Writable<ScheduleTrigger | false | undefined>, initialPrimarySchedule: Writable<ScheduleTrigger | false | undefined>, workspace: string, triggersCount: Writable<TriggersCount | undefined>, loadPrimarySchedule?: boolean): Promise<void>;
+export declare function loadSchedules(forceRefresh: boolean, path: string, isFlow: boolean, schedules: Writable<Schedule[] | undefined>, primarySchedule: Writable<ScheduleTrigger | false | undefined>, initialPrimarySchedule: Writable<ScheduleTrigger | false | undefined>, workspace: string, triggersCount: Writable<TriggersCount | undefined>, loadPrimarySchedule?: boolean, isDeployed?: Writable<boolean | undefined>): Promise<void>;
 export declare function saveSchedule(path: string, newItem: boolean, workspace: string, primarySchedule: Writable<ScheduleTrigger | false | undefined>, isFlow: boolean): Promise<void>;
+export declare function saveScheduleFromCfg(scheduleCfg: Record<string, any>, edit: boolean, workspace: string): Promise<boolean>;

package/package/components/flows/scheduleUtils.js

@@ -1,4 +1,5 @@
 import { ScheduleService } from '../../gen';
+import { writable } from 'svelte/store';
 import { get } from 'svelte/store';
 import { sendUserToast } from '../../utils';
 // Load the schedule of a flow given its path and the workspace
@@ -22,7 +23,7 @@ export async function loadSchedule(path, workspace) {
         args: schedule.args ?? {}
     };
 }
-export async function loadSchedules(forceRefresh, path, isFlow, schedules, primarySchedule, initialPrimarySchedule, workspace, triggersCount, loadPrimarySchedule = false) {
+export async function loadSchedules(forceRefresh, path, isFlow, schedules, primarySchedule, initialPrimarySchedule, workspace, triggersCount, loadPrimarySchedule = false, isDeployed = writable(undefined)) {
     if (!path || path == '') {
         schedules.set([]);
         primarySchedule.update((ps) => (ps === undefined ? false : ps));
@@ -36,6 +37,9 @@ export async function loadSchedules(forceRefresh, path, isFlow, schedules, prima
             isFlow
         });
         const primary = allSchedules.find((s) => s.path == path);
+        if (primary) {
+            isDeployed.set(true);
+        }
         let remotePrimarySchedule = undefined;
         if (loadPrimarySchedule && primary) {
             remotePrimarySchedule = await loadSchedule(path, workspace);
@@ -115,3 +119,55 @@ export async function saveSchedule(path, newItem, workspace, primarySchedule, is
         }
     }
 }
+export async function saveScheduleFromCfg(scheduleCfg, edit, workspace) {
+    const requestBody = {
+        schedule: scheduleCfg.schedule,
+        timezone: scheduleCfg.timezone,
+        args: scheduleCfg.args,
+        on_failure: scheduleCfg.on_failure,
+        on_failure_times: scheduleCfg.on_failure_times,
+        on_failure_exact: scheduleCfg.on_failure_exact,
+        on_failure_extra_args: scheduleCfg.on_failure_extra_args,
+        on_recovery: scheduleCfg.on_recovery,
+        on_recovery_times: scheduleCfg.on_recovery_times,
+        on_recovery_extra_args: scheduleCfg.on_recovery_extra_args,
+        on_success: scheduleCfg.on_success,
+        on_success_extra_args: scheduleCfg.on_success_extra_args,
+        ws_error_handler_muted: scheduleCfg.ws_error_handler_muted,
+        retry: scheduleCfg.retry,
+        summary: scheduleCfg.summary,
+        description: scheduleCfg.description,
+        no_flow_overlap: scheduleCfg.no_flow_overlap,
+        tag: scheduleCfg.tag,
+        paused_until: scheduleCfg.paused_until,
+        cron_version: scheduleCfg.cron_version
+    };
+    try {
+        if (edit) {
+            await ScheduleService.updateSchedule({
+                workspace,
+                path: scheduleCfg.path,
+                requestBody: requestBody
+            });
+            sendUserToast(`Schedule ${scheduleCfg.path} updated`);
+        }
+        else {
+            await ScheduleService.createSchedule({
+                workspace,
+                requestBody: {
+                    path: scheduleCfg.path,
+                    script_path: scheduleCfg.script_path,
+                    is_flow: scheduleCfg.is_flow,
+                    ...requestBody,
+                    enabled: true
+                }
+            });
+            sendUserToast(`Schedule ${scheduleCfg.path} created`);
+        }
+        return true;
+    }
+    catch (error) {
+        sendUserToast(error.body || error.message, true);
+        return false;
+    }
+}

package/package/components/flows/types.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="svelte" />
 import type { FlowModule, OpenFlow } from '../../gen';
 import type { History } from '../../history';
 import type { Writable } from 'svelte/store';
@@ -38,7 +37,8 @@ export type FlowEditorContext = {
     flowStateStore: Writable<FlowState>;
     testStepStore: Writable<Record<string, any>>;
     saveDraft: () => void;
-    initialPath: string;
+    initialPathStore: Writable<string>;
+    fakeInitialPath: string;
     flowInputsStore: Writable<FlowInput>;
     customUi: FlowBuilderWhitelabelCustomUi;
     insertButtonOpen: Writable<boolean>;

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

@@ -1,6 +1,6 @@
 import { type FlowModule, type InputTransform, type Job, type RestartedFrom, type OpenFlow, type FlowModuleValue } from '../../gen';
 import type { FlowModuleState } from './flowState';
-import type { PickableProperties } from './previousResults';
+import { type PickableProperties } from './previousResults';
 import type { Schema } from '../../common';
 import type { ExtendedOpenFlow } from './types';
 export declare function evalValue(k: string, mod: FlowModule, testStepStore: Record<string, any>, pickableProperties: PickableProperties | undefined, showError: boolean): any;
@@ -32,9 +32,13 @@ export declare function computeFlowStepWarning(argName: string, flowModuleValue:
     type: 'error' | 'warning';
 }>, schema: Schema | undefined, moduleIds?: string[]): Promise<Record<string, {
     message: string;
-    type: 'error' | 'warning';
+    type: "error" | "warning";
 }>>;
 export declare function initFlowStepWarnings(flowModuleValue: FlowModuleValue, schema: Schema | undefined, moduleIds?: string[]): Promise<Record<string, {
     message: string;
-    type: 'error' | 'warning';
+    type: "error" | "warning";
 }>>;
+export declare function checkIfParentLoop(flowStore: ExtendedOpenFlow, modId: string): {
+    id: string;
+    type: 'forloopflow' | 'whileloopflow';
+} | undefined;

package/package/components/flows/utils.js

@@ -2,6 +2,7 @@ import { JobService } from '../../gen';
 import { workspaceStore } from '../../stores';
 import { cleanExpr, emptySchema } from '../../utils';
 import { get } from 'svelte/store';
+import { dfs } from './previousResults';
 import { NEVER_TESTED_THIS_FAR } from './models';
 import { sendUserToast } from '../../toast';
 import { parseOutputs } from '../../infer';
@@ -223,3 +224,13 @@ export async function initFlowStepWarnings(flowModuleValue, schema, moduleIds =
     }
     return messages;
 }
+export function checkIfParentLoop(flowStore, modId) {
+    const flow = JSON.parse(JSON.stringify(flowStore));
+    const parents = dfs(modId, flow, true);
+    for (const parent of parents.slice(1)) {
+        if (parent.value.type === 'forloopflow' || parent.value.type === 'whileloopflow') {
+            return { id: parent.id, type: parent.value.type };
+        }
+    }
+    return undefined;
+}

package/package/components/graph/FlowGraphV2.svelte

@@ -1,4 +1,4 @@
-<script>import { FlowService } from '../../gen';
+<script lang="ts">import { FlowService } from '../../gen';
 import { NODE } from '.';
 import { createEventDispatcher, getContext, onDestroy, onMount, setContext, tick } from 'svelte';
 import { get, writable } from 'svelte/store';
@@ -53,6 +53,7 @@ export let disableAi = false;
 export let flowInputsStore = writable(undefined);
 export let triggerNode = false;
 export let workspace = $workspaceStore ?? 'NO_WORKSPACE';
+export let editMode = false;
 let useDataflow = writable(false);
 setContext('FlowGraphContext', { selectedId, flowInputsStore, useDataflow });
 const triggerContext = getContext('TriggerContext');
@@ -173,6 +174,9 @@ let eventHandler = {
     minimizeSubflow: (id) => {
         delete expandedSubflows[id];
         expandedSubflows = expandedSubflows;
+    },
+    updateMock: () => {
+        dispatch('updateMock');
     }
 };
 let lastModules = structuredClone(modules);
@@ -192,7 +196,8 @@ $: graph = graphBuilder(newModules, {
     path,
     newFlow,
     cache,
-    earlyStop
+    earlyStop,
+    editMode
 }, failureModule, preprocessorModule, eventHandler, success, $useDataflow, $selectedId, moving, simplifiableFlow, triggerNode ? path : undefined, expandedSubflows);
 const nodes = writable([]);
 const edges = writable([]);
@@ -307,7 +312,7 @@ let yamlEditorDrawer = undefined;
 			nodesDraggable={false}
 			--background-color={false}
 		>
-			<div class="absolute inset-0 !bg-surface-secondary" />
+			<div class="absolute inset-0 !bg-surface-secondary"></div>
 			<Controls position="top-right" orientation="horizontal" showLock={false}>
 				{#if download}
 					<ControlButton
@@ -362,11 +367,11 @@ let yamlEditorDrawer = undefined;
 	:global(.svelte-flow__controls-button) {
 		border-width: 0px;
 		--tw-bg-opacity: 1;
-		background-color: rgb(var(--color-surface) / var(--tw-bg-opacity));
+		background-color: rgb(var(--color-surface) / var(--tw-bg-opacity, 1));
 }
 	:global(.svelte-flow__controls-button:hover) {
 		--tw-bg-opacity: 1;
-		background-color: rgb(var(--color-surface-hover) / var(--tw-bg-opacity));
+		background-color: rgb(var(--color-surface-hover) / var(--tw-bg-opacity, 1));
 }
 
 	:global(.svelte-flow__edgelabel-renderer) {

package/package/components/graph/FlowGraphV2.svelte.d.ts

@@ -1,53 +1,59 @@
-import { SvelteComponent } from "svelte";
 import { type FlowModule } from '../../gen';
 import { type GraphModuleState } from '.';
 import { type Writable } from 'svelte/store';
 import '@xyflow/svelte/dist/style.css';
 import type { FlowInput } from '../flows/types';
-declare const __propDef: {
-    props: {
-        success?: boolean | undefined;
-        modules?: FlowModule[] | undefined;
-        failureModule?: FlowModule | undefined;
-        preprocessorModule?: FlowModule | undefined;
-        minHeight?: number | undefined;
-        maxHeight?: number | undefined;
-        notSelectable?: boolean | undefined;
-        flowModuleStates?: Record<string, GraphModuleState> | undefined;
-        selectedId?: Writable<string | undefined> | undefined;
-        path?: string | undefined;
-        newFlow?: boolean | undefined;
-        insertable?: boolean | undefined;
-        earlyStop?: boolean | undefined;
-        cache?: boolean | undefined;
-        scroll?: boolean | undefined;
-        moving?: string | undefined;
-        download?: boolean | undefined;
-        fullSize?: boolean | undefined;
-        disableAi?: boolean | undefined;
-        flowInputsStore?: Writable<FlowInput | undefined> | undefined;
-        triggerNode?: boolean | undefined;
-        workspace?: string | undefined;
-        allowSimplifiedPoll?: boolean | undefined;
-        expandedSubflows?: Record<string, FlowModule[]> | undefined;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    events: {
-        deleteBranch: CustomEvent<any>;
-        insert: CustomEvent<any>;
-        select: CustomEvent<any>;
-        changeId: CustomEvent<any>;
-        delete: CustomEvent<any>;
-        newBranch: CustomEvent<any>;
-        move: CustomEvent<any>;
-        selectedIteration: CustomEvent<any>;
-    } & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type FlowGraphV2Props = typeof __propDef.props;
-export type FlowGraphV2Events = typeof __propDef.events;
-export type FlowGraphV2Slots = typeof __propDef.slots;
-export default class FlowGraphV2 extends SvelteComponent<FlowGraphV2Props, FlowGraphV2Events, FlowGraphV2Slots> {
+    z_$$bindings?: Bindings;
 }
-export {};
+declare const FlowGraphV2: $$__sveltets_2_IsomorphicComponent<{
+    success?: boolean | undefined;
+    modules?: FlowModule[] | undefined;
+    failureModule?: FlowModule | undefined;
+    preprocessorModule?: FlowModule | undefined;
+    minHeight?: number;
+    maxHeight?: number | undefined;
+    notSelectable?: boolean;
+    flowModuleStates?: Record<string, GraphModuleState> | undefined;
+    selectedId?: Writable<string | undefined>;
+    path?: string | undefined;
+    newFlow?: boolean;
+    insertable?: boolean;
+    earlyStop?: boolean;
+    cache?: boolean;
+    scroll?: boolean;
+    moving?: string | undefined;
+    download?: boolean;
+    fullSize?: boolean;
+    disableAi?: boolean;
+    flowInputsStore?: Writable<FlowInput | undefined>;
+    triggerNode?: boolean;
+    workspace?: string;
+    editMode?: boolean;
+    allowSimplifiedPoll?: boolean;
+    expandedSubflows?: Record<string, FlowModule[]>;
+}, {
+    deleteBranch: CustomEvent<any>;
+    insert: CustomEvent<any>;
+    select: CustomEvent<any>;
+    changeId: CustomEvent<any>;
+    delete: CustomEvent<any>;
+    newBranch: CustomEvent<any>;
+    move: CustomEvent<any>;
+    selectedIteration: CustomEvent<any>;
+    updateMock: CustomEvent<any>;
+} & {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type FlowGraphV2 = InstanceType<typeof FlowGraphV2>;
+export default FlowGraphV2;

package/package/components/graph/graphBuilder.d.ts

@@ -12,6 +12,7 @@ export type GraphEventHandlers = {
     simplifyFlow: (detail: boolean) => void;
     expandSubflow: (id: string, path: string) => void;
     minimizeSubflow: (id: string) => void;
+    updateMock: () => void;
 };
 export type SimplifiableFlow = {
     simplifiedFlow: boolean;

package/package/components/graph/graphBuilder.js

@@ -101,7 +101,7 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                     disableMoveIds: options?.disableMoveIds,
                     enableTrigger: sourceId === 'Input',
                     // If the index is -1, it means that the target module is not in the modules array, so we set it to the length of the array
-                    index: index >= 0 ? index : mods?.length ?? 0,
+                    index: index >= 0 ? index : (mods?.length ?? 0),
                     ...extra,
                     insertable: extra.insertable && !options?.disableInsert && prefix == undefined
                 }
@@ -464,7 +464,7 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
         if (failureModule) {
             let toAdd = {};
             Object.keys(extra.flowModuleStates ?? {}).forEach((id) => {
-                if (id.startsWith('failure-')) {
+                if (id.startsWith('failure')) {
                     const failureState = extra.flowModuleStates?.[id];
                     if (failureState?.parent_module) {
                         toAdd[failureState.parent_module] = id;

package/package/components/graph/model.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="svelte" />
 import type { FlowStatusModule, Job } from '../../gen';
 import type { Writable } from 'svelte/store';
 import type { FlowState } from '../flows/flowState';

package/package/components/graph/renderers/edges/BaseEdge.svelte

@@ -1,4 +1,4 @@
-<script>import InsertModuleButton from '../../../flows/map/InsertModuleButton.svelte';
+<script lang="ts">import InsertModuleButton from '../../../flows/map/InsertModuleButton.svelte';
 import { getBezierPath, BaseEdge, EdgeLabelRenderer } from '@xyflow/svelte';
 import { ClipboardCopy } from 'lucide-svelte';
 import { getContext } from 'svelte';