Merge branch 'main' into pr_fix_manage

alan412 · web-flow · commit 19334647c43c · 2025-09-23T21:18:05.000-04:00
diff --git a/src/App.tsx b/src/App.tsx
@@ -368,6 +368,9 @@ const AppContent: React.FC<AppContentProps> = ({ project, setProject }): React.J
       await saveModule();
     }
     setCurrentModule(module);
+    if (module) {
+      setActiveTab(module.modulePath);
+    }
   };
 
   /** Handles toolbox settings modal close. */
diff --git a/src/blocks/mrc_call_python_function.ts b/src/blocks/mrc_call_python_function.ts
diff --git a/src/blocks/mrc_class_method_def.ts b/src/blocks/mrc_class_method_def.ts
@@ -322,6 +322,14 @@ const CLASS_METHOD_DEF = {
             this.mrcMethodId = oldIdToNewId[this.mrcMethodId];
         }
     },
+    upgrade_002_to_003: function(this: ClassMethodDefBlock) {
+        if (this.getFieldValue('NAME') === 'init') {
+            // Remove robot parameter from init method
+            const methodBlock = this as ClassMethodDefBlock;
+            let filteredParams: Parameter[] = methodBlock.mrcParameters.filter(param => param.name !== 'robot');
+            methodBlock.mrcParameters = filteredParams;
+        }
+    },
 };
 
 /**
@@ -447,6 +455,10 @@ export const pythonFromBlock = function (
         }
     }
 
+    if (generator.getModuleType() === storageModule.ModuleType.OPMODE && block.mrcPythonMethodName === '__init__') {
+        paramString = 'robot';
+    }
+
     if (params.length != 0) {
         block.mrcParameters.forEach((param) => {
             paramString += ', ' + param.name;
diff --git a/src/blocks/mrc_event_handler.ts b/src/blocks/mrc_event_handler.ts
@@ -176,6 +176,13 @@ const EVENT_HANDLER = {
    * workspace.
    */
   mrcOnLoad: function(this: EventHandlerBlock): void {
+    this.mrcValidate();
+  },
+  /**
+   * mrcValidate checks the block, updates it, and/or adds a warning balloon if necessary.
+   * It is called from mrcOnLoad above and from Editor.makeCurrent.
+   */
+  mrcValidate: function(this: EventHandlerBlock): void {
     const warnings: string[] = [];
 
     const editor = Editor.getEditorForBlocklyWorkspace(this.workspace, true /* returnCurrentIfNotFound */);
diff --git a/src/blocks/mrc_mechanism.ts b/src/blocks/mrc_mechanism.ts
@@ -174,8 +174,19 @@ const MECHANISM = {
       className: mechanismType,
     };
   },
