Added src/blocks/utils/workspaces.ts, which contains functions related to keeping track of blockly workspaces.

Modified editor to call workspaces.addWorkspace and workspaces.removeWorkspace
Modified existing code that use headless blockly workspaces to call workspaces.createHeadlessWorkspace and workspaces.destroyHeadlessWorkspace.

Author: lizlooney

src/blocks/utils/workspaces.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author lizlooney@google.com (Liz Looney)
+ */
+
+import * as Blockly from 'blockly/core';
+import * as storageModule from '../../storage/module';
+
+const workspaceIdToModuleType: { [workspaceId: string]: storageModule.ModuleType } = {};
+
+export function addWorkspace(workspace: Blockly.Workspace, moduleType: storageModule.ModuleType): void {
+  workspaceIdToModuleType[workspace.id] = moduleType;
+}
+
+export function removeWorkspace(workspace: Blockly.Workspace): void {
+  if (workspace.id in workspaceIdToModuleType) {
+    delete workspaceIdToModuleType[workspace.id];
+  }
+}
+
+export function getModuleTypeForWorkspace(workspace: Blockly.Workspace): storageModule.ModuleType {
+  if (workspace.id in workspaceIdToModuleType) {
+    return workspaceIdToModuleType[workspace.id];
+  }
+  throw new Error('getModuleTypeForWorkspace: workspaceId not found: ' + workspace.id);
+}
+
+export function createHeadlessWorkspace(moduleType: storageModule.ModuleType): Blockly.Workspace {
+  const workspace = new Blockly.Workspace();
+  addWorkspace(workspace, moduleType);
+  return workspace;
+}
+
+export function destroyHeadlessWorkspace(workspace: Blockly.Workspace): void {
+  removeWorkspace(workspace);
+  workspace.dispose();
+}

src/editor/editor.ts

@@ -30,6 +30,7 @@ import * as storageProject from '../storage/project';
 import * as eventHandler from '../blocks/mrc_event_handler';
 import * as classMethodDef from '../blocks/mrc_class_method_def';
 import * as mechanismComponentHolder from '../blocks/mrc_mechanism_component_holder';
+import * as workspaces from '../blocks/utils/workspaces';
 //import { testAllBlocksInToolbox } from '../toolbox/toolbox_tests';
 import { applyExpandedCategories, getToolboxJSON } from '../toolbox/toolbox';
 
