windmill-components 1.46.3 → 1.55.0

package/components/flows/previousResults.js

@@ -76,7 +76,8 @@ export function getStepPropPicker(flowState, parentModule, previousModule, id, f
     const pickableProperties = {
         flow_input: flowInput,
         priorIds: priorIds,
-        previousId: previousIds[0]
+        previousId: previousIds[0],
+        hasResume: previousModule?.suspend != undefined,
     };
     if (approvers && ((previousModule?.suspend?.required_events ?? 0) > 0)) {
         pickableProperties["approvers"] = "The list of approvers";
@@ -92,27 +93,27 @@ export function buildExtraLib(flowInput, results) {
 * get variable (including secret) at path
 * @param {string} path - path of the variable (e.g: g/all/pretty_secret)
 */
-export function variable(path: string): string;
+declare function variable(path: string): string;
 
 /**
 * get resource at path
 * @param {string} path - path of the resource (e.g: g/all/my_resource)
 */
-export function resource(path: string): any;
+declare function resource(path: string): any;
 
 /**
 * flow input as an object
 */
-export const flow_input = ${JSON.stringify(flowInput)};
+declare const flow_input = ${JSON.stringify(flowInput)};
 
 /**
 * static params of this same step
 */
-export const params: any;
+declare const params: any;
 
 /**
  * result by id
  */
-export const results = ${JSON.stringify(results)};
+declare const results = ${JSON.stringify(results)};
 `;
 }

package/components/flows/propPicker/PropPickerWrapper.svelte

@@ -29,12 +29,20 @@ setContext('PropPickerWrapper', {
 </script>
 
 <Splitpanes>
-	<Pane minSize={20} size={66} class="relative p-4 !transition-none">
+	<Pane minSize={20} size={60} class="relative p-4 !transition-none">
 		<slot />
 	</Pane>
-	<Pane minSize={20} size={34} class="px-2 py-2 h-full !transition-none">
+	<Pane minSize={20} size={40} class="py-2 relative !transition-none">
 		{#if result}
-			<PropPickerResult {result} />
+			<PropPickerResult
+				{result}
+				on:select={({ detail }) => {
+					dispatch('select', detail)
+					if ($propPickerConfig?.onSelect(detail)) {
+						propPickerConfig.set(undefined)
+					}
+				}}
+			/>
 		{:else if pickableProperties}
 			<PropPicker
 				{displayContext}

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

@@ -1,12 +1,12 @@
 import { SvelteComponentTyped } from "svelte";
-declare type InsertionMode = 'append' | 'connect' | 'insert';
-declare type SelectCallback = (path: string) => boolean;
-declare type PropPickerConfig = {
+type InsertionMode = 'append' | 'connect' | 'insert';
+type SelectCallback = (path: string) => boolean;
+type PropPickerConfig = {
     insertionMode: InsertionMode;
     propName: string;
     onSelect: SelectCallback;
 };
-export declare type PropPickerWrapperContext = {
+export type PropPickerWrapperContext = {
     propPickerConfig: Writable<PropPickerConfig | undefined>;
     focusProp: (propName: string, insertionMode: InsertionMode, onSelect: SelectCallback) => void;
     clearFocus: () => void;
@@ -30,9 +30,9 @@ declare const __propDef: {
         default: {};
     };
 };
-export declare type PropPickerWrapperProps = typeof __propDef.props;
-export declare type PropPickerWrapperEvents = typeof __propDef.events;
-export declare type PropPickerWrapperSlots = typeof __propDef.slots;
+export type PropPickerWrapperProps = typeof __propDef.props;
+export type PropPickerWrapperEvents = typeof __propDef.events;
+export type PropPickerWrapperSlots = typeof __propDef.slots;
 export default class PropPickerWrapper extends SvelteComponentTyped<PropPickerWrapperProps, PropPickerWrapperEvents, PropPickerWrapperSlots> {
 }
 export {};

package/components/flows/scheduleUtils.d.ts

@@ -1,4 +1,4 @@
-export declare type Schedule = {
+export type Schedule = {
     args: Record<string, any>;
     cron: string;
     enabled: boolean;

package/components/flows/scheduleUtils.js

@@ -6,7 +6,7 @@ export async function loadFlowSchedule(path, workspace = '') {
         path
     });
     if (!existsSchedule) {
-        throw new Error(`Flow at path: ${path} doesn't exit`);
+        throw new Error(`Flow at path: ${path} doesn't exist`);
     }
     const schedule = await ScheduleService.getSchedule({
         workspace,

package/components/flows/types.d.ts

@@ -1,6 +1,6 @@
 import type { Writable } from 'svelte/store';
 import type { Schedule } from './scheduleUtils';
-export declare type FlowEditorContext = {
+export type FlowEditorContext = {
     selectedId: Writable<string>;
     select: (id: string) => void;
     schedule: Writable<Schedule>;

package/components/flows/utils.d.ts

@@ -9,7 +9,7 @@ export declare function loadSchemaFromModule(module: FlowModule): Promise<{
     schema: Schema;
 }>;
 export declare function isCodeInjection(expr: string | undefined): boolean;
-export declare function getDefaultExpr(importPath?: string | undefined, key?: string, previousExpr?: string): string;
+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>;
 export declare function codeToStaticTemplate(code?: string): string | undefined;
@@ -17,5 +17,4 @@ export declare const NEVER_TESTED_THIS_FAR = "never tested this far";
 export declare function emptyFlowModuleState(): FlowModuleState;
 export declare function numberToChars(n: number): any;
 export declare function charsToNumber(n: string): number;
-export declare function isEmptyFlowModule(flowModule: FlowModule): boolean;
 export declare function findNextAvailablePath(path: string): Promise<string>;

package/components/flows/utils.js

@@ -1,6 +1,6 @@
 import { JobService, ScriptService } from '../../gen';
 import { inferArgs } from '../../infer';
-import { loadSchema } from '../../scripts';
+import { loadSchema, loadSchemaFlow } from '../../scripts';
 import { workspaceStore } from '../../stores';
 import { emptySchema } from '../../utils';
 import { get } from 'svelte/store';
@@ -46,15 +46,18 @@ export function getTypeAsString(arg) {
 }
 export async function loadSchemaFromModule(module) {
     const mod = module.value;
-    if (mod.type == 'rawscript' || mod.type === 'script') {
+    if (mod.type == 'rawscript' || mod.type === 'script' || mod.type === 'flow') {
         let schema;
         if (mod.type === 'rawscript') {
             schema = emptySchema();
             await inferArgs(mod.language, mod.content ?? '', schema);
         }
-        else if (mod.path && mod.path != '') {
+        else if (mod.type == 'script' && mod.path && mod.path != '') {
             schema = await loadSchema(mod.path);
         }
+        else if (mod.type == 'flow' && mod.path && mod.path != '') {
+            schema = await loadSchemaFlow(mod.path);
+        }
         else {
             return {
                 input_transforms: {},
@@ -93,11 +96,8 @@ export function isCodeInjection(expr) {
     }
     return dynamicTemplateRegex.test(expr);
 }
-export function getDefaultExpr(importPath = undefined, key = 'myfield', previousExpr) {
-    const expr = previousExpr ?? `results.${key}`;
-    return `import { results, flow_input, variable, resource, params } from 'windmill${importPath ? `@${importPath}` : ''}'
-
-${expr}`;
+export function getDefaultExpr(key = 'myfield', previousModuleId, previousExpr) {
+    return previousExpr ?? (previousModuleId ? `results.${previousModuleId}.${key}` : `flow_input.${key}`);
 }
 export function jobsToResults(jobs) {
     return jobs.map((job) => {
@@ -121,12 +121,10 @@ export async function runFlowPreview(args, flow) {
     });
 }
 export function codeToStaticTemplate(code) {
-    if (!code)
+    if (!code || typeof code != 'string')
         return undefined;
     const lines = code
-        .split('\n')
-        .slice(1)
-        .filter((x) => x != '');
+        .split('\n');
     if (lines.length == 1) {
         const line = lines[0].trim();
         if (line[0] == '`' && line.charAt(line.length - 1) == '`') {
@@ -169,9 +167,6 @@ export function charsToNumber(n) {
     }
     return res - 1;
 }
-export function isEmptyFlowModule(flowModule) {
-    return flowModule.value.type === 'identity';
-}
 export async function findNextAvailablePath(path) {
     try {
         await ScriptService.getScriptByPath({

package/components/graph/FlowGraph.svelte

@@ -1,38 +1,54 @@
 <script>import Svelvet, {} from 'svelvet';
-import { sugiyama, dagStratify, decrossOpt, coordGreedy, coordCenter } from 'd3-dag';
+import { sugiyama, dagStratify, decrossOpt, coordCenter } from 'd3-dag';
+import { FlowStatusModule, RawScript } from '../../gen';
 import { NODE, createIdGenerator, isNode, isLoop, isBranch } from '.';
-import { truncate, truncateRev } from '../../utils';
+import { defaultIfEmptyString, truncateRev } from '../../utils';
 import { createEventDispatcher } from 'svelte';
-import { numberToChars } from '../flows/utils';
+import { charsToNumber, numberToChars } from '../flows/utils';
 export let modules = [];
 export let failureModule = undefined;
 export let minHeight = 0;
-const idGenerator = createIdGenerator();
+export let notSelectable = false;
+export let flowModuleStates = undefined;
+let selectedNode = undefined;
+let idGenerator;
 let nestedNodes;
 let nodes = [];
 let edges = [];
 let width, height;
+let errorHandlers = {};
 let dispatch = createEventDispatcher();
 $: {
-    width && height && minHeight;
-    if (modules?.length) {
-        createGraph(modules, failureModule);
+    width && height && minHeight && selectedNode && flowModuleStates;
+    nodes = edges = [];
+    errorHandlers = {};
+    createGraph();
+}
+async function createGraph() {
+    if (modules) {
+        idGenerator = createIdGenerator();
     }
     else {
         nodes = edges = [];
+        return;
     }
-}
-function createGraph(modules, failureModule) {
     nestedNodes = nodes = [];
-    nestedNodes.push(createVirtualNode(getParentIds(), 'Flow start'));
+    nestedNodes.push(createVirtualNode(getParentIds(), 'Input'));
     modules.forEach((m) => {
         const item = getConvertedFlowModule(m);
         item && nestedNodes.push(item);
     });
-    const endParentIds = getParentIds();
-    nestedNodes.push(createVirtualNode(getParentIds(), 'Flow end'));
-    if (failureModule) {
-        nestedNodes.push(createErrorHandler(endParentIds, failureModule));
+    nestedNodes.push(createVirtualNode(getParentIds(), 'Result'));
+    if (!flowModuleStates) {
+        if (failureModule)
+            nestedNodes.push(createErrorHandler(failureModule));
+    }
+    else {
+        Object.entries(flowModuleStates ?? [])
+            .filter(([k, v]) => k.startsWith('failure'))
+            .forEach(([k, v]) => {
+            nestedNodes.push(createErrorHandler({ id: k }, v.parent_module));
+        });
     }
     const flatNodes = flattenNestedNodes(nestedNodes);
     const layered = layoutNodes(flatNodes);
@@ -53,25 +69,31 @@ function getConvertedFlowModule(module, parent = undefined, edgeLabel = undefine
         return flowModuleToNode(parentIds, module.id, module.summary || module.value.path, isHub ? 'hub' : 'workspace', module, undefined, edgeLabel);
     }
     else if (type === 'forloopflow') {
-        const expr = module.value.iterator['expr'];
-        return flowModuleToLoop(module.value.modules, `For loop: ${truncate(expr, 10)}`, parent);
+        return flowModuleToLoop(module.value.modules, module, parent);
     }
     else if (type === 'branchone') {
         const branches = [module.value.default, ...module.value.branches.map((b) => b.modules)];
-        return flowModuleToBranch(branches, ['Default', ...module.value.branches.map((x) => `If ${truncateRev(x.expr, 20)}`)], parent);
+        return flowModuleToBranch(module, branches, ['Default', ...module.value.branches.map((x) => `If ${truncateRev(x.expr, 20)}`)], parent);
     }
     else if (type === 'branchall') {
         const branches = module.value.branches.map((b) => b.modules);
-        return flowModuleToBranch(branches, [], parent);
+        return flowModuleToBranch(module, branches, [], parent);
+    }
+    else if (type === 'flow') {
+        return flowModuleToNode(parentIds, module.id, module.summary || 'Flow ' + module.value.path, 'inline', module, undefined, edgeLabel);
     }
-    return flowModuleToNode(parentIds, module.id, module.summary || 'Identity script', 'inline', module, undefined, edgeLabel);
+    return flowModuleToNode(parentIds, module.id, module.summary || 'Identity step', 'inline', module, undefined, edgeLabel);
 }
 function getParentIds(items = undefined) {
+    if (typeof items == 'string') {
+        return [items];
+    }
     const item = items?.at(-1) || nestedNodes.at(-1);
     if (!item)
         return [];
     if (isNode(item)) {
-        return ['' + item.id];
+        const id = numberToChars(item.id);
+        return [id];
     }
     else if (isLoop(item)) {
         return getParentIds(item.items);
@@ -81,7 +103,23 @@ function getParentIds(items = undefined) {
     }
     return [];
 }
-function flowModuleToNode(parentIds, id, title, host, onClickDetail, lang, edgeLabel) {
+function getStateColor(state) {
+    switch (state) {
+        case FlowStatusModule.type.SUCCESS:
+            return 'rgb(193, 255, 216)';
+        case FlowStatusModule.type.FAILURE:
+            return 'rgb(248 113 113)';
+        case FlowStatusModule.type.IN_PROGRESS:
+            return 'rgb(253, 240, 176)';
+        case FlowStatusModule.type.WAITING_FOR_EVENTS:
+            return 'rgb(229, 176, 253)';
+        case FlowStatusModule.type.WAITING_FOR_EXECUTOR:
+            return 'rgb(255, 208, 193)';
+        default:
+            return '#fff';
+    }
+}
+function flowModuleToNode(parentIds, id, title, host, onClickDetail, lang, edgeLabel, header) {
     const langImg = {
         deno: '/icons/ts-lang.svg',
         go: '/icons/go-lang.svg',
@@ -94,9 +132,9 @@ function flowModuleToNode(parentIds, id, title, host, onClickDetail, lang, edgeL
         inline: ''
     };
     const wrapperWidth = lang ? 'w-[calc(100%-70px)]' : 'w-[calc(100%-50px)]';
-    const graphId = idGenerator.next().value;
+    let nodeId = id ?? numberToChars(idGenerator.next().value - 1);
     return {
-        id: graphId,
+        id: charsToNumber(nodeId),
         position: { x: -1, y: -1 },
         data: {
             html: `
@@ -108,48 +146,69 @@ function flowModuleToNode(parentIds, id, title, host, onClickDetail, lang, edgeL
 						${lang ? `<img src="${langImg[lang]}" class="grayscale">` : ''}
 						${host != 'inline' ? `<img src="${hostImg[host]}" class="grayscale">` : ''}
 						<span class="center-center font-semibold bg-indigo-100 text-indigo-800 rounded px-1 pb-[2px] ml-[2px]">
-							${id ?? numberToChars(graphId - 1)}
+							${nodeId}
 						</span>
 					</div>
 				</div>
+				<div class="text-2xs absolute -top-6 text-gray-600 truncate">${flowModuleStates?.[nodeId]?.scheduled_for ?? header ?? ''}<div>
 			`
         },
         host,
         width: NODE.width,
         height: NODE.height,
-        bgColor: 'white',
+        borderColor: selectedNode == nodeId ? 'black' : '#999',
+        bgColor: selectedNode == nodeId ? '#f5f5f5' : getStateColor(flowModuleStates?.[nodeId]?.type),
         parentIds,
         clickCallback: (node) => {
+            if (!notSelectable) {
+                selectedNode = nodeId;
+            }
+            if (onClickDetail.id == undefined) {
+                onClickDetail.id = nodeId;
+            }
             dispatch('click', onClickDetail);
         },
         edgeLabel
     };
 }
-function flowModuleToLoop(modules, startLabel, parent = undefined) {
+function flowModuleToLoop(modules, module, parent = undefined) {
+    const value = module.value;
+    const expr = value.iterator.type == 'static' ? value.iterator.value : value.iterator.expr;
     const loop = {
         type: 'loop',
-        items: [createVirtualNode(getParentIds(parent), startLabel)]
+        items: [
+            flowModuleToNode(getParentIds(parent), module.id, module.summary || `For Loop: ${defaultIfEmptyString(expr ?? '', 'TBD')}`, 'inline', module, undefined, undefined, flowModuleStates?.[module.id]?.iteration_total
+                ? 'Iteration ' + flowModuleStates?.[module.id]?.iteration_total
+                : '')
+        ]
     };
     modules.forEach((module) => {
         const item = getConvertedFlowModule(module, loop.items);
         item && loop.items.push(item);
     });
-    loop.items.push(createVirtualNode(getParentIds(loop.items), "Collect iterations' results"));
+    loop.items.push(createVirtualNode(getParentIds(loop.items), `Collect iterations' results of For Loop ${module.id}`, undefined, 1000));
     return loop;
 }
-function flowModuleToBranch(branches, edgesLabel, parent = undefined) {
+function flowModuleToBranch(module, branches, edgesLabel, parent = undefined) {
     const branch = {
         type: 'branch',
+        node: flowModuleToNode(getParentIds(parent), module.id, module.summary || module.value.type == 'branchall'
+            ? 'Run all branches'
+            : 'Run one branch given predicate', 'inline', module, undefined),
         items: []
     };
+    const branchParent = [numberToChars(branch.node.id)];
+    if (branches.length == 0) {
+        branch.items.push([createVirtualNode(branchParent, 'No branches')]);
+    }
     branches.forEach((modules, i) => {
         const items = [];
         if (!modules.length) {
-            items.push(createVirtualNode(getParentIds(parent), 'Empty branch', edgesLabel[i]));
+            items.push(createVirtualNode(branchParent, 'Empty branch', edgesLabel[i]));
         }
         else {
             modules.forEach((module) => {
-                const item = getConvertedFlowModule(module, items.length ? items : parent, edgesLabel[i]);
+                const item = getConvertedFlowModule(module, items.length ? items : numberToChars(branch.node.id), edgesLabel[i]);
                 item && items.push(item);
             });
         }
@@ -167,6 +226,7 @@ function flattenNestedNodes(nestedNodes, nodes = []) {
             flattenNestedNodes(node.items, array);
         }
         else if (isBranch(node)) {
+            array.push(node.node);
             node.items.forEach((item) => {
                 flattenNestedNodes(item, array);
             });
@@ -175,9 +235,7 @@ function flattenNestedNodes(nestedNodes, nodes = []) {
     return array;
 }
 function layoutNodes(nodes) {
-    if (!nodes.length)
-        return { nodes: [], height: 0 };
-    const stratify = dagStratify().id(({ id }) => '' + id);
+    const stratify = dagStratify().id(({ id }) => numberToChars(id));
     const dag = stratify(nodes);
     const layout = sugiyama()
         .decross(decrossOpt())
@@ -187,7 +245,7 @@ function layoutNodes(nodes) {
     return {
         nodes: dag.descendants().map((des) => ({
             ...des.data,
-            id: +des.data.id,
+            id: des.data.id,
             position: {
                 x: des.x ? des.x + (width - boxSize.width - NODE.width) / 2 : 0,
                 y: des.y || 0
@@ -200,24 +258,51 @@ function createEdges(nodes) {
     const edges = [];
     nodes.forEach((node) => {
         node.parentIds.forEach((pid, i) => {
-            edges.push({
-                id: `e-${pid}-${node.id}`,
-                source: +pid,
-                target: node.id,
-                labelBgColor: 'white',
-                arrow: true,
-                animate: false,
-                noHandle: false,
-                label: node.edgeLabel
-                // type: 'smoothstep'
-            });
+            // skip virtual nodes such as collect result
+            if (errorHandlers[pid] && node.id < 900 && nodes.find((x) => x.id == errorHandlers[pid])) {
+                edges.push({
+                    id: `e-${pid}-${node.id}`,
+                    source: charsToNumber(pid),
+                    target: errorHandlers[pid],
+                    labelBgColor: 'white',
+                    arrow: true,
+                    animate: false,
+                    noHandle: false,
+                    label: node.edgeLabel
+                    // type: 'smoothstep'
+                });
+                edges.push({
+                    id: `e-${pid}-${node.id}`,
+                    source: errorHandlers[pid],
+                    target: node.id,
+                    labelBgColor: 'white',
+                    arrow: true,
+                    animate: false,
+                    noHandle: false,
+                    label: node.edgeLabel
+                    // type: 'smoothstep'
+                });
+            }
+            else {
+                edges.push({
+                    id: `e-${pid}-${node.id}`,
+                    source: charsToNumber(pid),
+                    target: node.id,
+                    labelBgColor: 'white',
+                    arrow: true,
+                    animate: false,
+                    noHandle: false,
+                    label: node.edgeLabel
+                    // type: 'smoothstep'
+                });
+            }
         });
     });
     return edges;
 }
-function createVirtualNode(parentIds, label, edgesLabel) {
+function createVirtualNode(parentIds, label, edgesLabel, offset) {
     return {
-        id: idGenerator.next().value,
+        id: -idGenerator.next().value - 1 + (offset ?? 0),
         position: { x: -1, y: -1 },
         data: {
             html: `
@@ -228,33 +313,53 @@ function createVirtualNode(parentIds, label, edgesLabel) {
         },
         width: NODE.width,
         height: NODE.height,
-        bgColor: '#d4e4ff',
-        parentIds
+        borderColor: selectedNode == label ? 'black' : '#999',
+        bgColor: selectedNode == label ? '#f5f5f5' : '#d4e4ff',
+        parentIds,
+        clickCallback: (node) => {
+            if (!notSelectable) {
+                selectedNode = label;
+            }
+            dispatch('click', label);
+        }
     };
 }
-function createErrorHandler(parentIds, module) {
+function createErrorHandler(mod, parent_module) {
+    const nId = -idGenerator.next().value - 1 + 1100;
+    parent_module && (errorHandlers[parent_module] = nId);
     return {
-        id: -1,
+        id: nId,
         position: { x: -1, y: -1 },
         data: {
             html: `
-				<div class="w-full max-h-full text-center ellipsize-multi-line text-2xs [-webkit-line-clamp:2] px-1">
-					Error handler
+				<div class="w-full flex justify-between items-center px-1">
+					<div class="text-left ellipsize text-2xs truncate">
+						Error Handler
+					</div>
+					<div class="flex items-center">
+						<span class="center-center font-semibold bg-indigo-100 text-indigo-800 rounded px-1 pb-[2px] ml-[2px]">
+							${mod.id}
+						</span>
+					</div>
 				</div>
 			`
         },
         width: NODE.width,
         height: NODE.height,
-        bgColor: 'rgb(248 113 113)',
-        parentIds,
+        bgColor: selectedNode == mod.id ? '#f5f5f5' : getStateColor(flowModuleStates?.[mod.id]?.type),
+        borderColor: selectedNode == mod.id ? 'black' : '#999',
+        parentIds: parent_module ? [parent_module] : [],
         clickCallback: (node) => {
-            dispatch('click', module);
+            if (!notSelectable) {
+                selectedNode = mod.id;
+            }
+            dispatch('click', mod);
         }
     };
 }
 </script>
 
-<div bind:clientWidth={width} class="w-full h-full overflow-hidden">
+<div bind:clientWidth={width} class="w-full h-full overflow-hidden relative">
 	{#if width && height}
 		<Svelvet {nodes} {width} {edges} {height} bgColor="rgb(249 250 251)" />
 	{/if}

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

@@ -1,10 +1,13 @@
 import { SvelteComponentTyped } from "svelte";
-import type { FlowModule } from '../../gen';
+import { type FlowModule } from '../../gen';
+import { type GraphModuleState } from '.';
 declare const __propDef: {
     props: {
         modules?: FlowModule[] | undefined;
         failureModule?: FlowModule | undefined;
         minHeight?: number | undefined;
+        notSelectable?: boolean | undefined;
+        flowModuleStates?: Record<string, GraphModuleState> | undefined;
     };
     events: {
         click: CustomEvent<any>;
@@ -13,9 +16,9 @@ declare const __propDef: {
     };
     slots: {};
 };
-export declare type FlowGraphProps = typeof __propDef.props;
-export declare type FlowGraphEvents = typeof __propDef.events;
-export declare type FlowGraphSlots = typeof __propDef.slots;
+export type FlowGraphProps = typeof __propDef.props;
+export type FlowGraphEvents = typeof __propDef.events;
+export type FlowGraphSlots = typeof __propDef.slots;
 export default class FlowGraph extends SvelteComponentTyped<FlowGraphProps, FlowGraphEvents, FlowGraphSlots> {
 }
 export {};

package/components/graph/model.d.ts

@@ -1,20 +1,32 @@
+import type { FlowStatusModule } from "../../gen";
 import type { Node as SvelvetNode } from "svelvet";
-export declare type ModuleHost = 'workspace' | 'inline' | 'hub';
-export declare type Node = SvelvetNode & {
+export type ModuleHost = 'workspace' | 'inline' | 'hub';
+export type Node = SvelvetNode & {
     parentIds: string[];
     edgeLabel?: string;
     host?: ModuleHost;
 };
-export declare type Loop = {
+export type Loop = {
     type: 'loop';
     items: NestedNodes;
 };
-export declare type Branch = {
+export type Branch = {
+    node: Node;
     type: 'branch';
     items: NestedNodes[];
 };
-export declare type GraphItem = Node | Loop | Branch;
-export declare type NestedNodes = GraphItem[];
+export type GraphItem = Node | Loop | Branch;
+export type GraphModuleState = {
+    type: FlowStatusModule.type;
+    logs?: string;
+    result?: any;
+    scheduled_for?: string;
+    job_id?: string;
+    parent_module?: string;
+    iteration_total?: number;
+    retries?: number;
+};
+export type NestedNodes = GraphItem[];
 export declare function isNode(item: GraphItem | NestedNodes | undefined): item is Node;
 export declare function isLoop(item: GraphItem | NestedNodes | undefined): item is Loop;
 export declare function isBranch(item: GraphItem | NestedNodes | undefined): item is Branch;