@2112-lab/central-plant 0.1.19 → 0.1.21

package/dist/bundle/index.js

@@ -21447,7 +21447,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
             case 0:
               component = this.sceneViewer;
               _context6.p = 1;
-              defaultCentralPlantUrl = './mock-data/cp-01-01.json';
+              defaultCentralPlantUrl = process.env.DEFAULT_CENTRAL_PLANT_URL;
               _context6.n = 2;
               return fetch(defaultCentralPlantUrl);
             case 2:
@@ -21600,6 +21600,115 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       });
     }
 
+    /**
+     * Add a new component to the scene data
+     * @param {Object} componentModel - The Three.js component model that was added to the scene
+     * @param {Object} currentSceneData - The current scene data structure
+     * @returns {boolean} True if the component was successfully added to scene data
+     */
+  }, {
+    key: "addComponentToSceneData",
+    value: function addComponentToSceneData(componentModel, currentSceneData) {
+      if (!componentModel || !currentSceneData) {
+        console.error('❌ addComponentToSceneData: Missing componentModel or currentSceneData');
+        return false;
+      }
+      if (!currentSceneData.scene || !currentSceneData.scene.object) {
+        console.error('❌ addComponentToSceneData: Invalid scene data structure');
+        return false;
+      }
+      try {
+        var _componentModel$userD;
+        // Calculate world bounding box for the component
+        var boundingBox = new THREE__namespace.Box3().setFromObject(componentModel);
+
+        // Create scene data entry for the new component
+        var componentSceneData = {
+          uuid: componentModel.uuid,
+          name: componentModel.name,
+          type: 'Group',
+          matrix: componentModel.matrix.elements,
+          position: {
+            x: componentModel.position.x,
+            y: componentModel.position.y,
+            z: componentModel.position.z
+          },
+          rotation: {
+            x: componentModel.rotation.x,
+            y: componentModel.rotation.y,
+            z: componentModel.rotation.z
+          },
+          scale: {
+            x: componentModel.scale.x,
+            y: componentModel.scale.y,
+            z: componentModel.scale.z
+          },
+          userData: _objectSpread2(_objectSpread2({}, componentModel.userData), {}, {
+            worldBoundingBox: {
+              min: boundingBox.min.toArray(),
+              max: boundingBox.max.toArray()
+            }
+          }),
+          children: []
+        };
+
+        // Process children (connectors, etc.) if they exist
+        if (componentModel.children && componentModel.children.length > 0) {
+          componentModel.children.forEach(function (child) {
+            var _child$userData17;
+            if (((_child$userData17 = child.userData) === null || _child$userData17 === void 0 ? void 0 : _child$userData17.componentType) === 'connector') {
+              var _child$geometry5;
+              var childBoundingBox = new THREE__namespace.Box3().setFromObject(child);
+              var childSceneData = {
+                uuid: child.uuid,
+                name: child.name,
+                type: child.type,
+                position: {
+                  x: child.position.x,
+                  y: child.position.y,
+                  z: child.position.z
+                },
+                rotation: {
+                  x: child.rotation.x,
+                  y: child.rotation.y,
+                  z: child.rotation.z
+                },
+                scale: {
+                  x: child.scale.x,
+                  y: child.scale.y,
+                  z: child.scale.z
+                },
+                userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
+                  worldBoundingBox: {
+                    min: childBoundingBox.min.toArray(),
+                    max: childBoundingBox.max.toArray()
+                  }
+                }),
+                geometry: ((_child$geometry5 = child.geometry) === null || _child$geometry5 === void 0 ? void 0 : _child$geometry5.uuid) || 'CONNECTOR-GEO'
+              };
+              componentSceneData.children.push(childSceneData);
+            }
+          });
+        }
+
+        // Add the component to the scene data
+        if (!currentSceneData.scene.object.children) {
+          currentSceneData.scene.object.children = [];
+        }
+        currentSceneData.scene.object.children.push(componentSceneData);
+        console.log('✅ addComponentToSceneData: Component added to scene data successfully', {
+          componentId: componentModel.uuid,
+          libraryId: (_componentModel$userD = componentModel.userData) === null || _componentModel$userD === void 0 ? void 0 : _componentModel$userD.libraryId,
+          childrenCount: componentSceneData.children.length,
+          totalSceneChildren: currentSceneData.scene.object.children.length
+        });
+        return true;
+      } catch (error) {
+        console.error('❌ addComponentToSceneData: Error adding component to scene data:', error);
+        return false;
+      }
+    }
+
     /**
      * Update scene data after object transform
      */