+
+  /**
+   * mrcOnLoad is called for each MechanismBlock when the blocks are loaded in the blockly
+   * workspace.
+   */
   mrcOnLoad: function(this: MechanismBlock): void {
-    // mrcOnLoad is called for each MechanismBlock when the blocks are loaded in the blockly workspace.
+    this.mrcValidate();
+  },
+  /**
+   * mrcValidate checks the block, updates it, and/or adds a warning balloon if necessary.
+   * It is called from mrcOnLoad above and from Editor.makeCurrent.
+   */
+  mrcValidate: function(this: MechanismBlock): void {
     const warnings: string[] = [];
 
     const editor = Editor.getEditorForBlocklyWorkspace(this.workspace, true /* returnCurrentIfNotFound */);
diff --git a/src/blocks/tokens.ts b/src/blocks/tokens.ts
@@ -61,6 +61,29 @@ export function customTokens(t: (key: string) => string): typeof Blockly.Msg {
     OPMODE_ENABLED_TOOLTIP: t('BLOCKLY.TOOLTIP.OPMODE_ENABLED'),
     OPMODE_NAME_TOOLTIP: t('BLOCKLY.TOOLTIP.OPMODE_NAME'),
     OPMODE_GROUP_TOOLTIP: t('BLOCKLY.TOOLTIP.OPMODE_GROUP'),
+    CALL: t('BLOCKLY.CALL'),
+    ROBOT_LOWER_CASE: t('BLOCKLY.ROBOT_LOWER_CASE'),
+    CREATE: t('BLOCKLY.CREATE'),
+    FIRE: t('BLOCKLY.FIRE'),
+    WARNING_CALL_COMPONENT_INSTANCE_METHOD_PRIVATE_COMPONENT: t('BLOCKLY.WARNING.CALL_COMPONENT_INSTANCE_METHOD_PRIVATE_COMPONENT'),
+    WARNING_CALL_COMPONENT_INSTANCE_METHOD_MISSING_COMPONENT: t('BLOCKLY.WARNING.CALL_COMPONENT_INSTANCE_METHOD_MISSING_COMPONENT'),
+    WARNING_CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_MISSING_MECHANISM: t('BLOCKLY.WARNING.CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_MISSING_MECHANISM'),
+    WARNING_CALL_ROBOT_INSTANCE_METHOD_INSIDE_MECHANISM: t('BLOCKLY.WARNING.CALL_ROBOT_INSTANCE_METHOD_INSIDE_MECHANISM'),
+    WARNING_CALL_ROBOT_INSTANCE_METHOD_MISSING_METHOD: t('BLOCKLY.WARNING.CALL_ROBOT_INSTANCE_METHOD_MISSING_METHOD'),
+    WARNING_CALL_MECHANISM_INSTANCE_METHOD_INSIDE_MECHANISM: t('BLOCKLY.WARNING.CALL_MECHANISM_INSTANCE_METHOD_INSIDE_MECHANISM'),
+    WARNING_CALL_MECHANISM_INSTANCE_METHOD_MISSING_METHOD: t('BLOCKLY.WARNING.CALL_MECHANISM_INSTANCE_METHOD_MISSING_METHOD'),
+    WARNING_CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM: t('BLOCKLY.WARNING.CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM'),
+    CALL_BUILTIN_FUNCTION_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_BUILTIN_FUNCTION'),
+    CALL_MODULE_FUNCTION_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_MODULE_FUNCTION'),
+    CALL_STATIC_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_STATIC_METHOD'),
+    CALL_CONSTRUCTOR_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_CONSTRUCTOR'),
+    CALL_INSTANCE_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_INSTANCE_METHOD'),
+    CALL_INSTANCE_METHOD_WITHIN_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_INSTANCE_METHOD_WITHIN'),
+    FIRE_EVENT_TOOLTIP: t('BLOCKLY.TOOLTIP.FIRE_EVENT'),
+    CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_MECHANISM_COMPONENT_INSTANCE_METHOD'),
+    CALL_COMPONENT_INSTANCE_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_COMPONENT_INSTANCE_METHOD'),
+    CALL_ROBOT_INSTANCE_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_ROBOT_INSTANCE_METHOD'),
+    CALL_MECHANISM_INSTANCE_METHOD_TOOLTIP: t('BLOCKLY.TOOLTIP.CALL_MECHANISM_INSTANCE_METHOD'),
     MRC_CATEGORY_HARDWARE: t('BLOCKLY.CATEGORY.HARDWARE'),
     MRC_CATEGORY_ROBOT: t('BLOCKLY.CATEGORY.ROBOT'),
     MRC_CATEGORY_COMPONENTS: t('BLOCKLY.CATEGORY.COMPONENTS'),
diff --git a/src/editor/editor.ts b/src/editor/editor.ts
@@ -38,6 +38,9 @@ const EMPTY_TOOLBOX: Blockly.utils.toolbox.ToolboxDefinition = {
   contents: [],
 };
 
+const MRC_ON_LOAD = 'mrcOnLoad';
+const MRC_VALIDATE = 'mrcValidate';
+
 export class Editor {
   private static workspaceIdToEditor: { [workspaceId: string]: Editor } = {};
   private static currentEditor: Editor | null = null;
@@ -97,8 +100,8 @@ export class Editor {
         blockCreateEvent.ids.forEach(id => {
           const block = this.blocklyWorkspace.getBlockById(id);
           if (block) {
-            if ('mrcOnLoad' in block && typeof block.mrcOnLoad === "function") {
-              block.mrcOnLoad();
+            if (MRC_ON_LOAD in block && typeof block[MRC_ON_LOAD] === 'function') {
+              block[MRC_ON_LOAD]();
             }
           }
         });
@@ -129,6 +132,13 @@ export class Editor {
     // Parse modules since they might have changed.
     this.parseModules(project, modulePathToContentText);
     this.updateToolboxImpl();
+
+    // Go through all the blocks in the workspace and call their mrcValidate method.
+    this.blocklyWorkspace.getAllBlocks().forEach(block => {
+      if (MRC_VALIDATE in block && typeof block[MRC_VALIDATE] === 'function') {
+        block[MRC_VALIDATE]();
+      }
+    });
   }
 
   public abandon(): void {
@@ -158,8 +168,8 @@ export class Editor {
     for (const mechanism of this.mechanisms) {
       const moduleContent = this.modulePathToModuleContent[mechanism.modulePath];
       if (!moduleContent) {
-        console.error(this.modulePath + " editor.parseModules - modulePathToModuleContent['" +
-            mechanism.modulePath + "'] is undefined");
+        console.error(this.modulePath + ' editor.parseModules - modulePathToModuleContent["' +
+            mechanism.modulePath + '"] is undefined');
         continue;
       }
       this.mechanismClassNameToModuleContent[mechanism.className] = moduleContent;
@@ -441,7 +451,7 @@ export class Editor {
   }
 
   /**
-   * Returns the components defined in the given mechanism.
+   * Returns the regular components defined in the given mechanism.
    */
   public getComponentsFromMechanism(mechanism: storageModule.Mechanism): storageModuleContent.Component[] {
     if (this.module.modulePath === mechanism.modulePath) {
@@ -453,6 +463,19 @@ export class Editor {
     throw new Error('getComponentsFromMechanism: mechanism not found: ' + mechanism.className);
   }
 
+  /**
+   * Returns the private components defined in the given mechanism.
+   */
+  public getPrivateComponentsFromMechanism(mechanism: storageModule.Mechanism): storageModuleContent.Component[] {
+    if (this.module.modulePath === mechanism.modulePath) {
+      return this.getPrivateComponentsFromWorkspace();
+    }
+    if (mechanism.className in this.mechanismClassNameToModuleContent) {
+      return this.mechanismClassNameToModuleContent[mechanism.className].getPrivateComponents();
+    }
+    throw new Error('getPrivateComponentsFromMechanism: mechanism not found: ' + mechanism.className);
+  }
+
   /**
    * Returns ALL components (including private components) defined in the given mechanism.
    * This is used when creating mechanism blocks that need all components for port parameters.
diff --git a/src/i18n/locales/en/translation.json b/src/i18n/locales/en/translation.json
@@ -81,6 +81,10 @@
         "DISPLAY_GROUP": "Display Group",
         "PRINT": "print",
         "NO_MECHANISM_CONTENTS": "No Mechanism Contents",
+        "CALL": "call",
+        "ROBOT": "robot",
+        "CREATE": "create",
+        "FIRE": "fire",
         "TOOLTIP":{
             "EVALUATE_BUT_IGNORE_RESULT": "Executes the connected block and ignores the result.  Allows you to call a function and ignore the return value.",
             "NONE": "Returns None.",
@@ -89,7 +93,18 @@
             "OPMODE_NAME": "The name shown on the Driver Station.  If blank will use the class name.",
             "OPMODE_GROUP": "An optional group to group OpModes on Driver Station",
             "COMPONENTS": "These components are visible in this mechanism, the robot, and all opmodes.",
-            "PRIVATE_COMPONENTS": "These components will not be visible in the robot or opmodes. They are only accessible within this mechanism."
+            "PRIVATE_COMPONENTS": "These components will not be visible in the robot or opmodes. They are only accessible within this mechanism.",
+            "CALL_BUILTIN_FUNCTION": "Calls the builtin function {{functionName}}.",
+            "CALL_MODULE_FUNCTION": "Calls the module function {{moduleName}}.{{functionName}}.",
+            "CALL_STATIC_METHOD": "Calls the static method {{className}}.{{functionName}}.",
+            "CALL_CONSTRUCTOR": "Constructs an instance of the class {{className}}.",
+            "CALL_INSTANCE_METHOD": "Calls the instance method {{className}}.{{functionName}}.",
+            "CALL_INSTANCE_METHOD_WITHIN": "Calls the instance method {{functionName}}.",
+            "FIRE_EVENT": "Fires the event named {{eventName}}.",
+            "CALL_MECHANISM_COMPONENT_INSTANCE_METHOD": "Calls the instance method {{className}}.{{functionName}} on the component named {{componentName}} in the mechanism named {{mechanismName}}.",
+            "CALL_COMPONENT_INSTANCE_METHOD": "Calls the instance method {{className}}.{{functionName}} on the component named {{componentName}}.",
+            "CALL_ROBOT_INSTANCE_METHOD": "Calls the robot method {{functionName}}.",
+            "CALL_MECHANISM_INSTANCE_METHOD": "Calls the instance method {{className}}.{{functionName}} on the mechanism named {{mechanismName}}."
         },
         "CATEGORY":{
             "LISTS": "Lists",
@@ -109,6 +124,16 @@
             "ADD_COMPONENT": "+ Component",
             "TEST": "Test",
             "PAGINATION_TOTAL": "{{start}}-{{end}} of {{total}} items"
+        },
+        "WARNING":{
+            "CALL_COMPONENT_INSTANCE_METHOD_PRIVATE_COMPONENT": "This blocks calls a method on a private component in the {{mechanismClassName}} mechanism.",
+            "CALL_COMPONENT_INSTANCE_METHOD_MISSING_COMPONENT": "This block calls a method on a component that no longer exists.",
+            "CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_MISSING_MECHANISM": "This block calls a method on a component that belongs to a mechanism that no longer exists.",
+            "CALL_ROBOT_INSTANCE_METHOD_INSIDE_MECHANISM": "This block is not allowed to be used inside a mechanism.",
+            "CALL_ROBOT_INSTANCE_METHOD_MISSING_METHOD": "This block calls a method that no longer exists in the robot.",
+            "CALL_MECHANISM_INSTANCE_METHOD_INSIDE_MECHANISM": "This block is not allowed to be used inside a mechanism.",
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_METHOD": "This block calls a method that no longer exists in the mechanism.",
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM": "This block calls a method in a mechanism that no longer exists."
         }
     }   
 }
diff --git a/src/i18n/locales/es/translation.json b/src/i18n/locales/es/translation.json
@@ -82,6 +82,10 @@
         "DISPLAY_GROUP": "Grupo a Mostrar",
         "PRINT": "imprimir",
         "NO_MECHANISM_CONTENTS": "Sin Contenido de Mecanismo",
+        "CALL": "llamar",
+        "ROBOT": "robot",
+        "CREATE": "crear",
+        "FIRE": "disparar",
         "TOOLTIP": {
             "EVALUATE_BUT_IGNORE_RESULT": "Ejecuta el bloque conectado e ignora el resultado. Te permite llamar una función e ignorar el valor de retorno.",
             "NONE": "No devuelve ninguno.",
@@ -90,7 +94,18 @@
             "OPMODE_NAME": "El nombre mostrado en la Estación del Conductor. Si está en blanco usará el nombre de la clase.",
             "OPMODE_GROUP": "Un grupo opcional para agrupar OpModes en la Estación del Conductor",
             "COMPONENTS": "Estos componentes son visibles en este mecanismo, el robot y todos los opmodes.",
-            "PRIVATE_COMPONENTS": "Estos componentes no serán visibles en el robot o en los opmodes. Solo son accesibles dentro de este mecanismo."
+            "PRIVATE_COMPONENTS": "Estos componentes no serán visibles en el robot o en los opmodes. Solo son accesibles dentro de este mecanismo.",
+            "CALL_BUILTIN_FUNCTION": "Llama a la función incorporada {{functionName}}.",
+            "CALL_MODULE_FUNCTION": "Llama a la función del módulo {{moduleName}}.{{functionName}}.",
+            "CALL_STATIC_METHOD": "Llama al método estático {{className}}.{{functionName}}.",
+            "CALL_CONSTRUCTOR": "Construye una instancia de la clase {{className}}.",
+            "CALL_INSTANCE_METHOD": "Llama al método de instancia {{className}}.{{functionName}}.",
+            "CALL_INSTANCE_METHOD_WITHIN": "Llama al método de instancia {{functionName}}.",
+            "FIRE_EVENT": "Dispara el evento llamado {{eventName}}.",
+            "CALL_MECHANISM_COMPONENT_INSTANCE_METHOD": "Llama al método de instancia {{className}}.{{functionName}} en el componente llamado {{componentName}} en el mecanismo llamado {{mechanismName}}.",
+            "CALL_COMPONENT_INSTANCE_METHOD": "Llama al método de instancia {{className}}.{{functionName}} en el componente llamado {{componentName}}.",
+            "CALL_ROBOT_INSTANCE_METHOD": "Llama al método robot {{functionName}}.",
+            "CALL_MECHANISM_INSTANCE_METHOD": "Llama al método de instancia {{className}}.{{functionName}} en el mecanismo llamado {{mechanismName}}."
         },
         "CATEGORY": {
             "LISTS": "Listas",
@@ -110,6 +125,16 @@
             "ADD_COMPONENT": "+ Componente",
             "TEST": "Prueba",
             "PAGINATION_TOTAL": "{{start}}-{{end}} de {{total}} elementos"
+        },
+        "WARNING":{
+            "CALL_COMPONENT_INSTANCE_METHOD_PRIVATE_COMPONENT": "Este bloque llama a un método en un componente privado en el mecanismo {{mechanismClassName}}.",
+            "CALL_COMPONENT_INSTANCE_METHOD_MISSING_COMPONENT": "Este bloque llama a un método en un componente que ya no existe.",
+            "CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_MISSING_MECHANISM": "Este bloque llama a un método de un componente que pertenece a un mecanismo que ya no existe.",
+            "CALL_ROBOT_INSTANCE_METHOD_INSIDE_MECHANISM": "No se permite utilizar este bloque dentro de un mecanismo.",
+            "CALL_ROBOT_INSTANCE_METHOD_MISSING_METHOD": "Este bloque llama a un método que ya no existe en el robot.",
+            "CALL_MECHANISM_INSTANCE_METHOD_INSIDE_MECHANISM": "No se permite utilizar este bloque dentro de un mecanismo.",
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_METHOD": "Este bloque llama a un método que ya no existe en el mecanismo.",
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM": "Este bloque llama a un método en un mecanismo que ya no existe."
         }
     }
 }
diff --git a/src/i18n/locales/he/translation.json b/src/i18n/locales/he/translation.json
@@ -81,6 +81,10 @@
         "DISPLAY_GROUP": "קבוצת תצוגה",
         "PRINT": "הדפס",
         "NO_MECHANISM_CONTENTS": "אין תוכן מנגנון",
+        "CALL": "שִׂיחָה",
+        "ROBOT": "רובוט",
+        "CREATE": "לִיצוֹר",
+        "FIRE": "לִגרוֹם",
         "TOOLTIP":{
             "EVALUATE_BUT_IGNORE_RESULT": "מריץ את הבלוק המחובר ומתעלם מהתוצאה. מאפשר לך לקרוא לפונקציה ולהתעלם מערך ההחזרה.",
             "NONE": "החזרות אין.",
@@ -89,7 +93,18 @@
             "OPMODE_NAME": "השם המוצג בתחנת הנהג. אם ריק ישתמש בשם הכיתה.",
             "OPMODE_GROUP": "קבוצה אופציונלית לקיבוץ מצבי פעולה בתחנת הנהג",
             "COMPONENTS": "רכיבים אלה גלויים במנגנון זה, ברובוט ובכל מצבי הפעולה.",
-            "PRIVATE_COMPONENTS": "רכיבים אלה לא יהיו גלויים ברובוט או במצבי פעולה. הם נגישים רק בתוך המנגנון הזה."
+            "PRIVATE_COMPONENTS": "רכיבים אלה לא יהיו גלויים ברובוט או במצבי פעולה. הם נגישים רק בתוך המנגנון הזה.",
+            "CALL_BUILTIN_FUNCTION": "קורא לפונקציה המובנית {{functionName}}.",
+            "CALL_MODULE_FUNCTION": "קורא לפונקציית המודול {{moduleName}}.{{functionName}}.",
+            "CALL_STATIC_METHOD": "קורא למתודה הסטטית {{className}}.{{functionName}}.",
+            "CALL_CONSTRUCTOR": "בונה מופע של המחלקה {{className}}.",
+            "CALL_INSTANCE_METHOD": "קורא למתודה {{className}}.{{functionName}}.",
+            "CALL_INSTANCE_METHOD_WITHIN": "קורא למתודה {{functionName}}.",
+            "FIRE_EVENT": "מפעיל את האירוע בשם {{eventName}}.",
+            "CALL_MECHANISM_COMPONENT_INSTANCE_METHOD": "קורא למתודה {{className}}.{{functionName}} על הרכיב בשם {{componentName}} במנגנון בשם {{mechanismName}}.",
+            "CALL_COMPONENT_INSTANCE_METHOD": "קורא למתודה {{className}}.{{functionName}} על הרכיב בשם {{componentName}}.",
+            "CALL_ROBOT_INSTANCE_METHOD": "קורא למתודה הרובוטית {{functionName}}.",
+            "CALL_MECHANISM_INSTANCE_METHOD": "קורא למתודה {{className}}.{{functionName}} במנגנון בשם {{mechanismName}}."
         },
         "CATEGORY":{
             "LISTS": "רשימות",
@@ -109,6 +124,16 @@
             "ADD_COMPONENT": "+ רכיב",
             "TEST": "בדיקה",
             "PAGINATION_TOTAL": "{{start}}-{{end}} מתוך {{total}} פריטים"
+        },
+        "WARNING":{
+            "CALL_COMPONENT_INSTANCE_METHOD_PRIVATE_COMPONENT": "פעולה זו חוסם קריאה למתודה על רכיב פרטי במנגנון {{mechanismClassName}}.",
+            "CALL_COMPONENT_INSTANCE_METHOD_MISSING_COMPONENT": "בלוק זה קורא למתודה על רכיב שכבר אינו קיים.",
+            "CALL_MECHANISM_COMPONENT_INSTANCE_METHOD_MISSING_MECHANISM": "בלוק זה קורא למתודה על רכיב השייך למנגנון שכבר אינו קיים.",
+            "CALL_ROBOT_INSTANCE_METHOD_INSIDE_MECHANISM": "אסור להשתמש בבלוק זה בתוך מנגנון.",
+            "CALL_ROBOT_INSTANCE_METHOD_MISSING_METHOD": "בלוק זה קורא למתודה שכבר לא קיימת ברובוט.",
+            "CALL_MECHANISM_INSTANCE_METHOD_INSIDE_MECHANISM": "אסור להשתמש בבלוק זה בתוך מנגנון.",
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_METHOD": "בלוק זה קורא לשיטה שכבר אינה קיימת במנגנון.",
+            "CALL_MECHANISM_INSTANCE_METHOD_MISSING_MECHANISM": "בלוק זה קורא לשיטה במנגנון שכבר אינו קיים."
         }
     }   
 }
diff --git a/src/modules/opmode_start.json b/src/modules/opmode_start.json
diff --git a/src/storage/project.ts b/src/storage/project.ts
diff --git a/src/storage/upgrade_project.ts b/src/storage/upgrade_project.ts

Original file line number	Diff line number	Diff line change
`@@ -368,6 +368,9 @@ const AppContent: React.FC<AppContentProps> = ({ project, setProject }): React.J`
`368`	`368`	`await saveModule();`
`369`	`369`	`}`
`370`	`370`	`setCurrentModule(module);`
	`371`	`+ if (module) {`
	`372`	`+ setActiveTab(module.modulePath);`
	`373`	`+ }`
`371`	`374`	`};`
`372`	`375`
`373`	`376`	`/** Handles toolbox settings modal close. */`