@@ -70,6 +71,7 @@ export class Editor {
       project: storageProject.Project,
       storage: commonStorage.Storage,
       modulePathToContentText: {[modulePath: string]: string}) {
+    workspaces.addWorkspace(blocklyWorkspace, module.moduleType);
     this.blocklyWorkspace = blocklyWorkspace;
     this.module = module;
     this.projectName = project.projectName;
@@ -186,6 +188,7 @@ export class Editor {
   }
 
   public abandon(): void {
+    workspaces.removeWorkspace(this.blocklyWorkspace);
     if (Editor.currentEditor === this) {
       Editor.currentEditor = null;
     }
@@ -250,7 +253,7 @@ export class Editor {
     if (toolbox != this.toolbox) {
       this.toolbox = toolbox;
       this.blocklyWorkspace.updateToolbox(toolbox);
-      // testAllBlocksInToolbox(toolbox);
+      // testAllBlocksInToolbox(toolbox, this.module.moduleType);
     }
   }
 

src/storage/create_python_files.ts

@@ -22,6 +22,7 @@
  */
 
 import * as Blockly from 'blockly/core';
+import * as workspaces from '../blocks/utils/workspaces';
 import { extendedPythonGenerator } from '../editor/extended_python_generator';
 import { Storage } from './common_storage';
 import { Module } from './module';
@@ -61,7 +62,7 @@ async function generatePythonForModule(module: Module, storage: Storage): Promis
     const moduleContent = parseModuleContentText(moduleContentText);
 
     // Create a headless workspace
-    const workspace = new Blockly.Workspace();
+    const workspace = workspaces.createHeadlessWorkspace(module.moduleType);
 
     // Parse and load the JSON into the workspace
     const blocks = moduleContent.getBlocks();
@@ -71,7 +72,7 @@ async function generatePythonForModule(module: Module, storage: Storage): Promis
     const pythonCode = extendedPythonGenerator.mrcWorkspaceToCode(workspace, module);
 
     // Clean up the workspace
-    workspace.dispose();
+    workspaces.destroyHeadlessWorkspace(workspace);
 
     return {
       moduleName: moduleName,

src/storage/module_content.ts

@@ -25,6 +25,7 @@ import * as storageNames from './names';
 import startingOpModeBlocks from '../modules/opmode_start.json';
 import startingMechanismBlocks from '../modules/mechanism_start.json';
 import startingRobotBlocks from '../modules/robot_start.json';
+import * as workspaces from '../blocks/utils/workspaces';
 
 export type MethodArg = {
   name: string,
@@ -253,7 +254,7 @@ export class ModuleContent {
 
     if (Object.keys(oldIdToNewId).length) {
       // Change the ids in the blocks.
-      const workspace = new Blockly.Workspace();
+      const workspace = workspaces.createHeadlessWorkspace(this.moduleType);
       Blockly.serialization.workspaces.load(this.blocks, workspace);
       workspace.getAllBlocks().forEach(block => {
         if ('mrcChangeIds' in block && typeof block.mrcChangeIds === "function") {
@@ -263,7 +264,7 @@ export class ModuleContent {
       this.blocks = Blockly.serialization.workspaces.save(workspace);
 
       // Clean up the workspace
-      workspace.dispose();
+      workspaces.destroyHeadlessWorkspace(workspace);
     }
   }
 }

src/storage/upgrade_project.ts

@@ -29,6 +29,7 @@ import * as storageModuleContent from './module_content';
 import * as storageNames from './names';
 import * as storageProject from './project';
 import { ClassMethodDefBlock, BLOCK_NAME as MRC_CLASS_METHOD_DEF_BLOCK_NAME } from '../blocks/mrc_class_method_def';
+import * as workspaces from '../blocks/utils/workspaces';
 
 export const NO_VERSION = '0.0.0';
 export const CURRENT_VERSION = '0.0.3';
@@ -82,14 +83,16 @@ async function upgradeFrom_001_to_002(
       // mrc_mechanism_component_holder block.
       const moduleContent = storageModuleContent.parseModuleContentText(moduleContentText);
       let blocks = moduleContent.getBlocks();
+
       // Create a temporary workspace to upgrade the blocks.
-      const headlessWorkspace = new Blockly.Workspace();
+      const headlessWorkspace = workspaces.createHeadlessWorkspace(storageModule.ModuleType.ROBOT);
+
       try {
         Blockly.serialization.workspaces.load(blocks, headlessWorkspace);
         mechanismComponentHolder.hidePrivateComponents(headlessWorkspace);
         blocks = Blockly.serialization.workspaces.save(headlessWorkspace);
       } finally {
-        headlessWorkspace.dispose();
+        workspaces.destroyHeadlessWorkspace(headlessWorkspace);
       }
       moduleContent.setBlocks(blocks);
       moduleContentText = moduleContent.getModuleContentText();
@@ -116,8 +119,9 @@ async function upgradeFrom_002_to_003(
       const moduleContent = storageModuleContent.parseModuleContentText(moduleContentText);
       let blocks = moduleContent.getBlocks();
 
-      // Create a temporary workspace to upgrade the blocks
-      const headlessWorkspace = new Blockly.Workspace();
+      // Create a temporary workspace to upgrade the blocks.
+      const headlessWorkspace = workspaces.createHeadlessWorkspace(storageModule.ModuleType.ROBOT);
+
       try {
         Blockly.serialization.workspaces.load(blocks, headlessWorkspace);
 
@@ -127,7 +131,7 @@ async function upgradeFrom_002_to_003(
         });
         blocks = Blockly.serialization.workspaces.save(headlessWorkspace);
       } finally {
-        headlessWorkspace.dispose();
+        workspaces.destroyHeadlessWorkspace(headlessWorkspace);
       }
 
       moduleContent.setBlocks(blocks);

src/toolbox/toolbox_tests.ts

@@ -22,13 +22,15 @@
 import * as Blockly from 'blockly/core';
 import { extendedPythonGenerator } from '../editor/extended_python_generator';
 import * as toolboxItems from './items';
+import * as storageModule from '../storage/module';
+import * as workspaces from '../blocks/utils/workspaces';
 
 // Tests
 
-export function testAllBlocksInToolbox(toolbox : Blockly.utils.toolbox.ToolboxInfo) {
-  const contents  = toolbox.contents;
+export function testAllBlocksInToolbox(toolbox : Blockly.utils.toolbox.ToolboxInfo, moduleType: storageModule.ModuleType) {
+  const contents = toolbox.contents;
   alert('Press OK to run tests on all blocks from the toolbox.');
-  const toolboxTestData = new ToolboxTestData(contents, () => {
+  const toolboxTestData = new ToolboxTestData(contents, moduleType, () => {
     alert('Completed tests on all blocks in the toolbox. See console for any errors.');
   });
   toolboxTestData.runTests();
@@ -40,9 +42,12 @@ class ToolboxTestData {
   jsonBlocks: toolboxItems.Block[];
   index: number;
 
-  constructor(contents: toolboxItems.ContentsType[] | undefined, onFinish: () => void) {
+  constructor(
+      contents: toolboxItems.ContentsType[] | undefined,
+      moduleType: storageModule.ModuleType,
+      onFinish: () => void) {
     this.onFinish = onFinish;
-    this.blocklyWorkspace = new Blockly.Workspace();
+    this.blocklyWorkspace = workspaces.createHeadlessWorkspace(moduleType);
     this.blocklyWorkspace.MAX_UNDO = 0;
     this.jsonBlocks = [];
     if (contents){
@@ -95,7 +100,7 @@ class ToolboxTestData {
     if (this.index < this.jsonBlocks.length) {
       setTimeout(this.testCallback.bind(this), 0);
     } else {
-      this.blocklyWorkspace.dispose();
+      workspaces.destroyHeadlessWorkspace(this.blocklyWorkspace);
       if (this.onFinish) {
         this.onFinish();
       }