@2112-lab/central-plant 0.1.20 → 0.1.22

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) {
@@ -25336,6 +25445,9 @@ var CentralPlant = /*#__PURE__*/function () {
       lastTransform: null
     };
 
+    // Add component counter for unique ID generation
+    this.componentCounter = 0;
+
     // Set default scene metadata
     this.setDefaultSceneMetadata();
 
@@ -25520,6 +25632,9 @@ var CentralPlant = /*#__PURE__*/function () {
         timestamp: new Date().toISOString()
       });
 
+      // Reset component counter based on imported components to avoid ID conflicts
+      this.resetComponentCounter();
+
       // Set default metadata for imported scene data
       this.setDefaultImportedSceneMetadata(sceneData);
 
@@ -26534,7 +26649,7 @@ var CentralPlant = /*#__PURE__*/function () {
 
       // Perform the translation
       var normalizedAxis = axis.toLowerCase();
-      var previousPosition = component.position[normalizedAxis];
+      component.position[normalizedAxis];
       try {
         // Apply the translation
         component.position[normalizedAxis] += value;
@@ -26588,22 +26703,18 @@ var CentralPlant = /*#__PURE__*/function () {
           });
         }
 
+        // 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);
@@ -26620,18 +26731,639 @@ var CentralPlant = /*#__PURE__*/function () {
         return false;
       }
     }