@@ -21621,9 +21730,9 @@ var SceneOperationsManager = /*#__PURE__*/function () {
 
         // Also update the corresponding scene data object
         for (var i = 0; i < currentSceneData.scene.object.children.length; i++) {
-          var _object$userData4, _child$userData17;
+          var _object$userData4, _child$userData18;
           var child = currentSceneData.scene.object.children[i];
-          if (child.uuid === object.uuid || child.uuid === ((_object$userData4 = object.userData) === null || _object$userData4 === void 0 ? void 0 : _object$userData4.originalUuid) || object.uuid === ((_child$userData17 = child.userData) === null || _child$userData17 === void 0 ? void 0 : _child$userData17.originalUuid)) {
+          if (child.uuid === object.uuid || child.uuid === ((_object$userData4 = object.userData) === null || _object$userData4 === void 0 ? void 0 : _object$userData4.originalUuid) || object.uuid === ((_child$userData18 = child.userData) === null || _child$userData18 === void 0 ? void 0 : _child$userData18.originalUuid)) {
             if (!child.userData) child.userData = {};
             child.userData.origin = 'declared';
             break;
@@ -21672,20 +21781,20 @@ var SceneOperationsManager = /*#__PURE__*/function () {
 
       // Update the corresponding child in currentSceneData with the transformed object
       var _loop = function _loop() {
-        var _object$userData6, _child$userData18, _object$userData7, _child$userData19;
+        var _object$userData6, _child$userData19, _object$userData7, _child$userData20;
         var child = currentSceneData.scene.object.children[_i2];
         console.log("onTransformEnd child.uuid:", child.uuid);
         // Enhanced matching logic with hardcoded UUID priority
         var isMatch = false;
 
         // Strategy 1: Direct hardcoded UUID match (HIGHEST PRIORITY)
-        if (child.uuid === object.uuid || child.uuid === ((_object$userData6 = object.userData) === null || _object$userData6 === void 0 ? void 0 : _object$userData6.originalUuid) || object.uuid === ((_child$userData18 = child.userData) === null || _child$userData18 === void 0 ? void 0 : _child$userData18.originalUuid)) {
+        if (child.uuid === object.uuid || child.uuid === ((_object$userData6 = object.userData) === null || _object$userData6 === void 0 ? void 0 : _object$userData6.originalUuid) || object.uuid === ((_child$userData19 = child.userData) === null || _child$userData19 === void 0 ? void 0 : _child$userData19.originalUuid)) {
           isMatch = true;
           console.log('🎯 Matched by hardcoded UUID');
         }
 
         // Strategy 4: Component type and library ID match
-        if (!isMatch && (_object$userData7 = object.userData) !== null && _object$userData7 !== void 0 && _object$userData7.libraryId && (_child$userData19 = child.userData) !== null && _child$userData19 !== void 0 && _child$userData19.libraryId && object.userData.libraryId === child.userData.libraryId) {
+        if (!isMatch && (_object$userData7 = object.userData) !== null && _object$userData7 !== void 0 && _object$userData7.libraryId && (_child$userData20 = child.userData) !== null && _child$userData20 !== void 0 && _child$userData20.libraryId && object.userData.libraryId === child.userData.libraryId) {
           // For library components, also check position similarity
           var positionTolerance = 1.0; // Larger tolerance for main components
           if (child.position && object.position) {
@@ -26482,6 +26591,615 @@ var CentralPlant = /*#__PURE__*/function () {
     value: function getUtility(utilityName) {
       return this.utilities[utilityName] || null;
     }
+
+    /**
+     * Translate a component by a specified value along a given axis
+     * @param {string} componentId - The UUID or identifier of the component to translate
+     * @param {string} axis - The axis to translate along ('x', 'y', or 'z')
+     * @param {number} value - The value to translate by (can be positive or negative)
+     * @returns {Object|false} The component object if translation was successful, false otherwise
+     */
+  }, {
+    key: "translate",
+    value: function translate(componentId, axis, value) {
+      // Validate input parameters
+      if (!componentId || typeof componentId !== 'string') {
+        console.error('❌ translate(): Invalid componentId provided:', componentId);
+        return false;
+      }
+      if (!['x', 'y', 'z'].includes(axis.toLowerCase())) {
+        console.error('❌ translate(): Invalid axis provided. Must be "x", "y", or "z":', axis);
+        return false;
+      }
+      if (typeof value !== 'number' || isNaN(value)) {
+        console.error('❌ translate(): Invalid value provided. Must be a number:', value);
+        return false;
+      }
+
+      // Check if scene viewer is available
+      if (!this.sceneViewer || !this.sceneViewer.scene) {
+        console.error('❌ translate(): Scene viewer or scene not available');
+        return false;
+      }
+
+      // Find the component in the scene
+      var component = this.utilities.findObjectByHardcodedUuid(this.sceneViewer.scene, componentId);
+      if (!component) {
+        console.error("\u274C translate(): Component not found with ID: ".concat(componentId));
+        return false;
+      }
+
+      // Verify this is a valid component that can be translated
+      if (!component.userData || !component.userData.componentType) {
+        console.warn("\u26A0\uFE0F translate(): Object found but may not be a valid component: ".concat(componentId));
+      }
+
+      // Store previous transform values for undo functionality
+      var previousValues = {
+        position: component.position.clone(),
+        rotation: component.rotation.clone(),
+        scale: component.scale.clone()
+      };
+
+      // Perform the translation
+      var normalizedAxis = axis.toLowerCase();
+      var previousPosition = component.position[normalizedAxis];
+      try {
+        // Apply the translation
+        component.position[normalizedAxis] += value;
+
+        // Force update the component's matrices
+        component.updateMatrix();
+        component.updateMatrixWorld(true);
+
+        // Update world bounding box if the component has an associated JSON object
+        if (component.userData.associatedJsonObject) {
+          var worldBoundingBox = new THREE__namespace.Box3().setFromObject(component);
+          component.userData.associatedJsonObject.userData.worldBoundingBox = {
+            min: worldBoundingBox.min.toArray(),
+            max: worldBoundingBox.max.toArray()
+          };
+        }
+
+        // Record this transform operation in history
+        this.recordTransform({
+          type: 'translate',
+          object: component,
+          values: {
+            position: component.position.clone(),
+            rotation: component.rotation.clone(),
+            scale: component.scale.clone()
+          },
+          previousValues: previousValues,
+          axis: normalizedAxis,
+          translationValue: value
+        });
+
+        // Emit transform event if the scene viewer supports it
+        if (this.sceneViewer.emit && typeof this.sceneViewer.emit === 'function') {
+          this.sceneViewer.emit('transform-update', {
+            componentId: componentId,
+            component: component,
+            type: 'translate',
+            axis: normalizedAxis,
+            value: value,
+            newPosition: {
+              x: component.position.x,
+              y: component.position.y,
+              z: component.position.z
+            }
+          });
+          this.sceneViewer.emit('scene-changed', {
+            action: 'translate',
+            componentId: componentId,
+            axis: normalizedAxis,
+            value: value
+          });
+        }
+
+        // If there's a scene operations manager, update scene data
+        if (this.sceneViewer.sceneOperationsManager && this.sceneViewer.currentSceneData) {
+          this.sceneViewer.sceneOperationsManager.updateSceneDataAfterTransform(component, this.sceneViewer.currentSceneData);
+        }
+
+        // if (this.sceneViewer.shouldUpdatePaths && this.sceneViewer.updatePaths) {
+        //   this.sceneViewer.updatePaths()
+        // }
+
+        // // Update scene data and paths after successful translation
+        // this.updatePaths(component)
+
+        // Log successful translation
+        console.log("\u2705 translate(): Component ".concat(componentId, " translated ").concat(value, " units along ").concat(normalizedAxis.toUpperCase(), "-axis"), {
+          componentId: componentId,
+          axis: normalizedAxis,
+          value: value,
+          previousPosition: previousPosition,
+          newPosition: component.position[normalizedAxis],
+          totalPosition: {
+            x: component.position.x.toFixed(3),
+            y: component.position.y.toFixed(3),
+            z: component.position.z.toFixed(3)
+          }
+        });
+        return component;
+      } catch (error) {
+        console.error("\u274C translate(): Error translating component ".concat(componentId, ":"), error);
+
+        // Attempt to restore previous position on error
+        try {
+          component.position.copy(previousValues.position);
+          component.updateMatrix();
+          component.updateMatrixWorld(true);
+          console.log('🔄 translate(): Restored previous position after error');
+        } catch (restoreError) {
+          console.error('❌ translate(): Failed to restore previous position:', restoreError);
+        }
+        return false;
+      }
+    }
+
+    /**
+     * Add a new component to the scene using its library ID
+     * @param {string} libraryId - The library identifier for the component type (e.g., 'PUMP', 'CHILLER', 'COOLING-TOWER')
+     * @param {Object} options - Optional configuration for the new component
+     * @param {Object} options.position - Initial position for the component (default: random position within scene bounds)
+     * @param {Object} options.rotation - Initial rotation for the component (default: no rotation)
+     * @param {Object} options.scale - Initial scale for the component (default: 1.0 on all axes)
+     * @param {string} options.customId - Custom identifier for the component (default: auto-generated UUID)
+     * @returns {Object|false} The added component object if successful, false otherwise
+     */
+  }, {
+    key: "addComponent",
+    value: function addComponent(libraryId) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      // Validate input parameters
+      if (!libraryId || typeof libraryId !== 'string') {
+        console.error('❌ addComponent(): Invalid library ID provided. Must be a non-empty string.');
+        return false;
+      }
+
+      // Check if scene viewer is available
+      if (!this.sceneViewer || !this.sceneViewer.scene) {
+        console.error('❌ addComponent(): Scene viewer or scene not available');
+        return false;
+      }
+
+      // Check if component manager is available
+      var componentManager = this.sceneViewer.componentManager;
+      if (!componentManager) {
+        console.error('❌ addComponent(): Component manager not available');
+        return false;
+      }
+
+      // Check if model preloader is available
+      var modelPreloader = this.utilities.modelPreloader;
+      if (!modelPreloader) {
+        console.error('❌ addComponent(): Model preloader not available');
+        return false;
+      }
+      try {
+        // Generate a unique component ID if not provided
+        var componentId = options.customId || this.utilities.generateUuidFromName(libraryId + '_' + Date.now());
+
+        // Set default position within scene boundaries if not provided
+        var position = options.position || {
+          x: 0,
+          y: 0,
+          z: 0
+        };
+
+        // Set default rotation if not provided
+        var rotation = options.rotation || {
+          x: 0,
+          y: 0,
+          z: 0
+        };
+        console.log("\uD83D\uDD04 addComponent(): Adding component ".concat(libraryId, " at position:"), position);
+
+        // Get the component data from the preloader's component dictionary
+        if (!modelPreloader.componentDictionary) {
+          console.error("\u274C addComponent(): Component dictionary not available in model preloader");
+          return false;
+        }
+        var componentData = modelPreloader.componentDictionary[libraryId];
+        if (!componentData || !componentData.modelKey) {
+          console.error("\u274C addComponent(): Component data not found for library ID '".concat(libraryId, "'. Available components:"), Object.keys(modelPreloader.componentDictionary));
+          return false;
+        }
+
+        // Get the cached model using the modelKey
+        var cachedModel = modelPreloader.getCachedModelWithDimensions(componentData.modelKey, libraryId);
+        if (!cachedModel) {
+          var status = modelPreloader.getStatus();
+          console.error("\u274C addComponent(): Model for library ID '".concat(libraryId, "' (modelKey: '").concat(componentData.modelKey, "') not found in cache. Cache status:"), {
+            cachedModels: status.cachedModels,
+            totalCached: status.totalCached,
+            isPreloading: status.isPreloading,
+            currentlyLoading: status.currentlyLoading
+          });
+          return false;
+        }
+
+        // Clone the cached model to create a new instance
+        var componentModel = cachedModel;
+
+        // Set the component properties
+        componentModel.uuid = componentId;
+        componentModel.name = libraryId + '_' + componentId.substring(0, 8);
+
+        // Set position and rotation
+        componentModel.position.set(position.x, position.y, position.z);
+        componentModel.rotation.set(rotation.x, rotation.y, rotation.z);
+
+        // Set up component metadata
+        componentModel.userData = {
+          componentType: 'component',
+          libraryId: libraryId,
+          originalUuid: componentId,
+          hardcodedUuid: componentId,
+          addedTimestamp: new Date().toISOString(),
+          addedBy: 'centralPlant.addComponent()',
+          isUserAdded: true,
+          initialPosition: _objectSpread2({}, position),
+          initialRotation: _objectSpread2({}, rotation)
+        };
+
+        // Add the component to the scene
+        this.sceneViewer.scene.add(componentModel);
+
+        // Update matrices to ensure proper positioning
+        componentModel.updateMatrix();
+        componentModel.updateMatrixWorld(true);
+
+        // Add children connectors from component dictionary
+        if (componentData.children && Array.isArray(componentData.children)) {
+          console.log("\uD83D\uDD0C addComponent(): Adding ".concat(componentData.children.length, " connectors for ").concat(libraryId));
+          componentData.children.forEach(function (childData, index) {
+            try {
+              var _childData$userData, _childData$userData2, _childData$userData3;
+              // Create connector geometry (simple sphere for now)
+              var connectorGeometry = new THREE__namespace.SphereGeometry(0.1, 8, 6);
+              var connectorMaterial = new THREE__namespace.MeshPhysicalMaterial({
+                color: 0xC0C0C0,
+                roughness: 0.15,
+                metalness: 0.9,
+                emissive: 0x000000,
+                envMapIntensity: 1.5,
+                transparent: true,
+                opacity: 0.8
+              });
+
+              // Create connector mesh
+              var connectorMesh = new THREE__namespace.Mesh(connectorGeometry, connectorMaterial);
+
+              // Set connector properties from child data
+              if (childData.uuid) {
+                connectorMesh.uuid = "".concat(componentId, "_").concat(childData.uuid);
+              }
+              connectorMesh.name = "".concat(libraryId, "_connector_").concat(index);
+
+              // Set connector position relative to component
+              if (childData.position) {
+                connectorMesh.position.set(childData.position.x || 0, childData.position.y || 0, childData.position.z || 0);
+              }
+
+              // Set connector user data
+              connectorMesh.userData = {
+                componentType: 'connector',
+                parentComponentId: componentId,
+                connectorIndex: index,
+                direction: ((_childData$userData = childData.userData) === null || _childData$userData === void 0 ? void 0 : _childData$userData.direction) || [0, 1, 0],
+                group: ((_childData$userData2 = childData.userData) === null || _childData$userData2 === void 0 ? void 0 : _childData$userData2.group) || null,
+                forExport: ((_childData$userData3 = childData.userData) === null || _childData$userData3 === void 0 ? void 0 : _childData$userData3.forExport) || false,
+                originalChildData: childData
+              };
+
+              // Add connector as child of the component
+              componentModel.add(connectorMesh);
+              console.log("\u2705 Added connector ".concat(index, " to component ").concat(libraryId, ":"), {
+                uuid: connectorMesh.uuid,
+                position: connectorMesh.position,
+                direction: connectorMesh.userData.direction,
+                group: connectorMesh.userData.group
+              });
+            } catch (connectorError) {
+              console.error("\u274C Error creating connector ".concat(index, " for ").concat(libraryId, ":"), connectorError);
+            }
+          });
+        }
+
+        // Notify the component manager about the new component
+        if (componentManager.registerComponent) {
+          componentManager.registerComponent(componentModel);
+        }
+
+        // Update scene data if available
+        if (this.sceneViewer.sceneOperationsManager && this.sceneViewer.currentSceneData) {
+          var success = this.sceneViewer.sceneOperationsManager.addComponentToSceneData(componentModel, this.sceneViewer.currentSceneData);
+          if (success) {
+            console.log('✅ Component successfully added to scene data');
+          } else {
+            console.warn('⚠️ Failed to add component to scene data');
+          }
+        }
+
+        // Record the add operation in metadata
+        this.recordComponentAddition(componentModel, libraryId, options);
+
+        // Log successful addition
+        console.log("\u2705 addComponent(): Component ".concat(libraryId, " added successfully"), componentModel);
+        return componentModel;
+      } catch (error) {
+        console.error("\u274C addComponent(): Error adding component ".concat(libraryId, ":"), error);
+        return false;
+      }
+    }
+
+    /**
+     * Record component addition in metadata for tracking and potential undo
+     * @param {Object} component - The added component
+     * @param {string} libraryId - The library ID used
+     * @param {Object} options - The options used for addition
+     */
+  }, {
+    key: "recordComponentAddition",
+    value: function recordComponentAddition(component, libraryId, options) {
+      // Get existing addition history or create new array
+      var additionHistory = this.getMetadata('componentAdditionHistory') || [];
+      var additionRecord = {
+        componentId: component.uuid,
+        libraryId: libraryId,
+        position: {
+          x: component.position.x,
+          y: component.position.y,
+          z: component.position.z
+        },
+        rotation: {
+          x: component.rotation.x,
+          y: component.rotation.y,
+          z: component.rotation.z
+        },
+        scale: {
+          x: component.scale.x,
+          y: component.scale.y,
+          z: component.scale.z
+        },
+        options: options,
+        timestamp: new Date().toISOString(),
+        sessionId: this.getMetadata('sessionId') || 'unknown'
+      };
+
+      // Add to history (keep only last 50 additions to prevent memory issues)
+      additionHistory.push(additionRecord);
+      if (additionHistory.length > 50) {
+        additionHistory.shift(); // Remove oldest entry
+      }
+
+      // Update metadata
+      this.setMetadata('componentAdditionHistory', additionHistory);
+      this.setMetadata('lastComponentAddition', additionRecord);
+      console.log('📝 Component addition recorded in metadata:', {
+        componentId: component.uuid,
+        libraryId: libraryId,
+        totalAdditions: additionHistory.length
+      });
+    }
+
+    /**
+     * Add a connection between two connector IDs to the connections list
+     * This method adds a new connection to the currentSceneData.connections array
+     * @param {string} fromConnectorId - The ID of the source connector
+     * @param {string} toConnectorId - The ID of the destination connector
+     * @returns {Object|false} The added connection object if successful, false otherwise
+     */
+  }, {
+    key: "addConnection",
+    value: function addConnection(fromConnectorId, toConnectorId) {
+      // Validate input parameters
+      if (!fromConnectorId || typeof fromConnectorId !== 'string') {
+        console.error('❌ addConnection(): Invalid fromConnectorId provided. Must be a non-empty string:', fromConnectorId);
+        return false;
+      }
+      if (!toConnectorId || typeof toConnectorId !== 'string') {
+        console.error('❌ addConnection(): Invalid toConnectorId provided. Must be a non-empty string:', toConnectorId);
+        return false;
+      }
+
+      // Check if the same connector IDs (avoid self-connection)
+      if (fromConnectorId === toConnectorId) {
+        console.error('❌ addConnection(): Cannot connect a connector to itself:', fromConnectorId);
+        return false;
+      }
+
+      // Check if scene viewer and currentSceneData are available
+      if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
+        console.error('❌ addConnection(): Scene viewer or current scene data not available');
+        return false;
+      }
+      try {
+        // Initialize connections array if it doesn't exist
+        if (!this.sceneViewer.currentSceneData.connections) {
+          this.sceneViewer.currentSceneData.connections = [];
+          console.log('🔄 addConnection(): Initialized connections array in currentSceneData');
+        }
+
+        // Check if connection already exists
+        var existingConnection = this.sceneViewer.currentSceneData.connections.find(function (connection) {
+          return connection.from === fromConnectorId && connection.to === toConnectorId || connection.from === toConnectorId && connection.to === fromConnectorId;
+        });
+        if (existingConnection) {
+          console.warn("\u26A0\uFE0F addConnection(): Connection already exists between ".concat(fromConnectorId, " and ").concat(toConnectorId));
+          return existingConnection;
+        }
+
+        // Create the new connection object
+        var newConnection = {
+          from: fromConnectorId,
+          to: toConnectorId
+        };
+
+        // Add the connection to the connections array
+        this.sceneViewer.currentSceneData.connections.push(newConnection);
+
+        // Log successful addition
+        console.log("\u2705 addConnection(): Connection added successfully", {
+          from: fromConnectorId,
+          to: toConnectorId,
+          totalConnections: this.sceneViewer.currentSceneData.connections.length
+        });
+
+        // Record the connection addition in metadata for tracking
+        this.recordConnectionAddition(newConnection);
+        return newConnection;
+      } catch (error) {
+        console.error("\u274C addConnection(): Error adding connection from ".concat(fromConnectorId, " to ").concat(toConnectorId, ":"), error);
+        return false;
+      }
+    }
+
+    /**
+     * Record connection addition in metadata for tracking and potential undo
+     * @param {Object} connection - The added connection object
+     */
+  }, {
+    key: "recordConnectionAddition",
+    value: function recordConnectionAddition(connection) {
+      try {
+        // Get existing connection history or create new array
+        var connectionHistory = this.getMetadata('connectionAdditionHistory') || [];
+        var connectionRecord = {
+          from: connection.from,
+          to: connection.to,
+          timestamp: new Date().toISOString(),
+          addedBy: 'centralPlant.addConnection()'
+        };
+
+        // Add to history
+        connectionHistory.push(connectionRecord);
+
+        // Store updated history (keep last 100 entries to prevent memory issues)
+        this.setMetadata('connectionAdditionHistory', connectionHistory.slice(-100));
+
+        // Update connection statistics
+        var stats = this.getMetadata('connectionStats') || {
+          totalAdded: 0
+        };
+        stats.totalAdded = (stats.totalAdded || 0) + 1;
+        stats.lastAddedTimestamp = new Date().toISOString();
+        this.setMetadata('connectionStats', stats);
+      } catch (error) {
+        console.warn('⚠️ Failed to record connection addition in metadata:', error);
+      }
+    }
+
+    /**
+     * Get all current connections from the scene data
+     * @returns {Array} Array of connection objects or empty array if none exist
+     */
+  }, {
+    key: "getConnections",
+    value: function getConnections() {
+      if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
+        console.warn('⚠️ getConnections(): Scene viewer or current scene data not available');
+        return [];
+      }
+      return this.sceneViewer.currentSceneData.connections || [];
+    }
+
+    /**
+     * Remove a connection between two connector IDs from the connections list
+     * @param {string} fromConnectorId - The ID of the source connector
+     * @param {string} toConnectorId - The ID of the destination connector
+     * @returns {boolean} True if connection was removed, false otherwise
+     */
+  }, {
+    key: "removeConnection",
+    value: function removeConnection(fromConnectorId, toConnectorId) {
+      // Validate input parameters
+      if (!fromConnectorId || typeof fromConnectorId !== 'string') {
+        console.error('❌ removeConnection(): Invalid fromConnectorId provided. Must be a non-empty string:', fromConnectorId);
+        return false;
+      }
+      if (!toConnectorId || typeof toConnectorId !== 'string') {
+        console.error('❌ removeConnection(): Invalid toConnectorId provided. Must be a non-empty string:', toConnectorId);
+        return false;
+      }
+
+      // Check if scene viewer and currentSceneData are available
+      if (!this.sceneViewer || !this.sceneViewer.currentSceneData || !this.sceneViewer.currentSceneData.connections) {
+        console.error('❌ removeConnection(): Scene viewer, current scene data, or connections array not available');
+        return false;
+      }
+      try {
+        // Find the connection to remove (check both directions)
+        var connectionIndex = this.sceneViewer.currentSceneData.connections.findIndex(function (connection) {
+          return connection.from === fromConnectorId && connection.to === toConnectorId || connection.from === toConnectorId && connection.to === fromConnectorId;
+        });
+        if (connectionIndex === -1) {
+          console.warn("\u26A0\uFE0F removeConnection(): Connection not found between ".concat(fromConnectorId, " and ").concat(toConnectorId));
+          return false;
+        }
+
+        // Remove the connection
+        var removedConnection = this.sceneViewer.currentSceneData.connections.splice(connectionIndex, 1)[0];
+
+        // Log successful removal
+        console.log("\u2705 removeConnection(): Connection removed successfully", {
+          from: removedConnection.from,
+          to: removedConnection.to,
+          remainingConnections: this.sceneViewer.currentSceneData.connections.length
+        });
+
+        // Record the connection removal in metadata
+        this.recordConnectionRemoval(removedConnection);
+        return true;
+      } catch (error) {
+        console.error("\u274C removeConnection(): Error removing connection from ".concat(fromConnectorId, " to ").concat(toConnectorId, ":"), error);
+        return false;
+      }
+    }
+
+    /**
+     * Record connection removal in metadata for tracking
+     * @param {Object} connection - The removed connection object
+     */
+  }, {
+    key: "recordConnectionRemoval",
+    value: function recordConnectionRemoval(connection) {
+      try {
+        // Get existing removal history or create new array
+        var removalHistory = this.getMetadata('connectionRemovalHistory') || [];
+        var removalRecord = {
+          from: connection.from,
+          to: connection.to,
+          timestamp: new Date().toISOString(),
+          removedBy: 'centralPlant.removeConnection()'
+        };
+
+        // Add to history
+        removalHistory.push(removalRecord);
+
+        // Store updated history (keep last 100 entries to prevent memory issues)
+        this.setMetadata('connectionRemovalHistory', removalHistory.slice(-100));
+
+        // Update connection statistics
+        var stats = this.getMetadata('connectionStats') || {
+          totalAdded: 0,
+          totalRemoved: 0
+        };
+        stats.totalRemoved = (stats.totalRemoved || 0) + 1;
+        stats.lastRemovedTimestamp = new Date().toISOString();
+        this.setMetadata('connectionStats', stats);
+      } catch (error) {
+        console.warn('⚠️ Failed to record connection removal in metadata:', error);
+      }
+    }
+  }, {
+    key: "updatePaths",
+    value: function updatePaths() {
+      this.sceneViewer.updatePaths();
+    }
   }]);
 }();