windmill-components 1.655.1 → 1.665.0

package/package/components/graph/flowStructure.js

@@ -0,0 +1,422 @@
+import { getContainerInnerArrays } from './groupEditor.svelte';
+import { VIRTUAL_NODE_IDS } from './groupDetectionUtils';
+// ---------------------------------------------------------------------------
+// Type guards
+// ---------------------------------------------------------------------------
+// Building the structure tree
+// ---------------------------------------------------------------------------
+export function buildStructureTree(modules, groups) {
+    const { items, consumed } = buildStructureTreeRecurse(modules, groups);
+    const unconsumed = groups.filter((g) => !consumed.has(g.id));
+    if (unconsumed.length > 0) {
+        throw new Error(`Group(s) ${unconsumed.map((g) => `'${g.id}'`).join(', ')} could not be resolved: ` +
+            `their start/end nodes do not belong to the same branch`);
+    }
+    return items;
+}
+export function moduleToStructureNode(mod) {
+    const innerArrays = getContainerInnerArrays(mod);
+    if (innerArrays.length === 0) {
+        return { id: mod.id, kind: 'leaf', branches: [] };
+    }
+    const kind = mod.value.type;
+    const branches = innerArrays.map(({ get, label }) => ({
+        label,
+        children: [] // filled later by recursion
+    }));
+    return { id: mod.id, kind, branches };
+}
+function buildStructureTreeRecurse(modules, groups) {
+    if (modules.length === 0) {
+        return { items: [], consumed: new Set() };
+    }
+    const indexMap = new Map();
+    for (let i = 0; i < modules.length; i++) {
+        indexMap.set(modules[i].id, i);
+    }
+    // Reject duplicate group IDs
+    const seenGroupIds = new Set();
+    for (const g of groups) {
+        if (seenGroupIds.has(g.id)) {
+            throw new Error(`Duplicate group id: '${g.id}'`);
+        }
+        seenGroupIds.add(g.id);
+    }
+    // Reject groups referencing virtual nodes
+    for (const g of groups) {
+        if (VIRTUAL_NODE_IDS.has(g.start_id) || VIRTUAL_NODE_IDS.has(g.end_id)) {
+            throw new Error(`Group '${g.id}' references virtual node: groups cannot include Input, Result, or Trigger`);
+        }
+    }
+    // Partition: groups for this level vs rest
+    const levelGroups = [];
+    const otherGroups = [];
+    for (const g of groups) {
+        if (indexMap.has(g.start_id) && indexMap.has(g.end_id)) {
+            const s = indexMap.get(g.start_id);
+            const e = indexMap.get(g.end_id);
+            if (s > e) {
+                throw new Error(`Group '${g.id}' has inverted range: start_id='${g.start_id}' (index ${s}) > end_id='${g.end_id}' (index ${e})`);
+            }
+            levelGroups.push(g);
+        }
+        else {
+            otherGroups.push(g);
+        }
+    }
+    // Validate no partial overlaps
+    for (let i = 0; i < levelGroups.length; i++) {
+        for (let j = i + 1; j < levelGroups.length; j++) {
+            const a = levelGroups[i];
+            const b = levelGroups[j];
+            const aStart = indexMap.get(a.start_id);
+            const aEnd = indexMap.get(a.end_id);
+            const bStart = indexMap.get(b.start_id);
+            const bEnd = indexMap.get(b.end_id);
+            if (aEnd < bStart || bEnd < aStart)
+                continue;
+            if (aStart <= bStart && bEnd <= aEnd)
+                continue;
+            if (bStart <= aStart && aEnd <= bEnd)
+                continue;
+            throw new Error(`Groups '${a.id}' and '${b.id}' overlap without nesting`);
+        }
+    }
+    // Build grouped structure for this level
+    function build(startIdx, endIdx, availableGroups) {
+        const result = [];
+        let i = startIdx;
+        while (i <= endIdx) {
+            const candidates = availableGroups.filter((g) => {
+                const gStart = indexMap.get(g.start_id);
+                const gEnd = indexMap.get(g.end_id);
+                return gStart === i && gEnd <= endIdx;
+            });
+            candidates.sort((a, b) => {
+                const spanA = indexMap.get(a.end_id) - indexMap.get(a.start_id);
+                const spanB = indexMap.get(b.end_id) - indexMap.get(b.start_id);
+                return spanB - spanA;
+            });
+            const group = candidates[0];
+            if (group) {
+                const gEnd = indexMap.get(group.end_id);
+                const remaining = availableGroups.filter((g) => g.id !== group.id);
+                const innerNodes = build(i, gEnd, remaining);
+                const moduleIds = [];
+                for (let k = i; k <= gEnd; k++) {
+                    moduleIds.push(modules[k].id);
+                }
+                result.push({
+                    id: group.id,
+                    kind: 'group',
+                    group: {
+                        summary: group.summary,
+                        note: group.note,
+                        color: group.color,
+                        autocollapse: group.autocollapse,
+                        start_id: group.start_id,
+                        end_id: group.end_id
+                    },
+                    moduleIds,
+                    branches: [{ children: innerNodes }]
+                });
+                i = gEnd + 1;
+            }
+            else {
+                result.push(moduleToStructureNode(modules[i]));
+                i++;
+            }
+        }
+        return result;
+    }
+    const result = build(0, modules.length - 1, levelGroups);
+    // Recurse into containers with remaining unconsumed groups
+    const consumed = new Set(levelGroups.map((g) => g.id));
+    let remaining = otherGroups;
+    function recurseIntoContainers(items) {
+        for (const item of items) {
+            if (item.kind === 'group') {
+                recurseIntoContainers(item.branches[0].children);
+                continue;
+            }
+            if (item.branches.length === 0)
+                continue;
+            // This is a container module — get inner FlowModule arrays and recurse
+            const modIdx = indexMap.get(item.id);
+            if (modIdx === undefined)
+                continue;
+            const mod = modules[modIdx];
+            const innerArrays = getContainerInnerArrays(mod);
+            for (let bi = 0; bi < innerArrays.length; bi++) {
+                const inner = buildStructureTreeRecurse(innerArrays[bi].get(), remaining);
+                item.branches[bi] = {
+                    label: item.branches[bi]?.label,
+                    children: inner.items
+                };
+                for (const id of inner.consumed)
+                    consumed.add(id);
+                remaining = remaining.filter((g) => !inner.consumed.has(g.id));
+            }
+        }
+    }
+    recurseIntoContainers(result);
+    return { items: result, consumed };
+}
+// ---------------------------------------------------------------------------
+// Traversal utilities
+// ---------------------------------------------------------------------------
+/** Generic DFS over the structure tree */
+export function dfsStructure(nodes, fn) {
+    for (const node of nodes) {
+        fn(node, nodes);
+        for (const branch of node.branches) {
+            dfsStructure(branch.children, fn);
+        }
+    }
+}
+/** Flatten to ordered module IDs (groups are transparent) */
+export function flattenStructureIds(nodes) {
+    const ids = [];
+    for (const node of nodes) {
+        if (node.kind === 'group') {
+            ids.push(...flattenStructureIds(node.branches[0].children));
+        }
+        else {
+            ids.push(node.id);
+        }
+    }
+    return ids;
+}
+/** Collect leaf module IDs recursively (including inside containers) */
+export function collectLeafIds(nodes) {
+    const ids = [];
+    for (const node of nodes) {
+        if (node.kind === 'group') {
+            ids.push(...collectLeafIds(node.branches[0].children));
+        }
+        else {
+            ids.push(node.id);
+            for (const branch of node.branches) {
+                ids.push(...collectLeafIds(branch.children));
+            }
+        }
+    }
+    return ids;
+}
+export function findInStructure(nodes, id) {
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if (node.id === id)
+            return { parentChildren: nodes, index: i };
+        for (const branch of node.branches) {
+            const found = findInStructure(branch.children, id);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+/**
+ * Match a structure node against a graph node ID.
+ * Handles group head/end IDs (group:X, group:X-end) and collapsed-group:X.
+ */
+export function matchStructureNode(node, nodeId) {
+    if (node.id === nodeId)
+        return true;
+    if (node.kind === 'group') {
+        return (nodeId === `group:${node.id}` ||
+            nodeId === `group:${node.id}-end` ||
+            nodeId === `collapsed-group:${node.id}`);
+    }
+    return false;
+}
+/**
+ * Find insert index using graph node IDs (handles group:X-end etc.).
+ * Returns the index OF the matched item (insert before it).
+ * For group-end nodes, returns index AFTER the group (insert after it).
+ */
+export function findInsertIndexByNodeId(items, targetNodeId) {
+    // group-end: insert after the group
+    if (targetNodeId.startsWith('group:') && targetNodeId.endsWith('-end')) {
+        const groupId = targetNodeId.slice('group:'.length, -'-end'.length);
+        const idx = items.findIndex((n) => n.kind === 'group' && n.id === groupId);
+        return idx >= 0 ? idx + 1 : items.length;
+    }
+    // Everything else: insert at the matched item's position
+    for (let i = 0; i < items.length; i++) {
+        if (matchStructureNode(items[i], targetNodeId))
+            return i;
+    }
+    return items.length;
+}
+// ---------------------------------------------------------------------------
+// Deriving groups from the structure tree
+// ---------------------------------------------------------------------------
+export function deriveGroupsFromStructure(nodes) {
+    const groups = [];
+    for (const node of nodes) {
+        if (node.kind === 'group' && node.group) {
+            const flatIds = flattenStructureIds(node.branches[0].children);
+            if (flatIds.length === 0) {
+                console.warn(`deriveGroupsFromStructure: skipping empty group "${node.id}"`);
+                continue;
+            }
+            groups.push({
+                ...node.group,
+                start_id: flatIds[0],
+                end_id: flatIds[flatIds.length - 1]
+            });
+            // Recurse for nested groups
+            groups.push(...deriveGroupsFromStructure(node.branches[0].children));
+        }
+        else {
+            for (const branch of node.branches) {
+                groups.push(...deriveGroupsFromStructure(branch.children));
+            }
+        }
+    }
+    return groups;
+}
+// ---------------------------------------------------------------------------
+// Syncing structure back to FlowModule[]
+// ---------------------------------------------------------------------------
+/**
+ * Reconstruct a FlowModule[] from the structure tree, looking up originals
+ * from moduleMap and patching container inner arrays to match the tree ordering.
+ */
+export function applyStructureToModules(nodes, moduleMap) {
+    const result = [];
+    for (const node of nodes) {
+        if (node.kind === 'group') {
+            // Groups are transparent — splice their children into this level
+            result.push(...applyStructureToModules(node.branches[0].children, moduleMap));
+        }
+        else {
+            const mod = moduleMap.get(node.id);
+            if (!mod)
+                continue;
+            // Patch container inner arrays
+            if (node.branches.length > 0) {
+                const innerArrays = getContainerInnerArrays(mod);
+                for (let bi = 0; bi < innerArrays.length && bi < node.branches.length; bi++) {
+                    innerArrays[bi].set(applyStructureToModules(node.branches[bi].children, moduleMap));
+                }
+            }
+            result.push(mod);
+        }
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Empty groups cleanup
+// ---------------------------------------------------------------------------
+/**
+ * Walk the tree, remove group nodes that have no leaf modules, and return
+ * the removed groups. Mutates the input array in-place.
+ * Recurses depth-first so inner groups are cleaned before checking outer ones.
+ */
+export function removeEmptyGroups(nodes) {
+    const removed = [];
+    for (let i = nodes.length - 1; i >= 0; i--) {
+        const node = nodes[i];
+        if (node.kind === 'group' && node.group) {
+            // Recurse first — inner groups may become empty too
+            removed.push(...removeEmptyGroups(node.branches[0].children));
+            if (flattenStructureIds(node.branches[0].children).length === 0) {
+                removed.push(node.group);
+                nodes.splice(i, 1);
+            }
+        }
+        else {
+            for (const branch of node.branches) {
+                removed.push(...removeEmptyGroups(branch.children));
+            }
+        }
+    }
+    return removed;
+}
+/** Walk the structure tree to compute nesting depth for each group (O(n)). */
+export function computeGroupDepths(tree) {
+    const depths = {};
+    function walk(nodes, groupDepth) {
+        for (const node of nodes) {
+            if (node.kind === 'group') {
+                depths[node.id] = groupDepth;
+                for (const branch of node.branches) {
+                    walk(branch.children, groupDepth + 1);
+                }
+            }
+            else {
+                for (const branch of node.branches) {
+                    walk(branch.children, groupDepth);
+                }
+            }
+        }
+    }
+    walk(tree, 0);
+    return depths;
+}
+/**
+ * Find duplicate groups in the structure tree (same start_id:end_id after mutation).
+ * Returns the groups that should be removed (keeps the first, removes subsequent duplicates).
+ */
+export function findDuplicateGroups(nodes) {
+    const duplicates = [];
+    const seen = new Set();
+    function walk(items) {
+        for (const node of items) {
+            if (node.kind === 'group' && node.group) {
+                const flatIds = flattenStructureIds(node.branches[0].children);
+                if (flatIds.length > 0) {
+                    const key = `${flatIds[0]}:${flatIds[flatIds.length - 1]}`;
+                    if (seen.has(key)) {
+                        duplicates.push(node.group);
+                    }
+                    else {
+                        seen.add(key);
+                    }
+                }
+                walk(node.branches[0].children);
+            }
+            else {
+                for (const branch of node.branches) {
+                    walk(branch.children);
+                }
+            }
+        }
+    }
+    walk(nodes);
+    return duplicates;
+}
+/** Remove duplicate groups from the structure tree (keeps first occurrence). */
+export function removeDuplicateGroups(nodes) {
+    const removed = [];
+    const seen = new Set();
+    function walk(items) {
+        for (let i = items.length - 1; i >= 0; i--) {
+            const node = items[i];
+            if (node.kind === 'group' && node.group) {
+                walk(node.branches[0].children);
+                const flatIds = flattenStructureIds(node.branches[0].children);
+                if (flatIds.length > 0) {
+                    const key = `${flatIds[0]}:${flatIds[flatIds.length - 1]}`;
+                    if (seen.has(key)) {
+                        // Replace group node with its children (ungroup)
+                        removed.push(node.group);
+                        items.splice(i, 1, ...node.branches[0].children);
+                    }
+                    else {
+                        seen.add(key);
+                    }
+                }
+            }
+            else {
+                for (const branch of node.branches) {
+                    walk(branch.children);
+                }
+            }
+        }
+    }
+    walk(nodes);
+    return removed;
+}

package/package/components/graph/flowStructure.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package/components/graph/flowStructure.test.js

@@ -0,0 +1,205 @@
+import { describe, it, expect, vi } from 'vitest';
+// Mock modules that transitively import CSS/Monaco
+vi.mock('monaco-editor', () => ({}));
+vi.mock('@xyflow/svelte', () => ({}));
+vi.mock('./renderers/nodes/AssetNode.svelte', () => ({
+    assetDisplaysAsOutputInFlowGraph: () => false
+}));
+vi.mock('../modulesTest.svelte', () => ({}));
+import { buildStructureTree, flattenStructureIds, deriveGroupsFromStructure, collectLeafIds, findInStructure } from './flowStructure';
+function makeModule(id) {
+    return {
+        id,
+        value: { type: 'rawscript', content: '', language: 'python3' }
+    };
+}
+function makeBranchAll(id, branchInnerIds) {
+    return {
+        id,
+        value: {
+            type: 'branchall',
+            branches: branchInnerIds.map((ids) => ({ modules: ids.map((iid) => makeModule(iid)) }))
+        }
+    };
+}
+function makeForloop(id, innerIds) {
+    return {
+        id,
+        value: {
+            type: 'forloopflow',
+            modules: innerIds.map((iid) => makeModule(iid)),
+            iterator: { type: 'javascript', expr: '' }
+        }
+    };
+}
+function makeGroup(id, start_id, end_id, moduleIds = []) {
+    return { id, start_id, end_id, moduleIds };
+}
+describe('buildStructureTree', () => {
+    const modules = [makeModule('a'), makeModule('b'), makeModule('c')];
+    it('builds structure tree for a valid group', () => {
+        const groups = [makeGroup('g1', 'a', 'b', ['a', 'b'])];
+        const result = buildStructureTree(modules, groups);
+        // Should have a group node + the remaining leaf 'c'
+        expect(result).toHaveLength(2);
+        expect(result[0].kind).toBe('group');
+        expect(result[0].id).toBe('g1');
+        expect(result[0].branches[0].children).toHaveLength(2);
+        expect(result[1].kind).toBe('leaf');
+        expect(result[1].id).toBe('c');
+    });
+    it('throws on duplicate group IDs', () => {
+        const groups = [makeGroup('g1', 'a', 'a', ['a']), makeGroup('g1', 'b', 'c', ['b', 'c'])];
+        expect(() => buildStructureTree(modules, groups)).toThrow(/duplicate group id.*g1/i);
+    });
+    it('throws on inverted range (start_id after end_id)', () => {
+        const groups = [makeGroup('g1', 'c', 'a', ['a', 'b', 'c'])];
+        expect(() => buildStructureTree(modules, groups)).toThrow(/inverted range/i);
+    });
+    it('throws on partially overlapping groups', () => {
+        const groups = [makeGroup('g1', 'a', 'b', ['a', 'b']), makeGroup('g2', 'b', 'c', ['b', 'c'])];
+        expect(() => buildStructureTree(modules, groups)).toThrow(/overlap without nesting/i);
+    });
+    it('throws when group start_id is a virtual node (Input)', () => {
+        const groups = [makeGroup('g1', 'Input', 'b', ['a', 'b'])];
+        expect(() => buildStructureTree(modules, groups)).toThrow(/virtual node/i);
+    });
+    it('throws when group end_id is a virtual node (Result)', () => {
+        const groups = [makeGroup('g1', 'a', 'Result', ['a', 'b', 'c'])];
+        expect(() => buildStructureTree(modules, groups)).toThrow(/virtual node/i);
+    });
+    it('throws when group references Trigger', () => {
+        const groups = [makeGroup('g1', 'Trigger', 'c', ['a', 'b', 'c'])];
+        expect(() => buildStructureTree(modules, groups)).toThrow(/virtual node/i);
+    });
+    it('allows fully nested groups', () => {
+        const mods = [makeModule('a'), makeModule('b'), makeModule('c'), makeModule('d')];
+        const groups = [
+            makeGroup('outer', 'a', 'd', ['a', 'b', 'c', 'd']),
+            makeGroup('inner', 'b', 'c', ['b', 'c'])
+        ];
+        const result = buildStructureTree(mods, groups);
+        expect(result).toHaveLength(1); // outer group contains everything
+        expect(result[0].kind).toBe('group');
+        // Inner group should be nested
+        const outerChildren = result[0].branches[0].children;
+        expect(outerChildren).toHaveLength(3); // a, inner-group, d
+        expect(outerChildren[1].kind).toBe('group');
+        expect(outerChildren[1].id).toBe('inner');
+    });
+    it('handles empty modules', () => {
+        const result = buildStructureTree([], []);
+        expect(result).toHaveLength(0);
+    });
+    it('handles container modules (forloop)', () => {
+        const mods = [makeForloop('loop', ['x', 'y']), makeModule('c')];
+        const result = buildStructureTree(mods, []);
+        expect(result).toHaveLength(2);
+        expect(result[0].kind).toBe('forloopflow');
+        expect(result[0].branches).toHaveLength(1);
+        expect(result[0].branches[0].children).toHaveLength(2);
+        expect(result[0].branches[0].children[0].id).toBe('x');
+    });
+    it('handles groups inside containers', () => {
+        const mods = [makeForloop('loop', ['x', 'y', 'z'])];
+        const groups = [makeGroup('g1', 'x', 'y', ['x', 'y'])];
+        const result = buildStructureTree(mods, groups);
+        expect(result).toHaveLength(1);
+        expect(result[0].kind).toBe('forloopflow');
+        const innerChildren = result[0].branches[0].children;
+        expect(innerChildren).toHaveLength(2); // group + z
+        expect(innerChildren[0].kind).toBe('group');
+        expect(innerChildren[0].id).toBe('g1');
+    });
+    it('throws when group spans parallel branches (branchall)', () => {
+        const mods = [
+            makeModule('a'),
+            makeBranchAll('ba', [
+                ['x', 'y'],
+                ['p', 'q']
+            ]),
+            makeModule('c')
+        ];
+        const groups = [makeGroup('g1', 'x', 'q', ['x', 'q'])];
+        expect(() => buildStructureTree(mods, groups)).toThrow(/could not be resolved/);
+    });
+});
+describe('flattenStructureIds', () => {
+    it('flattens a simple tree', () => {
+        const modules = [makeModule('a'), makeModule('b'), makeModule('c')];
+        const groups = [makeGroup('g1', 'a', 'b', ['a', 'b'])];
+        const tree = buildStructureTree(modules, groups);
+        const ids = flattenStructureIds(tree);
+        expect(ids).toEqual(['a', 'b', 'c']);
+    });
+    it('flattens nested groups', () => {
+        const mods = [makeModule('a'), makeModule('b'), makeModule('c'), makeModule('d')];
+        const groups = [
+            makeGroup('outer', 'a', 'd', ['a', 'b', 'c', 'd']),
+            makeGroup('inner', 'b', 'c', ['b', 'c'])
+        ];
+        const tree = buildStructureTree(mods, groups);
+        const ids = flattenStructureIds(tree);
+        expect(ids).toEqual(['a', 'b', 'c', 'd']);
+    });
+});
+describe('deriveGroupsFromStructure', () => {
+    it('derives group definitions with correct start/end', () => {
+        const modules = [makeModule('a'), makeModule('b'), makeModule('c')];
+        const groups = [makeGroup('g1', 'a', 'b', ['a', 'b'])];
+        const tree = buildStructureTree(modules, groups);
+        const derived = deriveGroupsFromStructure(tree);
+        expect(derived).toHaveLength(1);
+        expect(derived[0].start_id).toBe('a');
+        expect(derived[0].end_id).toBe('b');
+    });
+    it('derives nested groups', () => {
+        const mods = [makeModule('a'), makeModule('b'), makeModule('c'), makeModule('d')];
+        const groups = [
+            makeGroup('outer', 'a', 'd', ['a', 'b', 'c', 'd']),
+            makeGroup('inner', 'b', 'c', ['b', 'c'])
+        ];
+        const tree = buildStructureTree(mods, groups);
+        const derived = deriveGroupsFromStructure(tree);
+        expect(derived).toHaveLength(2);
+        expect(derived[0].start_id).toBe('a');
+        expect(derived[0].end_id).toBe('d');
+        expect(derived[1].start_id).toBe('b');
+        expect(derived[1].end_id).toBe('c');
+    });
+});
+describe('findInStructure', () => {
+    it('finds a leaf node', () => {
+        const modules = [makeModule('a'), makeModule('b')];
+        const tree = buildStructureTree(modules, []);
+        const found = findInStructure(tree, 'b');
+        expect(found).toBeDefined();
+        expect(found.index).toBe(1);
+    });
+    it('finds a node inside a group', () => {
+        const modules = [makeModule('a'), makeModule('b'), makeModule('c')];
+        const groups = [makeGroup('g1', 'a', 'b', ['a', 'b'])];
+        const tree = buildStructureTree(modules, groups);
+        const found = findInStructure(tree, 'b');
+        expect(found).toBeDefined();
+        expect(found.index).toBe(1);
+        // parentChildren should be the group's branch children
+        expect(found.parentChildren).toHaveLength(2);
+    });
+    it('finds a group node by group id', () => {
+        const modules = [makeModule('a'), makeModule('b')];
+        const groups = [makeGroup('g1', 'a', 'b', ['a', 'b'])];
+        const tree = buildStructureTree(modules, groups);
+        const found = findInStructure(tree, 'g1');
+        expect(found).toBeDefined();
+        expect(found.index).toBe(0);
+    });
+});
+describe('collectLeafIds', () => {
+    it('collects all leaf module IDs including inside containers', () => {
+        const mods = [makeForloop('loop', ['x', 'y']), makeModule('c')];
+        const tree = buildStructureTree(mods, []);
+        const ids = collectLeafIds(tree);
+        expect(ids).toEqual(['loop', 'x', 'y', 'c']);
+    });
+});