+
+    /**
+     * Generate a unique component ID that doesn't conflict with existing components
+     * @param {string} libraryId - The library identifier for the component type
+     * @returns {string} A unique component ID
+     */
   }, {
-    key: "updatePaths",
-    value: function updatePaths(component) {
-      // 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);
+    key: "generateUniqueComponentId",
+    value: function generateUniqueComponentId(libraryId) {
+      // Get all existing component IDs
+      var existingIds = this.getComponentIds();
+      var existingIdSet = new Set(existingIds);
+      var attempts = 0;
+      var maxAttempts = 1000; // Safety limit to prevent infinite loops
+
+      while (attempts < maxAttempts) {
+        // Generate a candidate ID using the current counter
+        var candidateId = this.utilities.generateUuidFromName(libraryId + '-' + (this.componentCounter + 1));
+
+        // Check if this ID already exists
+        if (!existingIdSet.has(candidateId)) {
+          // ID is unique, increment counter and return it
+          this.componentCounter++;
+          console.log("\u2705 generateUniqueComponentId(): Generated unique ID ".concat(candidateId, " for ").concat(libraryId, " (counter: ").concat(this.componentCounter, ")"));
+          return candidateId;
+        }
+
+        // ID exists, increment counter and try again
+        this.componentCounter++;
+        attempts++;
+        console.warn("\u26A0\uFE0F generateUniqueComponentId(): ID collision detected for ".concat(candidateId, ", trying again (attempt ").concat(attempts, ")"));
       }
 
-      // Update paths if pathfinding is enabled and should update paths
-      if (this.sceneViewer.shouldUpdatePaths && this.sceneViewer.updatePaths) {
-        this.sceneViewer.updatePaths();
+      // Fallback: use timestamp + random number if we can't find a unique ID with counter
+      var fallbackId = this.utilities.generateUuidFromName(libraryId + '-' + Date.now() + '-' + Math.random().toString(36).substring(2, 8));
+      console.warn("\u26A0\uFE0F generateUniqueComponentId(): Max attempts reached, using fallback ID: ".concat(fallbackId));
+      return fallbackId;
+    }
+
+    /**
+     * Reset the component counter based on existing components in the scene
+     * This is useful when loading scenes that already have numbered components
+     */
+  }, {
+    key: "resetComponentCounter",
+    value: function resetComponentCounter() {
+      var existingIds = this.getComponentIds();
+      var maxCounter = 0;
+
+      // Extract counter values from existing component IDs
+      existingIds.forEach(function (id) {
+        // Look for patterns like "PUMP-1", "CHILLER-2", etc.
+        var match = id.match(/-(\d+)(?:-|$)/);
+        if (match) {
+          var counter = parseInt(match[1], 10);
+          if (!isNaN(counter) && counter > maxCounter) {
+            maxCounter = counter;
+          }
+        }
+      });
+
+      // Set the counter to one more than the highest found
+      this.componentCounter = maxCounter;
+      console.log("\uD83D\uDD04 resetComponentCounter(): Counter reset to ".concat(this.componentCounter, " based on ").concat(existingIds.length, " existing components"));
+    }
+
+    /**
+     * 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.generateUniqueComponentId(libraryId);
+
+        // Validate that custom IDs don't conflict with existing components
+        if (options.customId) {
+          var existingIds = this.getComponentIds();
+          if (existingIds.includes(options.customId)) {
+            console.error("\u274C addComponent(): Custom ID '".concat(options.customId, "' already exists in scene. Existing IDs:"), existingIds);
+            return false;
+          }
+        }
+
+        // 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 || [];
+    }
+
+    /**
+     * Get all connector IDs from the currentSceneData
+     * @returns {Array} Array of all connector ID strings, or empty array if none exist
+     */
+  }, {
+    key: "getAllConnectorIds",
+    value: function getAllConnectorIds() {
+      if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
+        console.warn('⚠️ getAllConnectorIds(): Scene viewer or current scene data not available');
+        return [];
+      }
+      var allConnectorIds = [];
+      var sceneData = this.sceneViewer.currentSceneData;
+
+      // Check if scene data has the expected structure
+      if (!sceneData.scene || !sceneData.scene.object || !sceneData.scene.object.children) {
+        console.warn('⚠️ getAllConnectorIds(): Invalid scene data structure');
+        return [];
+      }
+
+      // Traverse through all components in the scene data
+      sceneData.scene.object.children.forEach(function (component) {
+        // Each component may have connector children
+        if (component.children && Array.isArray(component.children)) {
+          component.children.forEach(function (child) {
+            // Check if this child is a connector
+            if (child.userData && child.userData.componentType === 'connector' && child.uuid) {
+              allConnectorIds.push(child.uuid);
+            }
+          });
+        }
+      });
+      console.log("\uD83D\uDD0C getAllConnectorIds(): Found ".concat(allConnectorIds.length, " total connector IDs in currentSceneData"));
+      return allConnectorIds;
+    }
+
+    /**
+     * Get all available connector IDs that are not currently used in connections
+     * @returns {Array} Array of available connector ID strings, or empty array if none exist
+     */
+  }, {
+    key: "getAvailableConnections",
+    value: function getAvailableConnections() {
+      if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
+        console.warn('⚠️ getAvailableConnections(): Scene viewer or current scene data not available');
+        return [];
+      }
+
+      // Get all connector IDs from the currentSceneData
+      var allConnectorIds = this.getAllConnectorIds();
+
+      // Get existing connections
+      var existingConnections = this.getConnections();
+
+      // Collect all connector IDs that are already used in connections
+      var usedConnectorIds = new Set();
+      existingConnections.forEach(function (connection) {
+        if (connection.from) usedConnectorIds.add(connection.from);
+        if (connection.to) usedConnectorIds.add(connection.to);
+      });
+
+      // Filter out used connectors to get only available ones
+      var availableConnectorIds = allConnectorIds.filter(function (id) {
+        return !usedConnectorIds.has(id);
+      });
+      console.log("\uD83D\uDD0C getAvailableConnections(): Found ".concat(availableConnectorIds.length, " available connectors out of ").concat(allConnectorIds.length, " total connectors"));
+      console.log('📋 Available connector IDs:', availableConnectorIds);
+      return availableConnectorIds;
+    }
+
+    /**
+     * Get all component IDs from the scene
+     * @returns {Array} Array of component ID strings, or empty array if none exist
+     */
+  }, {
+    key: "getComponentIds",
+    value: function getComponentIds() {
+      if (!this.sceneViewer || !this.sceneViewer.scene) {
+        console.warn('⚠️ getComponentIds(): Scene viewer or scene not available');
+        return [];
+      }
+      var componentIds = [];
+
+      // Traverse the scene to find all components
+      this.sceneViewer.scene.traverse(function (child) {
+        if (child.userData && child.userData.componentType === 'component') {
+          var id = child.uuid || child.userData.originalUuid || child.name;
+          if (id) {
+            componentIds.push(id);
+          }
+        }
+      });
+      console.log("\uD83D\uDCCB getComponentIds(): Found ".concat(componentIds.length, " component IDs in scene:"), componentIds);
+      return componentIds;
+    }
+
+    /**
+     * 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() {
+      var componentId = this.sceneViewer.currentSceneData.scene.object.children[0].uuid;
+      this.translate(componentId, "x", 0);
+      this.sceneViewer.updatePaths();
     }
   }]);
 }();