windmill-components 1.677.1 → 1.687.0

package/package/components/flows/flowDiff.js

@@ -1,5 +1,6 @@
-import { dfs } from './dfs';
 import { deepEqual } from 'fast-equals';
+import { collectAllFlowModuleIds, collectFlowNodes, ensureModuleArrayByLocation, findModuleParent, getModuleArrayByLocation } from './flowTree';
+export { findModuleInFlow, findModuleParent } from './flowTree';
 /** Prefix added to module IDs when the original module coexists with a replacement */
 export const DUPLICATE_MODULE_PREFIX = 'old__';
 /** Prefix added to new module IDs when restoring original during type change rejection */
@@ -103,21 +104,11 @@ export function computeFlowModuleDiff(beforeFlow, afterFlow, options = { markAsP
  */
 function getAllModulesMap(flow) {
     const moduleMap = new Map();
-    // Get all regular modules
-    const allModules = dfs(flow.modules ?? [], (m) => m);
-    for (const module of allModules) {
+    for (const { module } of collectFlowNodes(flow)) {
         if (module?.id) {
             moduleMap.set(module.id, module);
         }
     }
-    // Add failure module if it exists
-    if (flow.failure_module?.id) {
-        moduleMap.set(flow.failure_module.id, flow.failure_module);
-    }
-    // Add preprocessor module if it exists
-    if (flow.preprocessor_module?.id) {
-        moduleMap.set(flow.preprocessor_module.id, flow.preprocessor_module);
-    }
     return moduleMap;
 }
 /**
@@ -125,28 +116,14 @@ function getAllModulesMap(flow) {
  */
 function getAllModulesWithLocation(flow) {
     const result = new Map();
-    const allModules = dfs(flow.modules ?? [], (m) => m);
-    for (const module of allModules) {
-        if (module?.id) {
-            const location = findModuleParent(flow, module.id);
-            if (location) {
-                result.set(module.id, { module, location });
-            }
+    for (const entry of collectFlowNodes(flow)) {
+        if (entry.module?.id) {
+            result.set(entry.module.id, {
+                module: entry.module,
+                location: entry.location
+            });
         }
     }
-    // Add special modules
-    if (flow.failure_module?.id) {
-        result.set(flow.failure_module.id, {
-            module: flow.failure_module,
-            location: { type: 'failure', index: -1 }
-        });
-    }
-    if (flow.preprocessor_module?.id) {
-        result.set(flow.preprocessor_module.id, {
-            module: flow.preprocessor_module,
-            location: { type: 'preprocessor', index: -1 }
-        });
-    }
     return result;
 }
 /**
@@ -177,95 +154,6 @@ export function locationsEqual(a, b) {
             return false;
     }
 }
-/**
- * Finds the parent location of a module in a flow
- */
-export function findModuleParent(flow, moduleId) {
-    // Check special modules
-    if (flow.failure_module?.id === moduleId) {
-        return { type: 'failure', index: -1 };
-    }
-    if (flow.preprocessor_module?.id === moduleId) {
-        return { type: 'preprocessor', index: -1 };
-    }
-    // Check root level
-    const rootIndex = flow.modules?.findIndex((m) => m.id === moduleId);
-    if (rootIndex !== undefined && rootIndex >= 0) {
-        return { type: 'root', index: rootIndex };
-    }
-    // Recursively search nested modules
-    function searchInModules(modules) {
-        for (const module of modules) {
-            // Check forloopflow
-            if (module.value.type === 'forloopflow') {
-                const index = module.value.modules.findIndex((m) => m.id === moduleId);
-                if (index >= 0) {
-                    return { type: 'forloop', parentId: module.id, index };
-                }
-                const nested = searchInModules(module.value.modules);
-                if (nested)
-                    return nested;
-            }
-            // Check whileloopflow
-            if (module.value.type === 'whileloopflow') {
-                const index = module.value.modules.findIndex((m) => m.id === moduleId);
-                if (index >= 0) {
-                    return { type: 'whileloop', parentId: module.id, index };
-                }
-                const nested = searchInModules(module.value.modules);
-                if (nested)
-                    return nested;
-            }
-            // Check branchone
-            if (module.value.type === 'branchone') {
-                // Check default branch
-                const defaultIndex = module.value.default.findIndex((m) => m.id === moduleId);
-                if (defaultIndex >= 0) {
-                    return { type: 'branchone-default', parentId: module.id, index: defaultIndex };
-                }
-                const nestedDefault = searchInModules(module.value.default);
-                if (nestedDefault)
-                    return nestedDefault;
-                // Check other branches
-                for (let branchIndex = 0; branchIndex < module.value.branches.length; branchIndex++) {
-                    const branch = module.value.branches[branchIndex];
-                    const index = branch.modules.findIndex((m) => m.id === moduleId);
-                    if (index >= 0) {
-                        return { type: 'branchone-branch', parentId: module.id, branchIndex, index };
-                    }
-                    const nested = searchInModules(branch.modules);
-                    if (nested)
-                        return nested;
-                }
-            }
-            // Check branchall
-            if (module.value.type === 'branchall') {
-                for (let branchIndex = 0; branchIndex < module.value.branches.length; branchIndex++) {
-                    const branch = module.value.branches[branchIndex];
-                    const index = branch.modules.findIndex((m) => m.id === moduleId);
-                    if (index >= 0) {
-                        return { type: 'branchall-branch', parentId: module.id, branchIndex, index };
-                    }
-                    const nested = searchInModules(branch.modules);
-                    if (nested)
-                        return nested;
-                }
-            }
-            // Check aiagent
-            if (module.value.type === 'aiagent' && module.value.tools) {
-                const index = module.value.tools.findIndex((m) => m.id === moduleId);
-                if (index >= 0) {
-                    return { type: 'aiagent', parentId: module.id, index };
-                }
-                const nested = searchInModules(module.value.tools);
-                if (nested)
-                    return nested;
-            }
-        }
-        return null;
-    }
-    return searchInModules(flow.modules ?? []);
-}
 /**
  * Deep clones a module to avoid mutation
  */
@@ -333,48 +221,8 @@ function prependModuleId(module, prefix) {
     }
     return newModule;
 }
-/**
- * Collects all module IDs from a flow structure recursively
- */
 function getAllModuleIds(flow) {
-    const ids = new Set();
-    function collectFromModules(modules) {
-        for (const module of modules) {
-            if (module.id) {
-                ids.add(module.id);
-            }
-            // Recursively collect from nested modules
-            if (module.value.type === 'forloopflow' || module.value.type === 'whileloopflow') {
-                collectFromModules(module.value.modules);
-            }
-            else if (module.value.type === 'branchone') {
-                collectFromModules(module.value.default);
-                for (const branch of module.value.branches) {
-                    collectFromModules(branch.modules);
-                }
-            }
-            else if (module.value.type === 'branchall') {
-                for (const branch of module.value.branches) {
-                    collectFromModules(branch.modules);
-                }
-            }
-            else if (module.value.type === 'aiagent' && module.value.tools) {
-                collectFromModules(module.value.tools);
-            }
-        }
-    }
-    // Collect from root modules
-    if (flow.modules) {
-        collectFromModules(flow.modules);
-    }
-    // Collect from special modules
-    if (flow.failure_module?.id) {
-        ids.add(flow.failure_module.id);
-    }
-    if (flow.preprocessor_module?.id) {
-        ids.add(flow.preprocessor_module.id);
-    }
-    return ids;
+    return new Set(collectAllFlowModuleIds(flow));
 }
 /**
  * Scans the merged flow for duplicate IDs and prefixes duplicates with 'old__'.
@@ -503,24 +351,7 @@ function reconstructMergedFlow(afterFlow, beforeFlow, beforeActions) {
         }
         // Track the newly added module ID
         mergedIds.add(clonedModule.id);
-        // Insert based on parent location
-        if (parentLocation.type === 'failure') {
-            merged.failure_module = clonedModule;
-        }
-        else if (parentLocation.type === 'preprocessor') {
-            merged.preprocessor_module = clonedModule;
-        }
-        else if (parentLocation.type === 'root') {
-            // Find the best position to insert in root modules
-            const insertIndex = findBestInsertPosition(merged.modules ?? [], beforeFlow.modules ?? [], parentLocation.index, removedId);
-            if (!merged.modules)
-                merged.modules = [];
-            merged.modules.splice(insertIndex, 0, clonedModule);
-        }
-        else {
-            // Find the parent module in merged flow and insert into it
-            insertIntoNestedParent(merged, parentLocation, clonedModule, beforeFlow);
-        }
+        insertModuleIntoFlow(merged, clonedModule, beforeFlow, removedId);
     }
     // Post-process: fix any duplicate IDs that may have been created
     // This handles the case where a module moved from one location to another
@@ -554,101 +385,6 @@ function findBestInsertPosition(targetModules, beforeModules, originalIndex, rem
 /**
  * Inserts a removed module into its nested parent in the merged flow
  */
-function insertIntoNestedParent(merged, parentLocation, moduleToInsert, beforeFlow) {
-    if (parentLocation.type === 'root' ||
-        parentLocation.type === 'failure' ||
-        parentLocation.type === 'preprocessor') {
-        return;
-    }
-    // Find the parent module in merged flow
-    const parentModule = findModuleById(merged, parentLocation.parentId);
-    if (!parentModule) {
-        console.warn('Parent module not found', parentLocation);
-        return;
-    }
-    // Get the before parent to know original ordering
-    const beforeParent = findModuleById(beforeFlow, parentLocation.parentId);
-    if (!beforeParent) {
-        console.warn('Before parent module not found', parentLocation);
-        return;
-    }
-    // Insert based on type
-    if (parentLocation.type === 'forloop' && parentModule.value.type === 'forloopflow') {
-        const beforeModules = beforeParent.value.modules ?? [];
-        const insertIndex = findBestInsertPosition(parentModule.value.modules, beforeModules, parentLocation.index, moduleToInsert.id);
-        parentModule.value.modules.splice(insertIndex, 0, moduleToInsert);
-    }
-    else if (parentLocation.type === 'whileloop' && parentModule.value.type === 'whileloopflow') {
-        const beforeModules = beforeParent.value.modules ?? [];
-        const insertIndex = findBestInsertPosition(parentModule.value.modules, beforeModules, parentLocation.index, moduleToInsert.id);
-        parentModule.value.modules.splice(insertIndex, 0, moduleToInsert);
-    }
-    else if (parentLocation.type === 'branchone-default' &&
-        parentModule.value.type === 'branchone') {
-        const beforeModules = beforeParent.value.default ?? [];
-        const insertIndex = findBestInsertPosition(parentModule.value.default, beforeModules, parentLocation.index, moduleToInsert.id);
-        parentModule.value.default.splice(insertIndex, 0, moduleToInsert);
-    }
-    else if (parentLocation.type === 'branchone-branch' &&
-        parentModule.value.type === 'branchone') {
-        let branch = parentModule.value.branches[parentLocation.branchIndex];
-        const beforeBranch = beforeParent.value.branches?.[parentLocation.branchIndex];
-        // If the branch doesn't exist (entire branch was removed), recreate it from beforeFlow
-        if (!branch && beforeBranch) {
-            // Ensure we have enough branch slots
-            while (parentModule.value.branches.length <= parentLocation.branchIndex) {
-                parentModule.value.branches.push({ expr: '', modules: [] });
-            }
-            // Restore the branch with its original expr but empty modules (we'll add them)
-            parentModule.value.branches[parentLocation.branchIndex] = {
-                ...beforeBranch,
-                modules: []
-            };
-            branch = parentModule.value.branches[parentLocation.branchIndex];
-        }
-        if (branch) {
-            const beforeModules = beforeBranch?.modules ?? [];
-            const insertIndex = findBestInsertPosition(branch.modules, beforeModules, parentLocation.index, moduleToInsert.id);
-            branch.modules.splice(insertIndex, 0, moduleToInsert);
-        }
-    }
-    else if (parentLocation.type === 'branchall-branch' &&
-        parentModule.value.type === 'branchall') {
-        let branch = parentModule.value.branches[parentLocation.branchIndex];
-        const beforeBranch = beforeParent.value.branches?.[parentLocation.branchIndex];
-        // If the branch doesn't exist (entire branch was removed), recreate it from beforeFlow
-        if (!branch && beforeBranch) {
-            // Ensure we have enough branch slots
-            while (parentModule.value.branches.length <= parentLocation.branchIndex) {
-                parentModule.value.branches.push({ modules: [] });
-            }
-            // Restore the branch with empty modules (we'll add them)
-            parentModule.value.branches[parentLocation.branchIndex] = {
-                ...beforeBranch,
-                modules: []
-            };
-            branch = parentModule.value.branches[parentLocation.branchIndex];
-        }
-        if (branch) {
-            const beforeModules = beforeBranch?.modules ?? [];
-            const insertIndex = findBestInsertPosition(branch.modules, beforeModules, parentLocation.index, moduleToInsert.id);
-            branch.modules.splice(insertIndex, 0, moduleToInsert);
-        }
-    }
-    else if (parentLocation.type === 'aiagent' && parentModule.value.type === 'aiagent') {
-        const tools = parentModule.value.tools ?? [];
-        const beforeTools = beforeParent.value.tools ?? [];
-        const insertIndex = findBestInsertPosition(tools, beforeTools, parentLocation.index, moduleToInsert.id);
-        tools.splice(insertIndex, 0, moduleToInsert);
-    }
-}
-/**
- * Finds a module by ID anywhere in the flow
- */
-function findModuleById(flow, moduleId) {
-    const moduleMap = getAllModulesMap(flow);
-    return moduleMap.get(moduleId) ?? null;
-}
 /**
  * Adjusts the after actions based on display mode and adds entries for prefixed IDs
  */
@@ -732,26 +468,13 @@ export function insertModuleIntoFlow(targetFlow, moduleToInsert, sourceFlow, mod
         targetFlow.preprocessor_module = moduleToInsert;
         return;
     }
-    // Handle root level modules
-    if (parentLocation.type === 'root') {
-        const insertIndex = findBestInsertPosition(targetFlow.modules ?? [], sourceFlow.modules ?? [], parentLocation.index, moduleId);
-        if (!targetFlow.modules)
-            targetFlow.modules = [];
-        targetFlow.modules.splice(insertIndex, 0, moduleToInsert);
+    const targetModules = ensureModuleArrayByLocation(targetFlow, parentLocation, sourceFlow);
+    const sourceModules = getModuleArrayByLocation(sourceFlow, parentLocation);
+    if (!targetModules || !sourceModules) {
         return;
     }
-    // Handle nested modules
-    insertIntoNestedParent(targetFlow, parentLocation, moduleToInsert, sourceFlow);
-}
-/**
- * Finds a module by ID anywhere in a flow (including nested modules, failure, and preprocessor)
- *
- * @param flow - The flow to search in
- * @param moduleId - The ID of the module to find
- * @returns The module if found, null otherwise
- */
-export function findModuleInFlow(flow, moduleId) {
-    return findModuleById(flow, moduleId);
+    const insertIndex = findBestInsertPosition(targetModules, sourceModules, parentLocation.index, moduleId);
+    targetModules.splice(insertIndex, 0, moduleToInsert);
 }
 /**
  * Checks if the input schema has changed between two flow versions.

package/package/components/flows/flowDiff.testUtils.d.ts

@@ -30,6 +30,14 @@ export declare function createBranchOneModule(id: string, defaultModules: FlowMo
 export declare function createBranchAllModule(id: string, branches: {
     modules: FlowModule[];
 }[]): FlowModule;
+/**
+ * Wraps a FlowModule as an AI agent flowmodule tool.
+ */
+export declare function createFlowModuleTool(module: FlowModule): FlowModule;
+/**
+ * Creates an AI agent module with the provided tools.
+ */
+export declare function createAiAgentModule(id: string, tools: FlowModule[]): FlowModule;
 /**
  * Creates a FlowValue with the given modules
  */

package/package/components/flows/flowDiff.testUtils.js

@@ -79,6 +79,32 @@ export function createBranchAllModule(id, branches) {
         }
     };
 }
+/**
+ * Wraps a FlowModule as an AI agent flowmodule tool.
+ */
+export function createFlowModuleTool(module) {
+    return {
+        id: module.id,
+        summary: module.summary,
+        value: {
+            tool_type: 'flowmodule',
+            ...module.value
+        }
+    };
+}
+/**
+ * Creates an AI agent module with the provided tools.
+ */
+export function createAiAgentModule(id, tools) {
+    return {
+        id,
+        value: {
+            type: 'aiagent',
+            tools,
+            input_transforms: {}
+        }
+    };
+}
 // ============================================================================
 // Flow Creation Helpers
 // ============================================================================

package/package/components/flows/flowDiffManager.svelte.js

@@ -5,10 +5,9 @@
  * This decouples diff management from specific UI components (like AI chat) and makes it
  * available for any use case that needs to track and apply flow changes.
  */
-import { buildFlowTimeline, insertModuleIntoFlow, findModuleParent, locationsEqual, DUPLICATE_MODULE_PREFIX, NEW_MODULE_PREFIX } from './flowDiff';
+import { buildFlowTimeline, insertModuleIntoFlow, locationsEqual, DUPLICATE_MODULE_PREFIX, NEW_MODULE_PREFIX } from './flowDiff';
+import { findModuleInFlow, findModuleParent, removeFlowModule, replaceFlowModule } from './flowTree';
 import { refreshStateStore } from '../../svelte5Utils.svelte';
-import { getIndexInNestedModules } from '../copilot/chat/flow/utils';
-import { dfs } from './previousResults';
 import { SPECIAL_MODULE_IDS } from '../copilot/chat/shared';
 /**
  * Creates a flow diff manager instance
@@ -26,7 +25,7 @@ function createSkeletonModule(module) {
         clone.value.branches.forEach((b) => (b.modules = []));
     }
     else if (clone.value.type === 'aiagent') {
-        clone.value.tools = [];
+        clone.value.tools = (clone.value.tools ?? []).filter((t) => t.value?.tool_type && t.value.tool_type !== 'flowmodule');
     }
     return clone;
 }
@@ -134,47 +133,12 @@ export function createFlowDiffManager({ testMode = false } = {}) {
     function setModuleActions(actions) {
         updateModuleActions(actions);
     }
-    /**
-     * Helper to get a module from a flow by ID
-     */
-    function getModuleFromFlow(id, flow) {
-        if (flow.value.preprocessor_module?.id === id) {
-            return flow.value.preprocessor_module;
-        }
-        else if (flow.value.failure_module?.id === id) {
-            return flow.value.failure_module;
-        }
-        else {
-            return dfs(id, flow, false)[0];
-        }
-    }
     /**
      * Internal helper to delete a module from a flow object
      * Returns true if the module was found and deleted, false otherwise
      */
     function deleteModuleInternal(id, flow) {
-        if (flow.value.preprocessor_module?.id === id) {
-            flow.value.preprocessor_module = undefined;
-            return true;
-        }
-        else if (flow.value.failure_module?.id === id) {
-            flow.value.failure_module = undefined;
-            return true;
-        }
-        else {
-            const result = getIndexInNestedModules(flow, id);
-            if (!result) {
-                // Module not found (may have been deleted along with a parent)
-                return false;
-            }
-            const { modules } = result;
-            const index = modules.findIndex((m) => m.id === id);
-            if (index >= 0) {
-                modules.splice(index, 1);
-                return true;
-            }
-            return false;
-        }
+        return removeFlowModule(flow.value, id) !== null;
     }
     /**
      * Helper to delete a module from the flow
@@ -221,7 +185,7 @@ export function createFlowDiffManager({ testMode = false } = {}) {
                 parentLoc.type !== 'root' &&
                 parentLoc.type !== 'failure' &&
                 parentLoc.type !== 'preprocessor') {
-                const parentInBefore = getModuleFromFlow(parentLoc.parentId, beforeFlow);
+                const parentInBefore = findModuleInFlow(beforeFlow.value, parentLoc.parentId) ?? undefined;
                 if (!parentInBefore) {
                     // Parent is missing in beforeFlow. It must be pending acceptance.
                     // Accept as skeleton to avoid auto-accepting all siblings.
@@ -229,13 +193,10 @@ export function createFlowDiffManager({ testMode = false } = {}) {
                 }
             }
             // Use insertModuleIntoFlow targeting beforeFlow, sourcing position from currentFlow
-            let module = getModuleFromFlow(actualId, {
-                value: currentFlow,
-                summary: ''
-            });
+            let module = findModuleInFlow(currentFlow, actualId) ?? undefined;
             if (module) {
                 // Check if module already exists in beforeFlow (could be a skeleton from earlier acceptance)
-                const existingModule = getModuleFromFlow(actualId, beforeFlow);
+                const existingModule = findModuleInFlow(beforeFlow.value, actualId) ?? undefined;
                 if (existingModule) {
                     // Module exists in beforeFlow - check if it's in the same location
                     const beforeLocation = findModuleParent(beforeFlow.value, actualId);
@@ -245,8 +206,7 @@ export function createFlowDiffManager({ testMode = false } = {}) {
                     if (sameLocation) {
                         // Module is in the same location, update it in-place
                         const moduleToApply = asSkeleton ? createSkeletonModule(module) : module;
-                        Object.keys(existingModule).forEach((k) => delete existingModule[k]);
-                        Object.assign(existingModule, $state.snapshot(moduleToApply));
+                        replaceFlowModule(existingModule, $state.snapshot(moduleToApply));
                     }
                     else {
                         // Module is being moved - insert at new location (the old copy will be removed when old__id is accepted)
@@ -263,14 +223,10 @@ export function createFlowDiffManager({ testMode = false } = {}) {
         }
         else if (info.action === 'modified') {
             // Modified: Apply modifications to beforeFlow module
-            const beforeModule = getModuleFromFlow(actualId, beforeFlow);
-            const afterModule = getModuleFromFlow(actualId, {
-                value: currentFlow,
-                summary: ''
-            });
+            const beforeModule = findModuleInFlow(beforeFlow.value, actualId) ?? undefined;
+            const afterModule = findModuleInFlow(currentFlow, actualId) ?? undefined;
             if (beforeModule && afterModule) {
-                Object.keys(beforeModule).forEach((k) => delete beforeModule[k]);
-                Object.assign(beforeModule, $state.snapshot(afterModule));
+                replaceFlowModule(beforeModule, $state.snapshot(afterModule));
             }
         }
     }
@@ -303,11 +259,11 @@ export function createFlowDiffManager({ testMode = false } = {}) {
             else if (info.action === 'removed') {
                 // Removed in after: Restore to flowStore (currentFlow)
                 // Source from beforeFlow
-                const oldModule = getModuleFromFlow(actualId, beforeFlow);
+                const oldModule = findModuleInFlow(beforeFlow.value, actualId) ?? undefined;
                 if (oldModule) {
                     // For type changes (old__ prefix), rename the new module to avoid ID conflict
                     if (id.startsWith(DUPLICATE_MODULE_PREFIX)) {
-                        const existingNew = getModuleFromFlow(actualId, flowStore.val);
+                        const existingNew = findModuleInFlow(flowStore.val.value, actualId) ?? undefined;
                         if (existingNew) {
                             existingNew.id = `${NEW_MODULE_PREFIX}${actualId}`;
                         }
@@ -318,11 +274,10 @@ export function createFlowDiffManager({ testMode = false } = {}) {
             }
             else if (info.action === 'modified') {
                 // Modified: Revert modifications in flowStore (currentFlow)
-                const oldModule = getModuleFromFlow(actualId, beforeFlow);
-                const newModule = getModuleFromFlow(actualId, flowStore.val);
+                const oldModule = findModuleInFlow(beforeFlow.value, actualId) ?? undefined;
+                const newModule = findModuleInFlow(flowStore.val.value, actualId) ?? undefined;
                 if (oldModule && newModule) {
-                    Object.keys(newModule).forEach((k) => delete newModule[k]);
-                    Object.assign(newModule, $state.snapshot(oldModule));
+                    replaceFlowModule(newModule, $state.snapshot(oldModule));
                 }
                 refreshStateStore(flowStore);
             }
@@ -391,20 +346,10 @@ export function createFlowDiffManager({ testMode = false } = {}) {
         }
         else {
             // Show module diff
-            const beforeModule = getModuleFromFlow(moduleId, beforeFlow);
-            // Need to check failure_module and preprocessor_module for currentFlow as well
-            let afterModule = undefined;
-            if (currentFlow) {
-                if (currentFlow.preprocessor_module?.id === moduleId) {
-                    afterModule = currentFlow.preprocessor_module;
-                }
-                else if (currentFlow.failure_module?.id === moduleId) {
-                    afterModule = currentFlow.failure_module;
-                }
-                else {
-                    afterModule = dfs(moduleId, { value: currentFlow, summary: '' }, false)[0];
-                }
-            }
+            const beforeModule = findModuleInFlow(beforeFlow.value, moduleId) ?? undefined;
+            const afterModule = currentFlow
+                ? (findModuleInFlow(currentFlow, moduleId) ?? undefined)
+                : undefined;
             if (beforeModule && afterModule) {
                 diffDrawer.openDrawer();
                 diffDrawer.setDiff({