@2112-lab/central-plant 0.1.60 → 0.1.62

package/dist/bundle/index.js

@@ -20136,7 +20136,24 @@ var TransformOperationsManager = /*#__PURE__*/function () {
             // Check if this is a valid T-junction (moving segment endpoint touching manual segment)
             var isTJunction = _this2.isTJunction(segmentEndpoints.start, segmentEndpoints.end, otherEndpoints.start, otherEndpoints.end, endpointTolerance);
             if (isTJunction) {
-              console.log("\u2705 T-junction detected but allowed - moving segment endpoint touches manual segment");
+              // T-junction detected, but we need to verify segments are NOT parallel
+              // Parallel segments with touching endpoints indicate overlapping along the same line
+              var _dir = new THREE__namespace.Vector3().subVectors(segmentEndpoints.end, segmentEndpoints.start).normalize();
+              var _dir2 = new THREE__namespace.Vector3().subVectors(otherEndpoints.end, otherEndpoints.start).normalize();
+              var _dotProduct = Math.abs(_dir.dot(_dir2));
+              var parallelThreshold = 0.9999; // Same threshold as collinear check above
+
+              if (_dotProduct > parallelThreshold) {
+                // Segments are parallel - this is NOT a valid T-junction, it's an overlap
+                console.log("\uD83D\uDD34 T-junction rejected - segments are parallel (dot product: ".concat(_dotProduct.toFixed(6), ")"));
+                console.log("   Moving segment: [".concat(segmentEndpoints.start.x.toFixed(2), ", ").concat(segmentEndpoints.start.y.toFixed(2), ", ").concat(segmentEndpoints.start.z.toFixed(2), "] to [").concat(segmentEndpoints.end.x.toFixed(2), ", ").concat(segmentEndpoints.end.y.toFixed(2), ", ").concat(segmentEndpoints.end.z.toFixed(2), "]"));
+                console.log("   Manual segment: [".concat(otherEndpoints.start.x.toFixed(2), ", ").concat(otherEndpoints.start.y.toFixed(2), ", ").concat(otherEndpoints.start.z.toFixed(2), "] to [").concat(otherEndpoints.end.x.toFixed(2), ", ").concat(otherEndpoints.end.y.toFixed(2), ", ").concat(otherEndpoints.end.z.toFixed(2), "]"));
+                hasIntersection = true;
+                return;
+              }
+
+              // Valid non-parallel T-junction - allowed
+              console.log("\u2705 T-junction detected and allowed - moving segment endpoint touches manual segment at different angle (dot product: ".concat(_dotProduct.toFixed(6), ")"));
               console.log("   Moving segment: [".concat(segmentEndpoints.start.x.toFixed(2), ", ").concat(segmentEndpoints.start.y.toFixed(2), ", ").concat(segmentEndpoints.start.z.toFixed(2), "] to [").concat(segmentEndpoints.end.x.toFixed(2), ", ").concat(segmentEndpoints.end.y.toFixed(2), ", ").concat(segmentEndpoints.end.z.toFixed(2), "]"));
               console.log("   Manual segment: [".concat(otherEndpoints.start.x.toFixed(2), ", ").concat(otherEndpoints.start.y.toFixed(2), ", ").concat(otherEndpoints.start.z.toFixed(2), "] to [").concat(otherEndpoints.end.x.toFixed(2), ", ").concat(otherEndpoints.end.y.toFixed(2), ", ").concat(otherEndpoints.end.z.toFixed(2), "]"));
               return;
@@ -20257,7 +20274,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         return null;
       }
       var collisionRadius = 0.5; // Radius around connector that triggers collision
-      var endpointTolerance = 0.55; // Tolerance for determining if connector is at segment endpoint
+      var endpointTolerance = 0.1; // Tolerance for determining if connector is at segment endpoint
 
       // Get segment endpoints in world coordinates
       var endpoints = this.calculateSegmentEndpoints(segment);
@@ -20272,6 +20289,15 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
         // Check if this is a component connector (not a segment-connector)
         if (((_child$userData11 = child.userData) === null || _child$userData11 === void 0 ? void 0 : _child$userData11.objectType) === 'connector') {
+          var _segment$userData10, _segment$userData11;
+          // Skip connectors that are connected to this segment (pathFrom or pathTo)
+          var segmentPathFrom = (_segment$userData10 = segment.userData) === null || _segment$userData10 === void 0 ? void 0 : _segment$userData10.pathFrom;
+          var segmentPathTo = (_segment$userData11 = segment.userData) === null || _segment$userData11 === void 0 ? void 0 : _segment$userData11.pathTo;
+          var connectorId = child.uuid;
+          if (connectorId === segmentPathFrom || connectorId === segmentPathTo) {
+            return; // Skip this connector - it's connected to this segment
+          }
+
           // Get world position of connector
           var connectorWorldPos = new THREE__namespace.Vector3();
           child.getWorldPosition(connectorWorldPos);
@@ -21285,8 +21311,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // Remove segment from scene data
       if (currentSceneData.scene && currentSceneData.scene.children) {
         var segmentIndex = currentSceneData.scene.children.findIndex(function (child) {
-          var _segment$userData10;
-          return child.uuid === segment.uuid || child.uuid === ((_segment$userData10 = segment.userData) === null || _segment$userData10 === void 0 ? void 0 : _segment$userData10.originalUuid);
+          var _segment$userData12;
+          return child.uuid === segment.uuid || child.uuid === ((_segment$userData12 = segment.userData) === null || _segment$userData12 === void 0 ? void 0 : _segment$userData12.originalUuid);
         });
         if (segmentIndex !== -1) {
           currentSceneData.scene.children.splice(segmentIndex, 1);
@@ -27027,15 +27053,12 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
       var objectsToRemove = [];
       sceneViewer.scene.traverse(function (obj) {
         // Remove computed Segments (uppercase SEGMENT-)
+        // Note: Elbows are children of segments, so they'll be removed automatically
         if (obj.uuid && obj.uuid.startsWith("SEGMENT-") && obj.userData.isDeclared !== true) {
           console.log("[removeComputedObjects] to be removed: ".concat(obj.uuid, ")"));
           objectsToRemove.push(obj);
         }
-        // Remove computed Elbows
-        if (obj.userData && obj.userData.isPipeElbow && obj.userData.isDeclared !== true) {
-          console.log("[removeComputedObjects] to be removed: ".concat(obj.uuid, ")"));
-          objectsToRemove.push(obj);
-        }
+        // Don't separately collect elbows - they're children of segments and will be handled below
         // Also remove computed Gateways
         if (obj.uuid && obj.uuid.includes("Gateway") && obj.userData && obj.userData.isDeclared !== true) {
           console.log("[removeComputedObjects] to be removed: ".concat(obj.uuid));
@@ -27044,9 +27067,30 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
       });
 
       // console.log(`[removeComputedObjects] objectsToRemove:`, objectsToRemove);
-
-      for (var _i = 0, _objectsToRemove = objectsToRemove; _i < _objectsToRemove.length; _i++) {
+      var _loop = function _loop() {
         var obj = _objectsToRemove[_i];
+        // Dispose of children (elbows) before removing parent segment
+        // Clone children array since we'll be modifying it during removal
+        if (obj.children && obj.children.length > 0) {
+          var childrenToRemove = _toConsumableArray(obj.children);
+          childrenToRemove.forEach(function (child) {
+            // Remove child from parent first
+            obj.remove(child);
+            // Then dispose of its resources
+            if (child.geometry) child.geometry.dispose();
+            if (child.material) {
+              if (Array.isArray(child.material)) {
+                child.material.forEach(function (mat) {
+                  return mat.dispose();
+                });
+              } else {
+                child.material.dispose();
+              }
+            }
+          });
+        }
+
+        // Now remove the parent object from scene
         sceneViewer.scene.remove(obj);
         if (obj.geometry) obj.geometry.dispose();
         if (obj.material) {
@@ -27058,8 +27102,11 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
             obj.material.dispose();
           }
         }
+      };
+      for (var _i = 0, _objectsToRemove = objectsToRemove; _i < _objectsToRemove.length; _i++) {
+        _loop();
       }
-      console.log("\u2705 Removed ".concat(objectsToRemove.length, " computed objects from scene (segments, elbows, and gateways)"));
+      console.log("\u2705 Removed ".concat(objectsToRemove.length, " computed objects from scene (segments with elbows, and gateways)"));
     }
 
     /**
@@ -29645,6 +29692,28 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         return;
       }
 
+      // Remove any child elbows from computed segment before manualizing
+      if (segment.children && segment.children.length > 0) {
+        var childrenToRemove = _toConsumableArray(segment.children);
+        childrenToRemove.forEach(function (child) {
+          var _child$userData10;
+          if ((_child$userData10 = child.userData) !== null && _child$userData10 !== void 0 && _child$userData10.isPipeElbow) {
+            console.log("\uD83D\uDDD1\uFE0F Removing elbow child from segment before manualization: ".concat(child.uuid));
+            segment.remove(child);
+            if (child.geometry) child.geometry.dispose();
+            if (child.material) {
+              if (Array.isArray(child.material)) {
+                child.material.forEach(function (mat) {
+                  return mat.dispose();
+                });
+              } else {
+                child.material.dispose();
+              }
+            }
+          }
+        });
+      }
+
       // CRITICAL: Clone the material BEFORE changing its color
       // This prevents the color change from affecting other segments that share the same material instance
       if (segment.material && !((_segment$material$use = segment.material.userData) !== null && _segment$material$use !== void 0 && _segment$material$use.isCloned)) {
@@ -33360,6 +33429,103 @@ var CentralPlantInternals = /*#__PURE__*/function () {
       return this.centralPlant.managers.transformOperationsManager.translateGateway(gatewayId, axis, value);
     }
 
+    /**
+     * Translate currently selected objects
+     * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
+     * @param {number} value - The value to translate by
+     * @param {boolean} [skipPathUpdate=false] - If true, skip automatic path regeneration
+     * @returns {Object} Result object with success status and details
+     */
+  }, {
+    key: "translateSelectedObjects",
+    value: function translateSelectedObjects(axis, value) {
+      var _this$centralPlant$sc2;
+      var skipPathUpdate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var result = {
+        success: false,
+        translatedCount: 0,
+        totalCount: 0,
+        errors: []
+      };
+
+      // Get selected objects from transform manager
+      var transformManager = (_this$centralPlant$sc2 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc2 === void 0 ? void 0 : _this$centralPlant$sc2.transformManager;
+      if (!transformManager) {
+        result.errors.push('Transform manager not available');
+        console.error('❌ translateSelectedObjects(): Transform manager not available');
+        return result;
+      }
+      var selectedObjects = transformManager.selectedObjects || [];
+      result.totalCount = selectedObjects.length;
+      if (selectedObjects.length === 0) {
+        result.errors.push('No objects selected');
+        console.warn('⚠️ translateSelectedObjects(): No objects selected');
+        return result;
+      }
+      console.log("\uD83D\uDD27 Translating ".concat(selectedObjects.length, " selected object(s) on ").concat(axis, " axis by ").concat(value));
+
+      // Translate each selected object using the appropriate method
+      var _iterator = _createForOfIteratorHelper(selectedObjects),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _obj$userData;
+          var obj = _step.value;
+          var objectType = (_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType;
+          var objectId = obj.uuid;
+          var success = false;
+          try {
+            if (objectType === 'segment') {
+              success = this.translateSegment(objectId, axis, value, skipPathUpdate);
+            } else if (objectType === 'gateway') {
+              success = this.translateGateway(objectId, axis, value);
+            } else if (objectType === 'component') {
+              success = this.translateComponent(objectId, axis, value);
+            } else {
+              result.errors.push("Unknown object type: ".concat(objectType, " (").concat(objectId, ")"));
+              console.warn("\u26A0\uFE0F Unknown object type: ".concat(objectType, " for ").concat(objectId));
+              continue;
+            }
+            if (success) {
+              result.translatedCount++;
+            } else {
+              result.errors.push("Failed to translate ".concat(objectType, ": ").concat(objectId));
+            }
+          } catch (error) {
+            result.errors.push("Error translating ".concat(objectId, ": ").concat(error.message));
+            console.error("\u274C Error translating ".concat(objectId, ":"), error);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      result.success = result.translatedCount === result.totalCount;
+      if (result.success) {
+        console.log("\u2705 Successfully translated all ".concat(result.translatedCount, " object(s)"));
+      } else {
+        console.warn("\u26A0\uFE0F Translated ".concat(result.translatedCount, "/").concat(result.totalCount, " objects. ").concat(result.errors.length, " error(s) occurred."));
+      }
+      return result;
+    }
+
+    /**
+     * Get currently selected objects
+     * @returns {Array<THREE.Object3D>} Array of currently selected objects
+     */
+  }, {
+    key: "getSelectedObjects",
+    value: function getSelectedObjects() {
+      var _this$centralPlant$sc3;
+      var transformManager = (_this$centralPlant$sc3 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc3 === void 0 ? void 0 : _this$centralPlant$sc3.transformManager;
+      if (!transformManager) {
+        console.warn('⚠️ getSelectedObjects(): Transform manager not available');
+        return [];
+      }
+      return transformManager.selectedObjects || [];
+    }
+
     /**
      * Rotate a component by componentId (delegates to TransformOperationsManager)
      * @param {string} componentId - The UUID of the component to rotate
@@ -33517,9 +33683,9 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "addConnection",
     value: function addConnection(fromConnectorId, toConnectorId) {
-      var _this$centralPlant$sc2;
+      var _this$centralPlant$sc4;
       // Use centralized validation for connection parameters
-      var existingConnections = ((_this$centralPlant$sc2 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc2 === void 0 || (_this$centralPlant$sc2 = _this$centralPlant$sc2.currentSceneData) === null || _this$centralPlant$sc2 === void 0 ? void 0 : _this$centralPlant$sc2.connections) || [];
+      var existingConnections = ((_this$centralPlant$sc4 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc4 === void 0 || (_this$centralPlant$sc4 = _this$centralPlant$sc4.currentSceneData) === null || _this$centralPlant$sc4 === void 0 ? void 0 : _this$centralPlant$sc4.connections) || [];
       var validation = this.validator.validateConnectionParams(fromConnectorId, toConnectorId, existingConnections);
       if (!validation.isValid) {
         return false; // Validator already logged the error
@@ -33645,7 +33811,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "addComponent",
     value: function addComponent(libraryId) {
-      var _this$centralPlant$sc3;
+      var _this$centralPlant$sc5;
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       // Use centralized validation for component addition parameters
       var existingIds = this.getComponentIds();
@@ -33655,7 +33821,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
       }
 
       // Validate scene availability
-      var sceneValidation = this.validator.validateSceneViewer(this.centralPlant.sceneViewer, (_this$centralPlant$sc3 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc3 === void 0 ? void 0 : _this$centralPlant$sc3.scene);
+      var sceneValidation = this.validator.validateSceneViewer(this.centralPlant.sceneViewer, (_this$centralPlant$sc5 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc5 === void 0 ? void 0 : _this$centralPlant$sc5.scene);
       if (!sceneValidation.isValid) {
         return false;
       }
@@ -33674,7 +33840,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
         return false;
       }
       try {
-        var _this$centralPlant$sc4;
+        var _this$centralPlant$sc6;
         // Generate a unique component ID if not provided
         var componentId = options.customId || this.generateUniqueComponentId(libraryId);
 
@@ -33748,7 +33914,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
         componentModel.updateMatrixWorld(true);
 
         // Check if component is underground and fix if needed (based on settings)
-        var checkUnderground = (_this$centralPlant$sc4 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc4 === void 0 || (_this$centralPlant$sc4 = _this$centralPlant$sc4.managers) === null || _this$centralPlant$sc4 === void 0 || (_this$centralPlant$sc4 = _this$centralPlant$sc4.settingsManager) === null || _this$centralPlant$sc4 === void 0 ? void 0 : _this$centralPlant$sc4.getSetting('scene', 'checkUnderground');
+        var checkUnderground = (_this$centralPlant$sc6 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc6 === void 0 || (_this$centralPlant$sc6 = _this$centralPlant$sc6.managers) === null || _this$centralPlant$sc6 === void 0 || (_this$centralPlant$sc6 = _this$centralPlant$sc6.settingsManager) === null || _this$centralPlant$sc6 === void 0 ? void 0 : _this$centralPlant$sc6.getSetting('scene', 'checkUnderground');
         if (checkUnderground) {
           var wasFixed = this.fixUndergroundComponent(componentModel);
           if (wasFixed) {
@@ -33888,7 +34054,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.1.60
+   * @version 0.1.62
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.
@@ -34160,6 +34326,179 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
       return this.internals.translateSegment(segmentId, axis, value, skipPathUpdate);
     }
 
+    /**
+     * Select an object in the scene
+     * @param {THREE.Object3D|string} objectOrId - The Three.js object to select, or its UUID
+     * @returns {boolean} True if selection was successful, false otherwise
+     * @description Selects an object in the scene, showing the transform controls and bounding box.
+     * This is useful for programmatically selecting objects before performing operations like translation.
+     * Objects marked as immutable (userData.immutable = true) cannot be selected.
+     * @example
+     * // Select by object reference
+     * const segment = scene.getObjectByProperty('uuid', 'segment-uuid-123');
+     * centralPlant.selectObject(segment);
+     * 
+     * // Select by UUID
+     * centralPlant.selectObject('segment-uuid-123');
+     * 
+     * // Then translate the selected object
+     * centralPlant.translateSegment('segment-uuid-123', 'x', 1.0);
+     * 
+     * @since 0.1.37
+     */
+  }, {
+    key: "selectObject",
+    value: function selectObject(objectOrId) {
+      var _this$sceneViewer, _object;
+      if (!((_this$sceneViewer = this.sceneViewer) !== null && _this$sceneViewer !== void 0 && _this$sceneViewer.transformManager)) {
+        console.warn('⚠️ Transform manager not initialized');
+        return false;
+      }
+      var object = objectOrId;
+
+      // If a string UUID was provided, find the object in the scene
+      if (typeof objectOrId === 'string') {
+        object = this.sceneViewer.scene.getObjectByProperty('uuid', objectOrId);
+        if (!object) {
+          console.warn("\u26A0\uFE0F Object with UUID ".concat(objectOrId, " not found in scene"));
+          return false;
+        }
+      }
+
+      // Check if object is immutable
+      if (((_object = object) === null || _object === void 0 || (_object = _object.userData) === null || _object === void 0 ? void 0 : _object.immutable) === true) {
+        console.warn("\u26A0\uFE0F Cannot select immutable object: ".concat(object.name || object.uuid));
+        return false;
+      }
+      return this.sceneViewer.transformManager.selectObject(object);
+    }
+
+    /**
+     * Toggle object selection (add/remove from multi-selection)
+     * @param {THREE.Object3D|string} objectOrId - The Three.js object to toggle, or its UUID
+     * @returns {boolean} True if toggle was successful, false otherwise
+     * @description Toggles an object in the multi-selection. If the object is already selected,
+     * it will be removed from the selection. If not selected, it will be added to the selection.
+     * This is useful for programmatic multi-selection (similar to shift+click behavior).
+     * Objects marked as immutable (userData.immutable = true) cannot be toggled.
+     * @example
+     * // Toggle selection by UUID
+     * centralPlant.toggleObject('segment-uuid-123');
+     * centralPlant.toggleObject('segment-uuid-456'); // Now both selected
+     * centralPlant.toggleObject('segment-uuid-123'); // Removes first, keeps second
+     * 
+     * // Toggle by object reference
+     * const segment = scene.getObjectByProperty('uuid', 'segment-uuid-789');
+     * centralPlant.toggleObject(segment);
+     * 
+     * @since 0.1.37
+     */
+  }, {
+    key: "toggleObject",
+    value: function toggleObject(objectOrId) {
+      var _this$sceneViewer2, _object2;
+      if (!((_this$sceneViewer2 = this.sceneViewer) !== null && _this$sceneViewer2 !== void 0 && _this$sceneViewer2.transformManager)) {
+        console.warn('⚠️ Transform manager not initialized');
+        return false;
+      }
+      var object = objectOrId;
+
+      // If a string UUID was provided, find the object in the scene
+      if (typeof objectOrId === 'string') {
+        object = this.sceneViewer.scene.getObjectByProperty('uuid', objectOrId);
+        if (!object) {
+          console.warn("\u26A0\uFE0F Object with UUID ".concat(objectOrId, " not found in scene"));
+          return false;
+        }
+      }
+
+      // Check if object is immutable
+      if (((_object2 = object) === null || _object2 === void 0 || (_object2 = _object2.userData) === null || _object2 === void 0 ? void 0 : _object2.immutable) === true) {
+        console.warn("\u26A0\uFE0F Cannot toggle immutable object: ".concat(object.name || object.uuid));
+        return false;
+      }
+      this.sceneViewer.transformManager.toggleObjectSelection(object);
+      return true;
+    }
+
+    /**
+     * Deselect the currently selected object(s)
+     * @returns {boolean} True if deselection was successful
+     * @description Clears the current selection, hiding transform controls and bounding boxes.
+     * @example
+     * centralPlant.deselectObject();
+     * 
+     * @since 0.1.37
+     */
+  }, {
+    key: "deselectObject",
+    value: function deselectObject() {
+      var _this$sceneViewer3;
+      if (!((_this$sceneViewer3 = this.sceneViewer) !== null && _this$sceneViewer3 !== void 0 && _this$sceneViewer3.transformManager)) {
+        console.warn('⚠️ Transform manager not initialized');
+        return false;
+      }
+      this.sceneViewer.transformManager.deselectObject();
+      return true;
+    }
+
+    /**
+     * Translate currently selected object(s)
+     * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
+     * @param {number} value - The value to translate by (must be a multiple of 0.5)
+     * @param {boolean} [skipPathUpdate=false] - If true, skip automatic path regeneration (for batch operations)
+     * @returns {Object} Result object with success status and details
+     * @returns {boolean} returns.success - True if all translations were successful
+     * @returns {number} returns.translatedCount - Number of objects successfully translated
+     * @returns {number} returns.totalCount - Total number of selected objects
+     * @returns {Array} returns.errors - Array of error messages if any failures occurred
+     * @description Translates all currently selected objects along the specified axis.
+     * Automatically determines the object type (component/segment/gateway) and calls the
+     * appropriate translation method for each. Useful for batch operations on selections.
+     * @example
+     * // Select objects first
+     * centralPlant.selectObject('segment-1')
+     * centralPlant.toggleObjectSelection('segment-2')
+     * centralPlant.toggleObjectSelection('component-1')
+     * 
+     * // Translate all selected objects 2 units along X axis
+     * const result = centralPlant.translateSelectedObjects('x', 2.0)
+     * console.log(`Translated ${result.translatedCount}/${result.totalCount} objects`)
+     * 
+     * // Batch operation with path update disabled
+     * centralPlant.translateSelectedObjects('x', 1.0, true)
+     * centralPlant.translateSelectedObjects('y', 0.5, true)
+     * centralPlant.updatePaths() // Update once at the end
+     * 
+     * @since 0.1.37
+     */
+  }, {
+    key: "translateSelectedObjects",
+    value: function translateSelectedObjects(axis, value) {
+      var skipPathUpdate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      return this.internals.translateSelectedObjects(axis, value, skipPathUpdate);
+    }
+
+    /**
+     * Get currently selected objects
+     * @returns {Array<THREE.Object3D>} Array of currently selected Three.js objects
+     * @description Returns the array of objects currently selected in the scene.
+     * Useful for inspecting selection state or performing custom operations.
+     * @example
+     * const selected = centralPlant.getSelectedObjects()
+     * console.log(`${selected.length} objects selected`)
+     * selected.forEach(obj => {
+     *   console.log(`- ${obj.name} (${obj.userData.objectType}): ${obj.uuid}`)
+     * })
+     * 
+     * @since 0.1.37
+     */
+  }, {
+    key: "getSelectedObjects",
+    value: function getSelectedObjects() {
+      return this.internals.getSelectedObjects();
+    }
+
     /**
      * Translate a gateway by gatewayId
      * @param {string} gatewayId - The UUID of the gateway to translate
@@ -34623,6 +34962,116 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
       return componentIds;
     }
 
+    /**
+     * Get object IDs from the scene by type
+     * @param {string|Array<string>} objectTypes - Object type(s) to retrieve: 'components', 'segments', 'gateways', or array of types
+     * @param {Object} [options={}] - Optional filtering options
+     * @param {boolean} [options.isDeclared] - Filter by declared status (true for declared only, false for computed only, undefined for all)
+     * @returns {Array<string>} Array of object UUID strings matching the specified type(s), or empty array if none exist
+     * @description Retrieves UUIDs of objects currently in the 3D scene filtered by object type.
+     * This traverses the Three.js scene graph to find objects with matching objectType in userData.
+     * Supports single type as string or multiple types as array.
+     * @example
+     * // Get all component IDs
+     * const componentIds = centralPlant.getObjectIds('components');
+     * console.log(`Components: ${componentIds.length}`);
+     * 
+     * // Get all segment IDs
+     * const segmentIds = centralPlant.getObjectIds('segments');
+     * console.log(`Segments: ${segmentIds.length}`);
+     * 
+     * // Get all gateway IDs
+     * const gatewayIds = centralPlant.getObjectIds('gateways');
+     * console.log(`Gateways: ${gatewayIds.length}`);
+     * 
+     * // Get multiple object types at once
+     * const allIds = centralPlant.getObjectIds(['components', 'segments', 'gateways']);
+     * console.log(`Total objects: ${allIds.length}`);
+     * 
+     * // Get only declared segments
+     * const declaredSegments = centralPlant.getObjectIds('segments', { isDeclared: true });
+     * console.log(`Declared segments: ${declaredSegments.length}`);
+     * 
+     * // Get only computed gateways
+     * const computedGateways = centralPlant.getObjectIds('gateways', { isDeclared: false });
+     * console.log(`Computed gateways: ${computedGateways.length}`);
+     * 
+     * // Use for selection UI
+     * const segments = centralPlant.getObjectIds('segments');
+     * segments.forEach(id => {
+     *   console.log(`Segment: ${id}`);
+     * });
+     */
+  }, {
+    key: "getObjectIds",
+    value: function getObjectIds() {
+      var objectTypes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['components', 'segments', 'gateways'];
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!this.sceneViewer) {
+        console.warn('⚠️ getObjectIds(): Scene viewer not available - centralPlant not fully initialized');
+        return [];
+      }
+      if (!this.sceneViewer.scene) {
+        console.warn('⚠️ getObjectIds(): Scene not available - scene viewer not fully initialized');
+        return [];
+      }
+      if (!this.sceneViewer.isInitialized) {
+        console.warn('⚠️ getObjectIds(): Scene viewer initialization not complete');
+        return [];
+      }
+
+      // Validate objectTypes parameter
+      if (!objectTypes) {
+        console.warn('⚠️ getObjectIds(): objectTypes parameter is required');
+        return [];
+      }
+
+      // Convert to array for consistent handling
+      var typesArray = Array.isArray(objectTypes) ? objectTypes : [objectTypes];
+
+      // Map plural types to singular (internal userData uses singular)
+      var typeMapping = {
+        'components': 'component',
+        'segments': 'segment',
+        'gateways': 'gateway'
+      };
+
+      // Validate each type and convert to internal format
+      var validTypes = ['components', 'segments', 'gateways'];
+      var invalidTypes = typesArray.filter(function (type) {
+        return !validTypes.includes(type);
+      });
+      if (invalidTypes.length > 0) {
+        console.warn("\u26A0\uFE0F getObjectIds(): Invalid object type(s): ".concat(invalidTypes.join(', '), ". Valid types are: ").concat(validTypes.join(', ')));
+        return [];
+      }
+
+      // Convert plural types to singular for internal lookup
+      var internalTypes = typesArray.map(function (type) {
+        return typeMapping[type];
+      });
+      var objectIds = [];
+
+      // Traverse the scene to find all objects matching the specified types
+      this.sceneViewer.scene.traverse(function (child) {
+        if (child.userData && child.userData.objectType && internalTypes.includes(child.userData.objectType)) {
+          // Apply isDeclared filter if specified
+          if (options.isDeclared !== undefined) {
+            var childIsDeclared = child.userData.isDeclared === true;
+            if (childIsDeclared !== options.isDeclared) {
+              return; // Skip this object if it doesn't match the isDeclared filter
+            }
+          }
+          var id = child.uuid || child.userData.originalUuid || child.name;
+          if (id) {
+            objectIds.push(id);
+          }
+        }
+      });
+      console.log("\uD83D\uDCCB getObjectIds(): Found ".concat(objectIds.length, " object IDs for type(s) [").concat(typesArray.join(', '), "]").concat(options.isDeclared !== undefined ? " (isDeclared: ".concat(options.isDeclared, ")") : '', ":"), objectIds);
+      return objectIds;
+    }
+
     /**
      * Get components from the dictionary with detailed information and flexible filtering
      * @param {Object} [options={}] - Configuration options for component listing