@2112-lab/central-plant 0.1.39 → 0.1.41

package/dist/cjs/src/managers/components/transformOperationsManager.js

@@ -0,0 +1,929 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../../_virtual/_rollupPluginBabelHelpers.js');
+var THREE = require('three');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
+
+var TransformOperationsManager = /*#__PURE__*/function () {
+  /**
+   * @param {Object} sceneViewer - The scene viewer instance
+   */
+  function TransformOperationsManager(sceneViewer) {
+    _rollupPluginBabelHelpers.classCallCheck(this, TransformOperationsManager);
+    this.sceneViewer = sceneViewer;
+  }
+
+  /**
+   * Translate a component by componentId
+   * @param {string} componentId - The UUID of the component to translate
+   * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
+   * @param {number} value - The value to translate by
+   * @returns {boolean} True if translation was successful, false otherwise
+   */
+  return _rollupPluginBabelHelpers.createClass(TransformOperationsManager, [{
+    key: "translateComponent",
+    value: function translateComponent(componentId, axis, value) {
+      var _this$sceneViewer$man, _this$sceneViewer;
+      // Store transform parameters using the OperationHistoryManager
+      if ((_this$sceneViewer$man = this.sceneViewer.managers) !== null && _this$sceneViewer$man !== void 0 && _this$sceneViewer$man.operationHistoryManager) {
+        this.sceneViewer.managers.operationHistoryManager.addToOperationHistory('translateComponent', {
+          componentId: componentId,
+          axis: axis,
+          value: value
+        });
+      }
+
+      // Validate parameters
+      if (!componentId || !axis || value === undefined || value === null) {
+        console.error('❌ translateComponent(): Invalid parameters');
+        return false;
+      }
+      if (!['x', 'y', 'z'].includes(axis)) {
+        console.error("\u274C translateComponent(): Invalid axis '".concat(axis, "'. Must be 'x', 'y', or 'z'"));
+        return false;
+      }
+      if (!this.sceneViewer || !this.sceneViewer.scene) {
+        console.error('❌ translateComponent(): Scene viewer or scene not available');
+        return false;
+      }
+
+      // Find the component in the scene
+      var component = null;
+      this.sceneViewer.scene.traverse(function (child) {
+        var _child$userData;
+        if (child.uuid === componentId || ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.originalUuid) === componentId) {
+          component = child;
+        }
+      });
+      if (!component) {
+        console.error("\u274C translateComponent(): Component with ID '".concat(componentId, "' not found in scene"));
+        return false;
+      }
+
+      // Validate that it's actually a component
+      if (!component.userData || !component.userData.objectType) {
+        console.error("\u274C translateComponent(): Object with ID '".concat(componentId, "' is not a valid component"));
+        return false;
+      }
+
+      // Apply the translation
+      console.log("\uD83D\uDD04 translateComponent(): Translating component ".concat(componentId, " on ").concat(axis, " axis by ").concat(value));
+
+      // Update the Three.js object position
+      component.position[axis] += value;
+
+      // Update matrices
+      component.updateMatrix();
+      component.updateMatrixWorld(true);
+
+      // Check if component is underground and fix if needed (based on settings)
+      var checkUnderground = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.settingsManager) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.getSetting('scene', 'checkUnderground');
+      if (checkUnderground) {
+        this.fixUndergroundComponent(component);
+      }
+
+      // Emit transform event if available
+      if (this.sceneViewer.emit && typeof this.sceneViewer.emit === 'function') {
+        this.sceneViewer.emit('objectTransformed', {
+          object: component,
+          transformType: 'translate',
+          axis: axis,
+          value: value
+        });
+      }
+      console.log("\u2705 translateComponent(): Component ".concat(componentId, " translated successfully"));
+      return true;
+    }
+
+    /**
+     * Translate a pipe segment by segmentId
+     * @param {string} segmentId - The UUID of the pipe segment to translate
+     * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
+     * @param {number} value - The value to translate by
+     * @returns {boolean} True if translation was successful, false otherwise
+     */
+  }, {
+    key: "translateSegment",
+    value: function translateSegment(segmentId, axis, value) {
+      var _this$sceneViewer$man2, _segment$userData, _segment$userData2, _this$sceneViewer3, _this$sceneViewer$man4, _this$sceneViewer$man5;
+      // Store transform parameters using the OperationHistoryManager
+      if ((_this$sceneViewer$man2 = this.sceneViewer.managers) !== null && _this$sceneViewer$man2 !== void 0 && _this$sceneViewer$man2.operationHistoryManager) {
+        this.sceneViewer.managers.operationHistoryManager.addToOperationHistory('translateSegment', {
+          segmentId: segmentId,
+          axis: axis,
+          value: value
+        });
+      }
+
+      // Validate parameters
+      if (!segmentId || !axis || value === undefined || value === null) {
+        console.error('❌ translateSegment(): Invalid parameters');
+        return false;
+      }
+      if (!['x', 'y', 'z'].includes(axis)) {
+        console.error("\u274C translateSegment(): Invalid axis '".concat(axis, "'. Must be 'x', 'y', or 'z'"));
+        return false;
+      }
+      if (!this.sceneViewer || !this.sceneViewer.scene) {
+        console.error('❌ translateSegment(): Scene viewer or scene not available');
+        return false;
+      }
+
+      // Find the segment in the scene
+      var segment = null;
+      this.sceneViewer.scene.traverse(function (child) {
+        var _child$userData2;
+        if (child.uuid === segmentId || ((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.originalUuid) === segmentId) {
+          segment = child;
+        }
+      });
+      if (!segment) {
+        console.error("\u274C translateSegment(): Segment with ID '".concat(segmentId, "' not found in scene"));
+        return false;
+      }
+
+      // Validate that it's actually a pipe segment
+      if (!((_segment$userData = segment.userData) !== null && _segment$userData !== void 0 && _segment$userData.objectType) === 'segment') {
+        console.error("\u274C translateSegment(): Object with ID '".concat(segmentId, "' is not a valid pipe segment"));
+        return false;
+      }
+
+      // Check if segment is transformable
+      if (((_segment$userData2 = segment.userData) === null || _segment$userData2 === void 0 ? void 0 : _segment$userData2.transformable) === false) {
+        console.warn("\u26A0\uFE0F translateSegment(): Segment '".concat(segmentId, "' is marked as non-transformable (stub segment)"));
+        return false;
+      }
+      console.log('[translateSegment] segment:', segment);
+
+      // Calculate segment endpoints to check for nearby connectors
+      var segmentEndpoints = this.calculateSegmentEndpoints(segment);
+
+      // Check if there are any connectors (component or manual) at segment endpoints
+      var connectorsAtEndpoints = this.findConnectorsAtPositions([segmentEndpoints.start, segmentEndpoints.end], 0.15 // tolerance for position matching
+      );
+
+      // Filter out segment connectors - we only care about component connectors
+      var componentConnectorsAtEndpoints = connectorsAtEndpoints.filter(function (connector) {
+        var _connector$userData;
+        return ((_connector$userData = connector.userData) === null || _connector$userData === void 0 ? void 0 : _connector$userData.objectType) !== 'segment-connector';
+      });
+      if (componentConnectorsAtEndpoints.length > 0) {
+        var _this$sceneViewer$man3, _this$sceneViewer2;
+        console.warn("\u26A0\uFE0F translateSegment(): Segment '".concat(segmentId, "' has component connectors at endpoints. Splitting segment..."));
+        console.log("   Found ".concat(componentConnectorsAtEndpoints.length, " component connector(s):"), componentConnectorsAtEndpoints.map(function (c) {
+          var _c$parent;
+          return {
+            uuid: c.uuid,
+            parent: (_c$parent = c.parent) === null || _c$parent === void 0 ? void 0 : _c$parent.uuid
+          };
+        }));
+
+        // Split the segment using SceneOperationsManager (will auto-detect component connectors)
+        var _sceneOperationsManager = (_this$sceneViewer$man3 = this.sceneViewer.managers) === null || _this$sceneViewer$man3 === void 0 ? void 0 : _this$sceneViewer$man3.sceneOperationsManager;
+        if (!_sceneOperationsManager) {
+          console.error('❌ translateSegment(): SceneOperationsManager not available for splitting');
+          return false;
+        }
+
+        // Check if segment splitting is enabled in settings
+        var splitSegmentsEnabled = (_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.managers) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.settingsManager) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.getSetting('scene', 'splitSegmentsWithComponentConnectors');
+        if (splitSegmentsEnabled === false) {
+          return false;
+        }
+        try {
+          var splitResult = _sceneOperationsManager.splitSegment(segment);
+          if (splitResult && splitResult.segment1 && splitResult.segment2) {
+            console.log("\u2705 Segment split: ".concat(splitResult.segment1.uuid, " (").concat(splitResult.segment1.geometry.parameters.height, "), ").concat(splitResult.segment2.uuid, " (").concat(splitResult.segment2.geometry.parameters.height, ")"));
+
+            // Determine which segment is the longer one (free side) to translate
+            var segment1Length = splitResult.segment1.geometry.parameters.height;
+            var segment2Length = splitResult.segment2.geometry.parameters.height;
+
+            // The longer segment is the one WITHOUT the component connector
+            var segmentToTranslate = segment1Length > segment2Length ? splitResult.segment1 : splitResult.segment2;
+            console.log("\uD83C\uDFAF Translating ".concat(segmentToTranslate.uuid, " (length: ").concat(segmentToTranslate.geometry.parameters.height, ") - the free segment"));
+
+            // Now translate the chosen segment (recursive call with the new segment)
+            var translateSuccess = this.translateSegment(segmentToTranslate.uuid, axis, value);
+            if (!translateSuccess) {
+              console.error('❌ translateSegment(): Failed to translate split segment half');
+              return false;
+            }
+            console.log('✅ Split and translate operation completed successfully');
+            return true;
+          } else {
+            console.error('❌ translateSegment(): Split operation failed');
+            return false;
+          }
+        } catch (error) {
+          console.error('❌ translateSegment(): Error splitting segment:', error);
+          return false;
+        }
+      }
+      console.log("\uD83D\uDD04 translateSegment(): Translating segment ".concat(segmentId, " on ").concat(axis, " axis by ").concat(value));
+
+      // Check if translationalOverrideForAutomaticSegments is enabled
+      var translationalOverride = (_this$sceneViewer3 = this.sceneViewer) === null || _this$sceneViewer3 === void 0 || (_this$sceneViewer3 = _this$sceneViewer3.managers) === null || _this$sceneViewer3 === void 0 || (_this$sceneViewer3 = _this$sceneViewer3.settingsManager) === null || _this$sceneViewer3 === void 0 ? void 0 : _this$sceneViewer3.getSetting('scene', 'translationalOverrideForAutomaticSegments');
+
+      // If override is disabled (false), check for intersections with computed segments
+      if (translationalOverride === false) {
+        console.log('🔍 Checking for intersections with computed segments (translationalOverrideForAutomaticSegments is disabled)');
+
+        // Temporarily apply the translation to check for intersections
+        var originalPosition = segment.position[axis];
+        segment.position[axis] += value;
+        segment.updateMatrix();
+        segment.updateMatrixWorld(true);
+
+        // Check if the translated segment intersects with any computed segments
+        var hasIntersection = this.checkSegmentIntersection(segment);
+        console.log("\uD83D\uDD04 translateSegment() hasIntersection:", hasIntersection);
+        if (hasIntersection) {
+          // Revert the translation
+          segment.position[axis] = originalPosition;
+          segment.updateMatrix();
+          segment.updateMatrixWorld(true);
+          console.warn("\u26A0\uFE0F translateSegment(): Translation canceled - segment would intersect with computed segment(s)");
+          return false;
+        }
+        console.log('✅ No intersections detected, proceeding with translation');
+      } else {
+        // Apply the translation to the Three.js object
+        segment.position[axis] += value;
+
+        // Update matrices
+        segment.updateMatrix();
+        segment.updateMatrixWorld(true);
+      }
+
+      // Validate PathfindingManager and SceneOperationsManager availability
+      var pathfindingManager = (_this$sceneViewer$man4 = this.sceneViewer.managers) === null || _this$sceneViewer$man4 === void 0 ? void 0 : _this$sceneViewer$man4.pathfindingManager;
+      var sceneOperationsManager = (_this$sceneViewer$man5 = this.sceneViewer.managers) === null || _this$sceneViewer$man5 === void 0 ? void 0 : _this$sceneViewer$man5.sceneOperationsManager;
+      if (!pathfindingManager || !sceneOperationsManager) {
+        console.error('❌ translateSegment(): PathfindingManager or SceneOperationsManager not available');
+        return false;
+      }
+
+      // Check if segment is already declared - if not, manualize it first
+      if (segment.userData.isDeclared !== true) {
+        console.log('🔌 Handling manual segment transformation via SceneOperationsManager (first move)');
+        try {
+          sceneOperationsManager.manualizeSegment(segment, this.sceneViewer.currentSceneData);
+        } catch (error) {
+          console.error('❌ translateSegment(): Error in manualizeSegment:', error);
+          return false;
+        }
+      } else {
+        console.log('🔄 Segment already declared, updating connector positions (subsequent move)');
+      }
+
+      // ALWAYS update connector positions after segment movement (first or subsequent moves)
+      this.updateSegmentConnectorPositions(segment);
+
+      // Regenerate paths to create new pipe segments that connect to the moved segment
+      console.log('🔄 Regenerating paths to create connecting pipe segments...');
+      try {
+        if (this.sceneViewer && typeof this.sceneViewer.updatePaths === 'function') {
+          this.sceneViewer.updatePaths();
+          console.log('✅ Paths regenerated successfully - new connecting segments created');
+        } else {
+          console.warn('⚠️ updatePaths method not available on sceneViewer');
+        }
+      } catch (error) {
+        console.error('❌ Error regenerating paths:', error);
+      }
+
+      // Emit transform event if available
+      if (this.sceneViewer.emit && typeof this.sceneViewer.emit === 'function') {
+        this.sceneViewer.emit('objectTransformed', {
+          object: segment,
+          transformType: 'translateSegment',
+          axis: axis,
+          value: value
+        });
+      }
+      console.log("\u2705 translateSegment(): Segment ".concat(segmentId, " translated and connections restructured successfully"));
+      return true;
+    }
+
+    /**
+     * Translate a gateway by gatewayId
+     * @param {string} gatewayId - The UUID of the gateway to translate
+     * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
+     * @param {number} value - The value to translate by
+     * @returns {boolean} True if translation was successful, false otherwise
+     */
+  }, {
+    key: "translateGateway",
+    value: function translateGateway(gatewayId, axis, value) {
+      var _this$sceneViewer$man6, _this$sceneViewer$man7;
+      console.log("[Pathfinder] translateGateway started");
+
+      // Store transform parameters using the OperationHistoryManager
+      if ((_this$sceneViewer$man6 = this.sceneViewer.managers) !== null && _this$sceneViewer$man6 !== void 0 && _this$sceneViewer$man6.operationHistoryManager) {
+        this.sceneViewer.managers.operationHistoryManager.addToOperationHistory('translateGateway', {
+          gatewayId: gatewayId,
+          axis: axis,
+          value: value
+        });
+      }
+
+      // Validate parameters
+      if (!gatewayId || !axis || value === undefined || value === null) {
+        console.error('❌ translateGateway(): Invalid parameters');
+        return false;
+      }
+      if (!['x', 'y', 'z'].includes(axis)) {
+        console.error("\u274C translateGateway(): Invalid axis '".concat(axis, "'. Must be 'x', 'y', or 'z'"));
+        return false;
+      }
+      if (!this.sceneViewer || !this.sceneViewer.scene) {
+        console.error('❌ translateGateway(): Scene viewer or scene not available');
+        return false;
+      }
+
+      // Find the gateway in the scene
+      var gateway = null;
+      this.sceneViewer.scene.traverse(function (child) {
+        var _child$userData3;
+        if (child.uuid === gatewayId || ((_child$userData3 = child.userData) === null || _child$userData3 === void 0 ? void 0 : _child$userData3.originalUuid) === gatewayId) {
+          gateway = child;
+        }
+      });
+      if (!gateway) {
+        console.error("\u274C translateGateway(): Gateway with ID '".concat(gatewayId, "' not found in scene"));
+        return false;
+      }
+
+      // Validate that it's actually a gateway
+      if (!gateway.userData || gateway.userData.objectType !== 'gateway') {
+        console.error("\u274C translateGateway(): Object with ID '".concat(gatewayId, "' is not a valid gateway"));
+        return false;
+      }
+      console.log("\uD83D\uDD04 translateGateway(): Translating gateway ".concat(gatewayId, " on ").concat(axis, " axis by ").concat(value));
+
+      // Apply the translation to the Three.js object
+      gateway.position[axis] += value;
+
+      // Update matrices
+      gateway.updateMatrix();
+      gateway.updateMatrixWorld(true);
+
+      // Handle manual gateway transformation (convert to declared and process connections)
+      console.log('🔧 Handling manual gateway transformation via SceneOperationsManager');
+      var sceneOperationsManager = (_this$sceneViewer$man7 = this.sceneViewer.managers) === null || _this$sceneViewer$man7 === void 0 ? void 0 : _this$sceneViewer$man7.sceneOperationsManager;
+      if (!sceneOperationsManager) {
+        console.error('❌ translateGateway(): SceneOperationsManager not available');
+        return false;
+      }
+      try {
+        sceneOperationsManager.manualizeGateway(gateway, this.sceneViewer.currentSceneData);
+      } catch (error) {
+        console.error('❌ translateGateway(): Error in manualizeGateway:', error);
+        return false;
+      }
+
+      // Regenerate paths to reflect the gateway's new position
+      console.log('🔄 Regenerating paths to reflect gateway movement...');
+      try {
+        if (this.sceneViewer && typeof this.sceneViewer.updatePaths === 'function') {
+          this.sceneViewer.updatePaths();
+          console.log('✅ Paths regenerated successfully - routing updated for new gateway position');
+        } else {
+          console.warn('⚠️ updatePaths method not available on sceneViewer');
+        }
+      } catch (error) {
+        console.error('❌ Error regenerating paths:', error);
+      }
+
+      // Emit transform event if available
+      if (this.sceneViewer.emit && typeof this.sceneViewer.emit === 'function') {
+        this.sceneViewer.emit('objectTransformed', {
+          object: gateway,
+          transformType: 'translateGateway',
+          axis: axis,
+          value: value
+        });
+      }
+      console.log("\u2705 translateGateway(): Gateway ".concat(gatewayId, " translated and marked as declared successfully"));
+      return true;
+    }
+
+    /**
+     * Rotate a component by componentId
+     * @param {string} componentId - The UUID of the component to rotate
+     * @param {string} axis - The axis to rotate around ('x', 'y', or 'z')
+     * @param {number} value - The value to rotate by in degrees
+     * @returns {boolean} True if rotation was successful, false otherwise
+     */
+  }, {
+    key: "rotateComponent",
+    value: function rotateComponent(componentId, axis, value) {
+      // Validate parameters
+      if (!componentId || !axis || value === undefined || value === null) {
+        console.error('❌ rotateComponent(): Invalid parameters');
+        return false;
+      }
+      if (!['x', 'y', 'z'].includes(axis)) {
+        console.error("\u274C rotateComponent(): Invalid axis '".concat(axis, "'. Must be 'x', 'y', or 'z'"));
+        return false;
+      }
+      if (!this.sceneViewer || !this.sceneViewer.scene) {
+        console.error('❌ rotateComponent(): Scene viewer or scene not available');
+        return false;
+      }
+
+      // Find the component in the scene
+      var component = null;
+      this.sceneViewer.scene.traverse(function (child) {
+        var _child$userData4;
+        if (child.uuid === componentId || ((_child$userData4 = child.userData) === null || _child$userData4 === void 0 ? void 0 : _child$userData4.originalUuid) === componentId) {
+          component = child;
+        }
+      });
+      if (!component) {
+        console.error("\u274C rotateComponent(): Component with ID '".concat(componentId, "' not found in scene"));
+        return false;
+      }
+      if (!component.userData.libraryId) {
+        console.error("\u274C rotateComponent(): Object with ID '".concat(componentId, "' is not a valid component"));
+        return false;
+      }
+
+      // Store previous rotation for potential undo
+      var previousRotation = {
+        x: component.rotation.x,
+        y: component.rotation.y,
+        z: component.rotation.z
+      };
+
+      // Convert degrees to radians
+      var radians = value * Math.PI / 180;
+      console.log("\uD83D\uDD04 rotateComponent(): Rotating component ".concat(componentId, " around ").concat(axis, " axis by ").concat(value, " degrees (").concat(radians, " radians)"));
+
+      // Apply the rotation
+      component.rotation[axis] += radians;
+
+      // Update direction vectors for connectors if this is a 90-degree rotation
+      if (value % 90 === 0) {
+        this.updateConnectorDirections(component, axis, value);
+      }
+
+      // Update matrices
+      component.updateMatrix();
+      component.updateMatrixWorld(true);
+
+      // Emit transform event if available
+      if (this.sceneViewer.emit && typeof this.sceneViewer.emit === 'function') {
+        this.sceneViewer.emit('objectTransformed', {
+          object: component,
+          transformType: 'rotate',
+          axis: axis,
+          value: value,
+          radians: radians,
+          previousRotation: previousRotation
+        });
+      }
+      console.log("\u2705 rotateComponent(): Component ".concat(componentId, " rotated successfully"));
+      return true;
+    }
+
+    /**
+     * Update connector direction vectors after component rotation
+     * @param {THREE.Object3D} component - The component that was rotated
+     * @param {string} axis - The axis of rotation ('x', 'y', or 'z')
+     * @param {number} degrees - The rotation angle in degrees (should be multiple of 90)
+     * @private
+     */
+  }, {
+    key: "updateConnectorDirections",
+    value: function updateConnectorDirections(component, axis, degrees) {
+      if (!component || degrees % 90 !== 0) {
+        return;
+      }
+      console.log("\uD83D\uDD04 Updating connector directions after ".concat(degrees, "\xB0 rotation around ").concat(axis, " axis"));
+
+      // Simple approach: just log that directions may need manual verification
+      // In most cases, Three.js world matrices handle the actual positioning correctly
+      component.traverse(function (child) {
+        var _child$userData5, _child$userData6;
+        if (((_child$userData5 = child.userData) === null || _child$userData5 === void 0 ? void 0 : _child$userData5.objectType) === 'connector' && (_child$userData6 = child.userData) !== null && _child$userData6 !== void 0 && _child$userData6.direction) {
+          console.log("\uD83D\uDCCD Connector ".concat(child.uuid, " direction may need verification after rotation"));
+        }
+      });
+    }
+
+    /**
+     * Check if a component is positioned underground (below Z=0 in Z-up coordinate system)
+     * @param {THREE.Object3D} component - The component to check
+     * @returns {Object} Object with { isUnderground: boolean, lowestZ: number, correction: number }
+     */
+  }, {
+    key: "checkComponentUnderground",
+    value: function checkComponentUnderground(component) {
+      if (!component) {
+        return {
+          isUnderground: false,
+          lowestZ: 0,
+          correction: 0
+        };
+      }
+      try {
+        // Calculate bounding box in world coordinates
+        var boundingBox = new THREE__namespace.Box3().setFromObject(component);
+
+        // In Z-up coordinate system, ground is at z=0
+        // Check the lowest Z point of the bounding box
+        var lowestZ = boundingBox.min.z;
+        var isUnderground = lowestZ < 0;
+
+        // Calculate how much we need to move up to put the lowest point at ground level
+        var correction = isUnderground ? Math.abs(lowestZ) : 0;
+        return {
+          isUnderground: isUnderground,
+          lowestZ: lowestZ,
+          correction: correction
+        };
+      } catch (error) {
+        console.warn('⚠️ Error checking component underground status:', error);
+        return {
+          isUnderground: false,
+          lowestZ: 0,
+          correction: 0
+        };
+      }
+    }
+
+    /**
+     * Fix component position if it's underground
+     * @param {THREE.Object3D} component - The component to fix
+     * @returns {boolean} True if component was adjusted, false otherwise
+     */
+  }, {
+    key: "fixUndergroundComponent",
+    value: function fixUndergroundComponent(component) {
+      if (!component) {
+        return false;
+      }
+      var checkResult = this.checkComponentUnderground(component);
+      if (checkResult.isUnderground) {
+        var _component$userData;
+        var componentId = component.uuid || ((_component$userData = component.userData) === null || _component$userData === void 0 ? void 0 : _component$userData.originalUuid) || 'unknown';
+        console.log("\uD83D\uDD27 Component ".concat(componentId, " is underground (lowest Z: ").concat(checkResult.lowestZ.toFixed(3), "), moving up by ").concat(checkResult.correction.toFixed(3)));
+
+        // Move the component up so its lowest point is at ground level (z=0)
+        component.position.z += checkResult.correction;
+
+        // Update matrices
+        component.updateMatrix();
+        component.updateMatrixWorld(true);
+        console.log("\u2705 Component ".concat(componentId, " moved to surface (new position Z: ").concat(component.position.z.toFixed(3), ")"));
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Check if a pipe segment is horizontal (Z-axis aligned in Z-up coordinate system)
+     * A segment is considered horizontal if its direction vector has minimal Z component
+     * @param {THREE.Object3D} segment - The pipe segment to check
+     * @param {number} tolerance - Angular tolerance in radians (default: ~5.7 degrees)
+     * @returns {boolean} True if segment is horizontal, false otherwise
+     * @private
+     */
+  }, {
+    key: "isSegmentHorizontal",
+    value: function isSegmentHorizontal(segment) {
+      var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.1;
+      if (!segment || !segment.geometry || !segment.quaternion) {
+        console.warn('⚠️ Invalid segment provided to isSegmentHorizontal');
+        return false;
+      }
+
+      // Get the segment's direction vector (cylinder aligned with Y-axis by default)
+      var direction = new THREE__namespace.Vector3(0, 1, 0);
+      direction.applyQuaternion(segment.quaternion);
+      direction.normalize();
+
+      // In Z-up coordinate system, horizontal segments should have Z component near 0
+      // A perfectly horizontal segment would have direction.z = 0
+      var zComponent = Math.abs(direction.z);
+
+      // Allow small tolerance for floating point precision
+      return zComponent < tolerance;
+    }
+
+    /**
+     * Calculate segment endpoints in world coordinates
+     * @param {THREE.Object3D} segment - The pipe segment
+     * @returns {Object} Object with start and end Vector3 points
+     * @private
+     */
+  }, {
+    key: "calculateSegmentEndpoints",
+    value: function calculateSegmentEndpoints(segment) {
+      // Get the segment's geometry to determine its length and orientation
+      var geometry = segment.geometry;
+      var length = geometry.parameters.height || 1;
+
+      // Calculate start and end points based on segment position and orientation
+      var startPoint = new THREE__namespace.Vector3();
+      var endPoint = new THREE__namespace.Vector3();
+
+      // Get the segment's direction vector
+      var direction = new THREE__namespace.Vector3(0, 1, 0);
+      direction.applyQuaternion(segment.quaternion);
+
+      // Calculate start point (half length back from center)
+      startPoint.copy(segment.position).sub(direction.clone().multiplyScalar(length / 2));
+
+      // Calculate end point (half length forward from center)
+      endPoint.copy(segment.position).add(direction.clone().multiplyScalar(length / 2));
+      return {
+        start: startPoint,
+        end: endPoint
+      };
+    }
+
+    /**
+     * Find all connectors (component or manual) at given positions
+     * @param {Array<THREE.Vector3>} positions - Array of positions to check
+     * @param {number} tolerance - Distance tolerance for position matching
+     * @returns {Array<THREE.Object3D>} Array of connector objects found at positions
+     * @private
+     */
+  }, {
+    key: "findConnectorsAtPositions",
+    value: function findConnectorsAtPositions(positions) {
+      var _this$sceneViewer4;
+      var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.15;
+      if (!((_this$sceneViewer4 = this.sceneViewer) !== null && _this$sceneViewer4 !== void 0 && _this$sceneViewer4.scene)) {
+        return [];
+      }
+      var foundConnectors = [];
+
+      // Traverse scene to find all connectors
+      this.sceneViewer.scene.traverse(function (child) {
+        var _child$userData7;
+        // Check if this is a connector (component connector or manual segment connector)
+        if (((_child$userData7 = child.userData) === null || _child$userData7 === void 0 ? void 0 : _child$userData7.objectType) === 'connector') {
+          // Get world position of connector
+          var connectorWorldPos = new THREE__namespace.Vector3();
+          child.getWorldPosition(connectorWorldPos);
+
+          // Check if connector is near any of the target positions
+          var _iterator = _rollupPluginBabelHelpers.createForOfIteratorHelper(positions),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var position = _step.value;
+              var distance = connectorWorldPos.distanceTo(position);
+              if (distance <= tolerance) {
+                foundConnectors.push(child);
+                break; // Don't count the same connector twice
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        }
+      });
+      return foundConnectors;
+    }
+
+    /**
+     * Update connector positions in scene data after a declared segment is moved
+     * @param {THREE.Object3D} segment - The segment whose connectors need updating
+     * @private
+     */
+  }, {
+    key: "updateSegmentConnectorPositions",
+    value: function updateSegmentConnectorPositions(segment) {
+      var _this$sceneViewer5;
+      console.log("updateSegmentConnectorPositions started:", segment);
+      if (!segment || !((_this$sceneViewer5 = this.sceneViewer) !== null && _this$sceneViewer5 !== void 0 && (_this$sceneViewer5 = _this$sceneViewer5.currentSceneData) !== null && _this$sceneViewer5 !== void 0 && _this$sceneViewer5.scene)) {
+        console.warn('⚠️ updateSegmentConnectorPositions(): Missing segment or scene data');
+        return;
+      }
+
+      // Helper function to clean up floating-point precision errors
+      var cleanPosition = function cleanPosition(value) {
+        return Math.abs(value) < 1e-10 ? 0 : value;
+      };
+
+      // Find all child connectors of the segment
+      var connectors = [];
+      segment.traverse(function (child) {
+        var _child$userData8;
+        if (((_child$userData8 = child.userData) === null || _child$userData8 === void 0 ? void 0 : _child$userData8.objectType) === 'segment-connector') {
+          connectors.push(child);
+        }
+      });
+      if (connectors.length === 0) {
+        console.warn("\u26A0\uFE0F No connectors found for segment ".concat(segment.uuid));
+        return;
+      }
+      console.log("\uD83D\uDCCD Updating ".concat(connectors.length, " connector positions in scene data for segment ").concat(segment.uuid));
+
+      // First, find the segment in scene data
+      var sceneDataSegment = this.sceneViewer.currentSceneData.scene.children.find(function (child) {
+        var _segment$userData3;
+        return child.uuid === segment.uuid || child.uuid === ((_segment$userData3 = segment.userData) === null || _segment$userData3 === void 0 ? void 0 : _segment$userData3.originalUuid);
+      });
+      if (!sceneDataSegment) {
+        console.warn("\u26A0\uFE0F Segment ".concat(segment.uuid, " not found in scene data"));
+        return;
+      }
+      if (!sceneDataSegment.children || !Array.isArray(sceneDataSegment.children)) {
+        console.warn("\u26A0\uFE0F Segment ".concat(segment.uuid, " has no children array in scene data"));
+        return;
+      }
+      console.log("\u2705 Found segment in scene data with ".concat(sceneDataSegment.children.length, " children"));
+
+      // Update each connector's position in scene data
+      connectors.forEach(function (connector) {
+        // Get world position
+        var worldPosition = new THREE__namespace.Vector3();
+        connector.getWorldPosition(worldPosition);
+
+        // Find the connector in the segment's children array (not root scene.children)
+        var sceneDataConnector = sceneDataSegment.children.find(function (child) {
+          var _connector$userData2;
+          return child.uuid === connector.uuid || child.uuid === ((_connector$userData2 = connector.userData) === null || _connector$userData2 === void 0 ? void 0 : _connector$userData2.originalUuid);
+        });
+        if (sceneDataConnector && sceneDataConnector.userData) {
+          // Update position as array [x, y, z] for pathfinder compatibility
+          sceneDataConnector.userData.position = [cleanPosition(worldPosition.x), cleanPosition(worldPosition.y), cleanPosition(worldPosition.z)];
+          console.log("\u2705 Updated connector ".concat(connector.uuid, " position to [").concat(sceneDataConnector.userData.position.join(', '), "]"));
+        } else {
+          console.warn("\u26A0\uFE0F Connector ".concat(connector.uuid, " not found in segment's children in scene data"));
+        }
+      });
+    }
+
+    /**
+     * Check if a segment intersects with any computed segments in the scene
+     * Uses segment-to-segment distance calculation, excluding endpoint connections
+     * @param {THREE.Object3D} segment - The segment to check for intersections
+     * @returns {boolean} True if segment intersects with any computed segment (not just touching at ends)
+     * @private
+     */
+  }, {
+    key: "checkSegmentIntersection",
+    value: function checkSegmentIntersection(segment) {
+      var _this$sceneViewer6,
+        _this = this;
+      if (!((_this$sceneViewer6 = this.sceneViewer) !== null && _this$sceneViewer6 !== void 0 && _this$sceneViewer6.scene)) {
+        return false;
+      }
+
+      // Get endpoints of the segment being checked
+      var segmentEndpoints = this.calculateSegmentEndpoints(segment);
+      var segmentRadius = segment.geometry.parameters.radiusTop || 0.05;
+
+      // Track if any intersection was found
+      var hasIntersection = false;
+
+      // Check all segments in the scene
+      this.sceneViewer.scene.traverse(function (child) {
+        var _child$userData9, _child$userData0;
+        // Skip the segment itself
+        if (child.uuid === segment.uuid) {
+          return;
+        }
+
+        // Only check computed segments (isDeclared === false or undefined)
+        if (((_child$userData9 = child.userData) === null || _child$userData9 === void 0 ? void 0 : _child$userData9.objectType) === 'segment' && ((_child$userData0 = child.userData) === null || _child$userData0 === void 0 ? void 0 : _child$userData0.isDeclared) !== true) {
+          // Get endpoints of the computed segment
+          var computedEndpoints = _this.calculateSegmentEndpoints(child);
+          var computedRadius = child.geometry.parameters.radiusTop || 0.05;
+
+          // Combined radius threshold - segments intersect if closer than this
+          var combinedRadius = segmentRadius + computedRadius;
+
+          // First, check if segments are connected at endpoints
+          // This is a cheaper check than full segment-to-segment distance
+          var endpointTolerance = 0.55; // Generous tolerance for endpoint connections
+
+          var d1 = segmentEndpoints.start.distanceTo(computedEndpoints.start);
+          var d2 = segmentEndpoints.start.distanceTo(computedEndpoints.end);
+          var d3 = segmentEndpoints.end.distanceTo(computedEndpoints.start);
+          var d4 = segmentEndpoints.end.distanceTo(computedEndpoints.end);
+
+          // Check if any endpoint of segment A is near any endpoint of segment B (they're connected)
+          var isConnectedAtEnds = d1 < endpointTolerance || d2 < endpointTolerance || d3 < endpointTolerance || d4 < endpointTolerance;
+
+          // If connected at ends, skip this segment (no collision)
+          if (isConnectedAtEnds) {
+            console.log("\u2705 Segments connected at endpoints - skipping intersection check (min endpoint distance: ".concat(Math.min(d1, d2, d3, d4).toFixed(3), ")"));
+            return;
+          }
+
+          // Calculate the minimum distance between the two line segments
+          var distance = _this.calculateSegmentToSegmentDistance(segmentEndpoints.start, segmentEndpoints.end, computedEndpoints.start, computedEndpoints.end);
+
+          // Only flag as intersection if segments are closer than combined radius
+          if (distance < combinedRadius) {
+            console.log("\uD83D\uDD34 Intersection detected with computed segment: ".concat(child.uuid || child.name));
+            console.log("   Distance: ".concat(distance.toFixed(3), ", Combined radius: ").concat(combinedRadius.toFixed(3)));
+            console.log("   Endpoint distances: [".concat(d1.toFixed(3), ", ").concat(d2.toFixed(3), ", ").concat(d3.toFixed(3), ", ").concat(d4.toFixed(3), "]"));
+            hasIntersection = true;
+          }
+        }
+      });
+      return hasIntersection;
+    }
+
+    /**
+     * Calculate the minimum distance between two line segments in 3D space
+     * @param {THREE.Vector3} p1 - Start point of first segment
+     * @param {THREE.Vector3} p2 - End point of first segment
+     * @param {THREE.Vector3} p3 - Start point of second segment
+     * @param {THREE.Vector3} p4 - End point of second segment
+     * @returns {number} Minimum distance between the two segments
+     * @private
+     */
+  }, {
+    key: "calculateSegmentToSegmentDistance",
+    value: function calculateSegmentToSegmentDistance(p1, p2, p3, p4) {
+      // Direction vectors
+      var d1 = new THREE__namespace.Vector3().subVectors(p2, p1); // Segment 1 direction
+      var d2 = new THREE__namespace.Vector3().subVectors(p4, p3); // Segment 2 direction
+      var r = new THREE__namespace.Vector3().subVectors(p1, p3); // Vector between start points
+
+      var a = d1.dot(d1); // Squared length of segment 1
+      var e = d2.dot(d2); // Squared length of segment 2
+      var f = d2.dot(r);
+
+      // Handle degenerate cases (zero-length segments)
+      if (a <= 1e-10 && e <= 1e-10) {
+        // Both segments are points
+        return p1.distanceTo(p3);
+      }
+      if (a <= 1e-10) {
+        // First segment is a point
+        var _t = Math.max(0, Math.min(1, f / e));
+        var closestPoint = new THREE__namespace.Vector3().addVectors(p3, d2.clone().multiplyScalar(_t));
+        return p1.distanceTo(closestPoint);
+      }
+      var c = d1.dot(r);
+      if (e <= 1e-10) {
+        // Second segment is a point
+        var _s = Math.max(0, Math.min(1, -c / a));
+        var _closestPoint = new THREE__namespace.Vector3().addVectors(p1, d1.clone().multiplyScalar(_s));
+        return p3.distanceTo(_closestPoint);
+      }
+
+      // General case - both segments have length
+      var b = d1.dot(d2);
+      var denom = a * e - b * b;
+
+      // Compute parameters for closest points
+      var s, t;
+      if (denom !== 0) {
+        s = Math.max(0, Math.min(1, (b * f - c * e) / denom));
+      } else {
+        s = 0;
+      }
+      t = (b * s + f) / e;
+      if (t < 0) {
+        t = 0;
+        s = Math.max(0, Math.min(1, -c / a));
+      } else if (t > 1) {
+        t = 1;
+        s = Math.max(0, Math.min(1, (b - c) / a));
+      }
+
+      // Calculate closest points
+      var c1 = new THREE__namespace.Vector3().addVectors(p1, d1.clone().multiplyScalar(s));
+      var c2 = new THREE__namespace.Vector3().addVectors(p3, d2.clone().multiplyScalar(t));
+      return c1.distanceTo(c2);
+    }
+  }]);
+}();
+
+exports.TransformOperationsManager = TransformOperationsManager;
+exports["default"] = TransformOperationsManager;