@2112-lab/central-plant 0.1.18 → 0.1.19

package/dist/bundle/index.js

@@ -26485,6 +26485,1238 @@ var CentralPlant = /*#__PURE__*/function () {
   }]);
 }();
 
+var SceneViewerEnhanced = /*#__PURE__*/function () {
+  function SceneViewerEnhanced(container) {
+    var centralPlant = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    _classCallCheck(this, SceneViewerEnhanced);
+    // Container element where the scene will be rendered
+    this.container = container;
+    this.centralPlant = centralPlant;
+
+    // Create Vue-like $refs object to maintain compatibility with managers
+    this.$refs = {
+      container: container
+    };
+
+    // Scene components
+    this.scene = null;
+    this.camera = null;
+    this.renderer = null;
+    this.controls = null;
+    this.currentSceneData = null;
+
+    // Flag to stop animation loop during cleanup
+    this.isDestroyed = false;
+
+    // Transform controls
+    this.transformManager = null;
+    this.selectedObjectForTransform = null;
+    this.transformMode = 'translate';
+    this.transformHistory = [];
+    this.previousTransformValues = null;
+
+    // Manager instances
+    this.disposalManager = null;
+    this.sceneExportManager = null;
+    this.componentManager = null;
+    this.sceneInitializationManager = null;
+    this.environmentManager = null;
+    this.keyboardControlsManager = null;
+    this.pathfindingManager = null;
+    this.sceneOperationsManager = null;
+    this.animationManager = null;
+    this.cameraControlsManager = null;
+    this.tooltipsManager = null;
+
+    // Scene helper utility
+    this.sceneHelper = null;
+
+    // Transform settings
+    this.shouldUpdatePaths = true;
+
+    // Event callbacks
+    this.callbacks = {
+      onSceneDataUpdated: null,
+      onObjectSelected: null,
+      onTransformUpdate: null,
+      onTransformModeChanged: null,
+      onSceneChanged: null
+    };
+  }
+
+  /**
+   * Initialize the scene viewer
+   */
+  return _createClass(SceneViewerEnhanced, [{
+    key: "init",
+    value: (function () {
+      var _init = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var _t;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              _context.p = 0;
+              if (this.centralPlant) {
+                _context.n = 1;
+                break;
+              }
+              console.error('❌ CentralPlant not provided');
+              return _context.a(2, false);
+            case 1:
+              // Set this scene viewer instance on the managers collection
+              this.centralPlant.setSceneViewer(this);
+
+              // Attach all managers and utilities to this component instance
+              this.centralPlant.attachToComponent();
+              _context.n = 2;
+              return this.initializeScene();
+            case 2:
+              return _context.a(2, true);
+            case 3:
+              _context.p = 3;
+              _t = _context.v;
+              console.error('Error during scene viewer initialization:', _t);
+              return _context.a(2, false);
+          }
+        }, _callee, this, [[0, 3]]);
+      }));
+      function init() {
+        return _init.apply(this, arguments);
+      }
+      return init;
+    }()
+    /**
+     * Initialize scene components and managers
+     */
+    )
+  }, {
+    key: "initializeScene",
+    value: (function () {
+      var _initializeScene = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        var _this = this;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              _context2.n = 1;
+              return this.sceneInitializationManager.initialize();
+            case 1:
+              _context2.n = 2;
+              return this.environmentManager.initializeEnvironment();
+            case 2:
+              // Setup keyboard controls and resize handlers
+              this.keyboardControlsManager.setupKeyboardControls();
+              this.keyboardControlsManager.setupResizeHandler();
+
+              // Initialize managers that need scene components (tooltip)
+              if (this.centralPlant) {
+                this.centralPlant.initializePostSceneManagers();
+              }
+
+              // Handle window resize to update tooltip renderer size
+              window.addEventListener('resize', function () {
+                if (_this.tooltipsManager) {
+                  _this.tooltipsManager.resize();
+                }
+              });
+
+              // Configure auto-rotation (initialize state from controls)
+              if (this.controls && this.cameraControlsManager) {
+                this.cameraControlsManager.isAutoRotating();
+              }
+
+              // Load and setup scene
+              _context2.n = 3;
+              return this.loadScene();
+            case 3:
+              // Start animation loop
+              this.animationManager.startAnimation();
+
+              // Set up event listeners for scene loading
+              this.sceneOperationsManager.setupEventListeners();
+
+              // Initialize transform controls AFTER all other initialization is complete
+              // This ensures that createTransformControls is available via attachToComponent
+              this.initTransformControls();
+
+              // Use transform manager's object selection instead of our own
+              if (this.transformManager) {
+                this.transformManager.setupObjectSelection(function (obj) {
+                  return _this.isSelectableObject(obj);
+                });
+              }
+              console.log('🔄 Transform controls will be enabled after scene loading');
+            case 4:
+              return _context2.a(2);
+          }
+        }, _callee2, this);
+      }));
+      function initializeScene() {
+        return _initializeScene.apply(this, arguments);
+      }
+      return initializeScene;
+    }()
+    /**
+     * Add event listener for scene viewer events
+     */
+    )
+  }, {
+    key: "on",
+    value: function on(eventName, callback) {
+      if (this.callbacks.hasOwnProperty("on".concat(eventName.charAt(0).toUpperCase() + eventName.slice(1)))) {
+        this.callbacks["on".concat(eventName.charAt(0).toUpperCase() + eventName.slice(1))] = callback;
+      }
+    }
+
+    /**
+     * Emit event to registered callbacks (Vue-compatible method)
+     */
+  }, {
+    key: "$emit",
+    value: function $emit(eventName, data) {
+      this.emit(eventName, data);
+    }
+
+    /**
+     * Emit event to registered callbacks
+     */
+  }, {
+    key: "emit",
+    value: function emit(eventName, data) {
+      var callbackName = "on".concat(eventName.charAt(0).toUpperCase() + eventName.slice(1).replace(/-([a-z])/g, function (g) {
+        return g[1].toUpperCase();
+      }));
+      if (this.callbacks[callbackName] && typeof this.callbacks[callbackName] === 'function') {
+        this.callbacks[callbackName](data);
+      }
+    }
+
+    /**
+     * Load scene data
+     */
+  }, {
+    key: "loadSceneData",
+    value: (function () {
+      var _loadSceneData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(data) {
+        var isImported,
+          _args3 = arguments;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              isImported = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : true;
+              if (!this.sceneOperationsManager) {
+                _context3.n = 2;
+                break;
+              }
+              _context3.n = 1;
+              return this.sceneOperationsManager.loadSceneData(data, isImported);
+            case 1:
+              // Update scene helper with new scene data
+              if (this.sceneHelper) {
+                this.sceneHelper.updateSceneData(data);
+              }
+            case 2:
+              return _context3.a(2);
+          }
+        }, _callee3, this);
+      }));
+      function loadSceneData(_x) {
+        return _loadSceneData.apply(this, arguments);
+      }
+      return loadSceneData;
+    }()
+    /**
+     * Load default scene
+     */
+    )
+  }, {
+    key: "loadScene",
+    value: (function () {
+      var _loadScene = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4() {
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              if (!this.sceneOperationsManager) {
+                _context4.n = 2;
+                break;
+              }
+              _context4.n = 1;
+              return this.sceneOperationsManager.loadScene();
+            case 1:
+              _context4.n = 3;
+              break;
+            case 2:
+              console.error('❌ SceneOperationsManager not available for loadScene');
+            case 3:
+              return _context4.a(2);
+          }
+        }, _callee4, this);
+      }));
+      function loadScene() {
+        return _loadScene.apply(this, arguments);
+      }
+      return loadScene;
+    }()
+    /**
+     * Clear scene objects while preserving base environment
+     */
+    )
+  }, {
+    key: "clearSceneObjects",
+    value: function clearSceneObjects() {
+      if (this.sceneOperationsManager) {
+        this.sceneOperationsManager.clearSceneObjects();
+      }
+    }
+
+    /**
+     * Create empty scene with just the base environment
+     */
+  }, {
+    key: "createEmptyScene",
+    value: function createEmptyScene() {
+      if (this.sceneOperationsManager) {
+        this.sceneOperationsManager.createEmptyScene();
+      }
+    }
+
+    /**
+     * Load scene from imported JSON data
+     */
+  }, {
+    key: "loadSceneFromData",
+    value: (function () {
+      var _loadSceneFromData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(data) {
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              if (!this.sceneOperationsManager) {
+                _context5.n = 1;
+                break;
+              }
+              _context5.n = 1;
+              return this.sceneOperationsManager.loadSceneFromData(data);
+            case 1:
+              return _context5.a(2);
+          }
+        }, _callee5, this);
+      }));
+      function loadSceneFromData(_x2) {
+        return _loadSceneFromData.apply(this, arguments);
+      }
+      return loadSceneFromData;
+    }()
+    /**
+     * Clear the model cache to free up memory
+     */
+    )
+  }, {
+    key: "clearModelCache",
+    value: function clearModelCache() {
+      if (this.sceneOperationsManager) {
+        this.sceneOperationsManager.clearModelCache();
+      }
+    }
+
+    /**
+     * Initialize transform controls
+     */
+  }, {
+    key: "initTransformControls",
+    value: function initTransformControls() {
+      if (!this.scene || !this.camera || !this.renderer) {
+        console.warn('⚠️ Cannot initialize transform controls: missing scene components');
+        return;
+      }
+
+      // Clean up existing transform manager if it exists
+      if (this.transformManager) {
+        console.log('🔧 Cleaning up existing transform manager before reinitializing');
+        this.transformManager.dispose();
+      }
+
+      // Create new transform controls manager using utility from centralPlant
+      this.transformManager = this.createTransformControls(this.scene, this.camera, this.renderer, this.controls // OrbitControls instance
+      );
+
+      // Register event callbacks
+      this.transformManager.on({
+        onObjectSelect: this.onObjectSelect.bind(this),
+        onTransformStart: this.onTransformStart.bind(this),
+        onTransform: this.onTransform.bind(this),
+        onTransformEnd: this.onTransformEnd.bind(this),
+        onModeChange: this.onModeChange.bind(this),
+        onObjectRemoved: this.onObjectRemoved.bind(this)
+      });
+
+      // Set up reasonable defaults
+      this.transformManager.setSnap({
+        translation: 0.5,
+        rotation: Math.PI / 2,
+        // 90 degrees
+        scale: 0.05
+      });
+
+      // Set transform controls size to 50% of default
+      this.transformManager.setSize(0.5);
+
+      // Hide multi-axis plane helpers by default (only allow single-axis translation)
+      this.transformManager.setShowPlanes(false);
+
+      // Set transform controls to invisible by default
+      if (this.transformManager.transformControls) {
+        this.transformManager.transformControls.visible = false;
+        this.transformManager.setEnabled(false);
+      }
+
+      // Check that transform controls are properly in scene
+      var isInScene = this.scene.children.includes(this.transformManager.transformControls);
+      console.log('🔧 Transform controls initialized and in scene:', isInScene ? 'YES' : 'NO');
+    }
+
+    /**
+     * Transform control event handlers
+     */
+  }, {
+    key: "onObjectSelect",
+    value: function onObjectSelect(object) {
+      this.selectedObjectForTransform = object;
+
+      // If object is null, it means we clicked away
+      if (!object) {
+        // Clear tooltip when clicking away from objects
+        if (this.tooltipsManager) {
+          this.tooltipsManager.handleSceneClick();
+        }
+
+        // Hide transform controls when clicking away
+        if (this.transformManager && this.transformManager.transformControls) {
+          this.transformManager.transformControls.enabled = false;
+          this.transformManager.transformControls.visible = false;
+        }
+        this.emit('object-selected-for-transform', null);
+        return;
+      }
+
+      // Object is selected, show transform controls
+      if (this.transformManager && this.transformManager.transformControls) {
+        this.transformManager.transformControls.enabled = true;
+        this.transformManager.transformControls.visible = true;
+      }
+
+      // Show tooltip if the object has component data
+      if (this.tooltipsManager && object && object.userData) {
+        // Make sure component exists in userData
+        if (!object.userData.component) {
+          object.userData.component = {};
+        }
+
+        // Make sure attributes exists in component 
+        if (!object.userData.component.attributes && object.userData.componentType) {
+          // Create default attributes based on component type
+          object.userData.component.attributes = {
+            'info': {
+              key: 'Type',
+              value: object.userData.componentType || 'component',
+              min: 0,
+              max: 100,
+              step: 1
+            }
+          };
+        }
+
+        // Determine the best tooltip corner position based on the object's position in the scene
+        var cornerPosition = this.determineTooltipPosition(object);
+
+        // Now set the selected mesh for tooltip display with the appropriate corner position
+        this.tooltipsManager.setSelectedMesh(object, cornerPosition);
+      } else if (this.tooltipsManager) {
+        // Clear tooltip if no valid userData
+        this.tooltipsManager.clearTooltip();
+      }
+
+      // Emit event
+      this.emit('object-selected-for-transform', object);
+    }
+  }, {
+    key: "onTransformStart",
+    value: function onTransformStart(object, mode) {
+      console.log("\uD83D\uDD27 Started ".concat(mode, " transformation on ").concat(object.uuid));
+
+      // Store the current transform mode for history tracking
+      this.transformMode = mode;
+
+      // Store previous transform values for history tracking
+      this.previousTransformValues = {
+        position: object.position.clone(),
+        rotation: object.rotation.clone(),
+        scale: object.scale.clone()
+      };
+    }
+  }, {
+    key: "onTransform",
+    value: function onTransform(object, mode) {
+      // Real-time transform feedback with both local and world coordinates
+      var transform = this.transformManager.getTransformData();
+
+      // Update tooltip position if it exists
+      if (this.tooltipsManager && object === this.tooltipsManager.selectedMesh) {
+        // Determine the best tooltip position dynamically as the object moves
+        var cornerPosition = this.determineTooltipPosition(object);
+        this.tooltipsManager.updateTooltip(cornerPosition);
+      }
+      this.emit('transform-update', transform);
+    }
+  }, {
+    key: "onTransformEnd",
+    value: function onTransformEnd(object) {
+      console.log('onTransformEnd started:', object);
+
+      // Check if the transformed object is a pipe segment and handle connector-based transformation
+      if (object && object.userData && object.userData.isPipeSegment) {
+        var segmentInfo = {
+          segmentId: object.userData.segmentId,
+          segmentIndex: object.userData.segmentIndex,
+          pathFrom: object.userData.pathFrom,
+          pathTo: object.userData.pathTo,
+          pathIndex: object.userData.pathIndex,
+          length: object.userData.length,
+          name: object.name
+        };
+        console.log('🔧 Pipe segment transformation completed:', segmentInfo);
+        console.log('📍 Pipe segment position after transform:', {
+          x: object.position.x.toFixed(3),
+          y: object.position.y.toFixed(3),
+          z: object.position.z.toFixed(3)
+        });
+
+        // Handle manual segment transformation with connector generation
+        if (this.pathfindingManager && this.currentSceneData) {
+          this.pathfindingManager.handleManualSegmentTransformation(object, this.currentSceneData);
+        } else {
+          console.warn('⚠️ PathfindingManager or CurrentSceneData not available');
+        }
+      } else {
+        console.warn('🔍 Object is not a pipe segment');
+      }
+
+      // Check if component is underground and move to surface if needed
+      var checkUnderground = this.getCheckUndergroundSetting();
+      if (checkUnderground && object.position.y < 0) {
+        console.log("\uD83D\uDD27 Component was underground (y=".concat(object.position.y.toFixed(3), "), moving to surface"));
+        object.position.y = 0;
+
+        // Update the transform controls to reflect the new position
+        if (this.transformManager && this.transformManager.transformControls) {
+          this.transformManager.transformControls.object = object;
+        }
+        console.log("\u2705 Component moved to surface (y=".concat(object.position.y.toFixed(3), ")"));
+      }
+      object.updateMatrix();
+      var worldBoundingBox = new THREE__namespace.Box3().setFromObject(object);
+      if (object.userData.associatedJsonObject) {
+        // Update jsonData.userData.worldBoundingBox as array of numbers 
+        object.userData.associatedJsonObject.userData.worldBoundingBox.min = worldBoundingBox.min.toArray();
+        object.userData.associatedJsonObject.userData.worldBoundingBox.max = worldBoundingBox.max.toArray();
+      }
+
+      // Record the transform operation in CentralPlant's transform history
+      if (this.centralPlant && this.previousTransformValues) {
+        var currentTransformValues = {
+          position: object.position.clone(),
+          rotation: object.rotation.clone(),
+          scale: object.scale.clone()
+        };
+        this.centralPlant.recordTransform({
+          type: this.transformMode || 'translate',
+          object: object,
+          values: currentTransformValues,
+          previousValues: this.previousTransformValues
+        });
+
+        // Clear previous values after recording
+        this.previousTransformValues = null;
+      }
+
+      // Delegate the complex update logic to SceneOperationsManager
+      if (this.sceneOperationsManager) {
+        this.sceneOperationsManager.updateSceneDataAfterTransform(object, this.currentSceneData);
+      }
+      if (this.shouldUpdatePaths) {
+        this.updatePaths();
+      }
+      if (typeof window !== 'undefined') {
+        // Also dispatch a general scene initialization complete event
+        console.log('📡 Dispatching sceneUpdateComplete event');
+        var sceneCompleteEvent = new CustomEvent('sceneUpdateComplete', {
+          detail: {
+            timestamp: Date.now()
+          }
+        });
+        window.dispatchEvent(sceneCompleteEvent);
+      }
+    }
+  }, {
+    key: "onModeChange",
+    value: function onModeChange(newMode, oldMode) {
+      this.transformMode = newMode;
+      console.log("\uD83D\uDD04 Transform mode: ".concat(oldMode, " \u2192 ").concat(newMode));
+
+      // Emit event
+      this.emit('transform-mode-changed', newMode);
+    }
+  }, {
+    key: "onObjectRemoved",
+    value: function onObjectRemoved(object) {
+      console.log('🗑️ Object removed:', object.uuid);
+      this.onGatewayConnectionsRevert(object);
+    }
+
+    /**
+     * Update pathfinding with new connections
+     */
+  }, {
+    key: "updatePathfindingWithConnections",
+    value: (function () {
+      var _updatePathfindingWithConnections = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(newConnections) {
+        var success;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              if (!this.pathfindingManager) {
+                _context6.n = 2;
+                break;
+              }
+              _context6.n = 1;
+              return this.pathfindingManager.updatePathfindingWithConnections(newConnections);
+            case 1:
+              success = _context6.v;
+              if (success) {
+                // Emit event to notify about the scene data change
+                this.emit('scene-data-updated', {
+                  action: 'connections-update',
+                  connections: newConnections,
+                  sceneData: this.currentSceneData
+                });
+              }
+              return _context6.a(2, success);
+            case 2:
+              return _context6.a(2, false);
+          }
+        }, _callee6, this);
+      }));
+      function updatePathfindingWithConnections(_x3) {
+        return _updatePathfindingWithConnections.apply(this, arguments);
+      }
+      return updatePathfindingWithConnections;
+    }())
+  }, {
+    key: "getPathColor",
+    value: function getPathColor(index) {
+      return this.pathfindingManager ? this.pathfindingManager.getPathColor(index) : '#468e49';
+    }
+  }, {
+    key: "updatePaths",
+    value: function updatePaths() {
+      console.log("updatePaths started");
+      // Delegate pathfinding update to PathfindingManager
+      if (this.pathfindingManager) {
+        this.pathfindingManager.updatePathfindingAfterTransform(this.currentSceneData);
+      }
+    }
+
+    /**
+     * Remove all paths
+     */
+  }, {
+    key: "removeAllPaths",
+    value: function removeAllPaths() {
+      if (this.pathfindingManager) {
+        this.pathfindingManager.removeAllPaths();
+      }
+    }
+
+    /**
+     * Recompute world bounding boxes
+     */
+  }, {
+    key: "recomputeWorldBoundingBoxes",
+    value: function recomputeWorldBoundingBoxes(currentSceneData) {
+      if (this.pathfindingManager) {
+        this.pathfindingManager.recomputeWorldBoundingBoxes(currentSceneData);
+      }
+    }
+
+    /**
+     * Gateway removal callback handlers
+     */
+  }, {
+    key: "onGatewayConnectionsRevert",
+    value: function onGatewayConnectionsRevert(gatewayInfo) {
+      console.log('🔄 Reverting gateway connections in SceneViewer:', gatewayInfo);
+
+      // Revert connections that were modified when the gateway was declared
+      if (this.currentSceneData && this.currentSceneData.connections && gatewayInfo.connections) {
+        var currentConnections = this.currentSceneData.connections;
+
+        // Revert removed connections (add them back)
+        if (gatewayInfo.connections.removed && Array.isArray(gatewayInfo.connections.removed)) {
+          console.log('🔄 Adding back removed connections:', gatewayInfo.connections.removed);
+          gatewayInfo.connections.removed.forEach(function (removedConn) {
+            // Check if connection already exists to avoid duplicates
+            var alreadyExists = currentConnections.some(function (conn) {
+              return conn.from === removedConn.from && conn.to === removedConn.to || conn.from === removedConn.to && conn.to === removedConn.from;
+            });
+            if (!alreadyExists) {
+              currentConnections.push(removedConn);
+              console.log("\uD83D\uDD04 Added back connection: ".concat(removedConn.from, " \u2192 ").concat(removedConn.to));
+            }
+          });
+        }
+
+        // Revert added connections (remove them)
+        if (gatewayInfo.connections.added && Array.isArray(gatewayInfo.connections.added)) {
+          console.log('🔄 Removing added connections:', gatewayInfo.connections.added);
+          this.currentSceneData.connections = currentConnections.filter(function (connection) {
+            var shouldRemove = gatewayInfo.connections.added.some(function (addedConn) {
+              return addedConn.from === connection.from && addedConn.to === connection.to || addedConn.from === connection.to && addedConn.to === connection.from;
+            });
+            if (shouldRemove) {
+              console.log("\uD83D\uDD04 Removed connection: ".concat(connection.from, " \u2192 ").concat(connection.to));
+            }
+            return !shouldRemove;
+          });
+        }
+        console.log('✅ Gateway connections reverted. Total connections:', this.currentSceneData.connections.length);
+      }
+      console.log('Executing pathfinding to regenerate gateway:', gatewayInfo.uuid);
+
+      // Remove the gateway from scene data so it can be regenerated
+      this.currentSceneData.scene.object.children = this.currentSceneData.scene.object.children.filter(function (child) {
+        return child.uuid !== gatewayInfo.uuid;
+      });
+      console.log('🗑️ Removed gateway from scene data for regeneration', this.currentSceneData);
+
+      // Recalculate bounding boxes
+      this.recomputeWorldBoundingBoxes(this.currentSceneData);
+
+      // Execute pathfinding with updated scene data
+      this.pathfindingManager.updatePathfindingAfterTransform(this.currentSceneData).then(function () {
+        console.log('✅ Pathfinding completed - gateway regenerated automatically');
+      }).catch(function (error) {
+        console.error('❌ Error during pathfinding execution:', error);
+      });
+    }
+
+    /**
+     * Check if object is selectable for transformation
+     */
+  }, {
+    key: "isSelectableObject",
+    value: function isSelectableObject(object) {
+      var _object$userData, _object$userData2;
+      if (object.type == "TransformControlsPlane") {
+        object = object.object;
+      }
+
+      // Allow pipe segments and junctions to be selected
+      var isPipeSegment = ((_object$userData = object.userData) === null || _object$userData === void 0 ? void 0 : _object$userData.isPipeSegment) === true;
+      var isPipeJunction = ((_object$userData2 = object.userData) === null || _object$userData2 === void 0 ? void 0 : _object$userData2.isPipeJunction) === true;
+      if (isPipeSegment) {
+        return true;
+      }
+
+      // Exclude regular polyline parent objects (pipe paths) from selection
+      if (object.name && object.name.toLowerCase().includes("polyline") && !isPipeSegment && !isPipeJunction) {
+        return false;
+      }
+
+      // Check for different component types using userData.componentType
+      var isGLBModel = object.userData && object.userData.componentType === 'component';
+      var isConnector = object.userData && object.userData.componentType === 'connector';
+      var isGateway = object.userData && object.userData.componentType === 'gateway';
+      var canTransform = (object.isMesh || object.isObject3D) && (isGLBModel || isConnector || isGateway) && object.visible;
+      return canTransform;
+    }
+
+    /**
+     * Select object for transformation
+     */
+  }, {
+    key: "selectObjectForTransform",
+    value: function selectObjectForTransform(object) {
+      // Safety check: ensure object is valid before selecting
+      if (!object || !object.parent) {
+        console.warn('⚠️ Cannot select invalid object for transform');
+        return;
+      }
+      if (this.transformManager) {
+        this.transformManager.selectObject(object);
+      }
+    }
+
+    /**
+     * Deselect currently selected object
+     */
+  }, {
+    key: "deselectObject",
+    value: function deselectObject() {
+      if (this.transformManager) {
+        this.transformManager.deselectObject();
+      }
+      this.selectedObjectForTransform = null;
+    }
+
+    /**
+     * Public API method to select an object in the scene
+     */
+  }, {
+    key: "selectObject",
+    value: function selectObject(object) {
+      if (!object || !object.uuid) {
+        console.warn('⚠️ Cannot select invalid object');
+        return false;
+      }
+
+      // Select the object for transformation
+      this.selectObjectForTransform(object);
+
+      // Emit event
+      this.emit('object-selected-for-transform', object);
+      return true;
+    }
+
+    /**
+     * Get currently selected object transform data
+     */
+  }, {
+    key: "getSelectedTransform",
+    value: function getSelectedTransform() {
+      var _this$transformManage;
+      return ((_this$transformManage = this.transformManager) === null || _this$transformManage === void 0 ? void 0 : _this$transformManage.getTransformData()) || null;
+    }
+
+    /**
+     * Component management methods
+     */
+  }, {
+    key: "addComponentToScene",
+    value: (function () {
+      var _addComponentToScene = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(componentData) {
+        var result, _t2;
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
+            case 0:
+              if (!this.componentManager) {
+                _context7.n = 2;
+                break;
+              }
+              _context7.n = 1;
+              return this.componentManager.addComponentToScene(componentData);
+            case 1:
+              _t2 = _context7.v;
+              _context7.n = 3;
+              break;
+            case 2:
+              _t2 = false;
+            case 3:
+              result = _t2;
+              if (result) {
+                this.emit('scene-changed', {
+                  action: 'add',
+                  data: componentData
+                });
+              }
+              return _context7.a(2, result);
+          }
+        }, _callee7, this);
+      }));
+      function addComponentToScene(_x4) {
+        return _addComponentToScene.apply(this, arguments);
+      }
+      return addComponentToScene;
+    }())
+  }, {
+    key: "removeComponentFromScene",
+    value: function removeComponentFromScene(componentUuid) {
+      var result = this.componentManager ? this.componentManager.removeComponentFromScene(componentUuid) : false;
+      if (result) {
+        this.emit('scene-changed', {
+          action: 'remove',
+          uuid: componentUuid
+        });
+      }
+      return result;
+    }
+  }, {
+    key: "getSceneComponents",
+    value: function getSceneComponents() {
+      return this.componentManager ? this.componentManager.getSceneComponents() : [];
+    }
+  }, {
+    key: "updateComponent",
+    value: function updateComponent(componentUuid, updates) {
+      return this.componentManager ? this.componentManager.updateComponent(componentUuid, updates) : false;
+    }
+
+    /**
+     * Export scene data
+     */
+  }, {
+    key: "exportSceneData",
+    value: function exportSceneData() {
+      return this.sceneExportManager ? this.sceneExportManager.exportSceneData() : null;
+    }
+  }, {
+    key: "downloadSceneExport",
+    value: function downloadSceneExport() {
+      var filename = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      return this.sceneExportManager ? this.sceneExportManager.downloadSceneExport(filename) : false;
+    }
+
+    /**
+     * Tooltip management methods
+     */
+  }, {
+    key: "updateTooltipForObject",
+    value: function updateTooltipForObject(object, cornerPosition) {
+      if (this.tooltipsManager && object) {
+        // If no specific corner position provided, determine the best one
+        if (!cornerPosition) {
+          cornerPosition = this.determineTooltipPosition(object);
+        }
+
+        // Update the tooltip for the specified object with the corner position
+        this.tooltipsManager.setSelectedMesh(object, cornerPosition);
+      }
+    }
+  }, {
+    key: "clearAllTooltips",
+    value: function clearAllTooltips() {
+      if (this.tooltipsManager) {
+        this.tooltipsManager.clearTooltip();
+      }
+    }
+
+    /**
+     * Helper method to determine the best tooltip position based on the object's position in the scene
+     */
+  }, {
+    key: "determineTooltipPosition",
+    value: function determineTooltipPosition(object) {
+      if (!object || !this.camera || !this.scene) {
+        return 'top-right'; // Default position
+      }
+
+      // Get the object's world position
+      var objPosition = new THREE__namespace.Vector3();
+      object.getWorldPosition(objPosition);
+
+      // Project the object's position to screen space
+      var screenPosition = objPosition.clone();
+      screenPosition.project(this.camera);
+
+      // Convert to normalized device coordinates (-1 to +1)
+      var x = screenPosition.x;
+      var y = screenPosition.y;
+
+      // Determine the best position based on the screen quadrant
+      if (x > 0 && y > 0) {
+        // Top-right quadrant - place tooltip at top-left
+        return 'top-left';
+      } else if (x <= 0 && y > 0) {
+        // Top-left quadrant - place tooltip at top-right
+        return 'top-right';
+      } else if (x > 0 && y <= 0) {
+        // Bottom-right quadrant - place tooltip at top-left
+        return 'top-left';
+      } else {
+        // Bottom-left quadrant - place tooltip at top-right
+        return 'top-right';
+      }
+    }
+
+    /**
+     * Helper method to get the checkUnderground setting from localStorage
+     */
+  }, {
+    key: "getCheckUndergroundSetting",
+    value: function getCheckUndergroundSetting() {
+      try {
+        if (typeof window !== 'undefined' && window.localStorage) {
+          var savedSettings = localStorage.getItem('sceneConfigurations');
+          if (savedSettings) {
+            var parsed = JSON.parse(savedSettings);
+            // Default to true if not explicitly set to false
+            return parsed.checkUnderground !== false;
+          }
+        }
+      } catch (error) {
+        console.warn('⚠️ Error reading checkUnderground setting from localStorage:', error);
+      }
+
+      // Default to true if localStorage is not available or has errors
+      return true;
+    }
+
+    /**
+     * Toggle shouldUpdatePaths setting
+     */
+  }, {
+    key: "toggleshouldUpdatePaths",
+    value: function toggleshouldUpdatePaths() {
+      this.shouldUpdatePaths = !this.shouldUpdatePaths;
+      console.log("\uD83D\uDD04 shouldUpdatePaths ".concat(this.shouldUpdatePaths ? 'enabled' : 'disabled'));
+
+      // Also log current state for clarity
+      if (this.shouldUpdatePaths) {
+        console.log('✅ Path recalculation will occur after component transforms');
+        this.updatePaths();
+      } else {
+        console.log('⚠️ Path recalculation disabled - manual scene reload may be needed');
+      }
+      return this.shouldUpdatePaths;
+    }
+
+    /**
+     * Transform controls management
+     */
+  }, {
+    key: "disableTransformControls",
+    value: function disableTransformControls() {
+      console.log('🔧 Manually disabling transform controls');
+      if (!this.transformManager) {
+        console.warn('⚠️ No transform manager found to disable');
+        return false;
+      }
+
+      // Deselect any selected object
+      if (this.transformManager.selectedObject) {
+        this.transformManager.deselectObject();
+      }
+
+      // Disable controls and set visibility to false
+      if (this.transformManager.transformControls) {
+        this.transformManager.setEnabled(false);
+        this.transformManager.transformControls.visible = false;
+        console.log('✅ Transform controls disabled');
+        return true;
+      }
+      console.warn('⚠️ Transform controls not found in manager');
+      return false;
+    }
+  }, {
+    key: "enableTransformControls",
+    value: function enableTransformControls() {
+      console.log('🔧 Manually enabling transform controls');
+      if (!this.transformManager) {
+        console.warn('⚠️ No transform manager found to enable');
+        return false;
+      }
+
+      // Check if we should enable transform controls
+      // Only enable if we have actual objects in the scene (not an empty scene)
+      var hasNonBaseObjects = false;
+      this.scene.traverse(function (child) {
+        var _child$userData, _child$userData2, _child$userData3, _child$geometry;
+        if (child.isMesh && !((_child$userData = child.userData) !== null && _child$userData !== void 0 && _child$userData.isBaseGround) && !((_child$userData2 = child.userData) !== null && _child$userData2 !== void 0 && _child$userData2.isBrickWall) && !((_child$userData3 = child.userData) !== null && _child$userData3 !== void 0 && _child$userData3.isBaseGrid) && ((_child$geometry = child.geometry) === null || _child$geometry === void 0 ? void 0 : _child$geometry.type) !== 'PlaneGeometry') {
+          hasNonBaseObjects = true;
+        }
+      });
+
+      // Don't enable controls for empty scenes
+      if (!hasNonBaseObjects) {
+        console.log('🔧 No objects to transform in scene, keeping transform controls disabled');
+        return false;
+      }
+
+      // Enable controls and set visibility to true  
+      if (this.transformManager.transformControls) {
+        // Reset the force invisible flag to allow controls to become visible
+        this.transformManager.forceInvisible = false;
+        this.transformManager.setEnabled(true);
+        this.transformManager.transformControls.visible = true;
+        console.log('✅ Transform controls enabled');
+        return true;
+      }
+      console.warn('⚠️ Transform controls not found in manager');
+      return false;
+    }
+  }, {
+    key: "keepTransformControlsInactive",
+    value: function keepTransformControlsInactive() {
+      if (this.transformManager && this.transformManager.transformControls) {
+        console.log('🔄 Ensuring transform controls remain inactive after scene load');
+        this.transformManager.setEnabled(false);
+        this.transformManager.transformControls.visible = false;
+
+        // Set force invisible flag to prevent any selection from making controls visible
+        this.transformManager.forceInvisible = true;
+
+        // Deselect any selected object to ensure clean state
+        if (this.transformManager.selectedObject) {
+          this.transformManager.deselectObject();
+        }
+      }
+    }
+  }, {
+    key: "setMultiAxisTranslation",
+    value: function setMultiAxisTranslation(enabled) {
+      if (!this.transformManager) {
+        console.warn('⚠️ No transform manager found');
+        return false;
+      }
+      return this.transformManager.setShowPlanes(enabled);
+    }
+  }, {
+    key: "ensureTransformControlsAttached",
+    value: function ensureTransformControlsAttached() {
+      var allowVisible = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      // Check if transform manager exists
+      if (!this.transformManager) {
+        console.log('🔧 No transform manager found, initializing transform controls...');
+        this.initTransformControls();
+        return;
+      }
+
+      // Check if transform controls exist in the manager
+      if (!this.transformManager.transformControls) {
+        console.log('🔧 Transform controls not found in manager, reinitializing...');
+        this.transformManager.createTransformControls();
+        this.transformManager.setupEventListeners();
+        console.log('✅ Transform controls recreated in manager');
+        return;
+      }
+
+      // Use the TransformControlsManager's built-in method for reattachment
+      var wasReattached = this.transformManager.ensureSceneAttachment(allowVisible);
+      if (wasReattached) {
+        console.log('🔧 Transform controls were reattached after scene operation');
+
+        // Override visibility based on allowVisible parameter
+        if (!allowVisible && this.transformManager.transformControls) {
+          this.transformManager.transformControls.visible = false;
+          console.log('🔧 Forcing transform controls to be invisible during load');
+        }
+      } else {
+        console.log('✓ Transform controls are properly attached');
+
+        // Still ensure visibility is set correctly even if not reattached
+        if (!allowVisible && this.transformManager.transformControls) {
+          this.transformManager.transformControls.visible = false;
+          console.log('🔧 Ensuring transform controls remain invisible during load');
+        }
+      }
+    }
+
+    /**
+     * Clean up transform controls
+     */
+  }, {
+    key: "cleanupTransformControls",
+    value: function cleanupTransformControls() {
+      console.log('🧹 Cleaning up transform controls...');
+      if (this.transformManager) {
+        // First deselect any object
+        if (this.transformManager.selectedObject) {
+          this.transformManager.deselectObject();
+        }
+
+        // Explicitly disable transform controls
+        if (this.transformManager.transformControls) {
+          console.log('🔧 Disabling transform controls before disposal');
+          this.transformManager.setEnabled(false);
+          this.transformManager.transformControls.visible = false;
+        }
+
+        // Now dispose of the transform controls
+        this.transformManager.dispose();
+        this.transformManager = null;
+      }
+      this.selectedObjectForTransform = null;
+      this.transformHistory = [];
+      console.log('✅ Transform controls cleanup completed');
+    }
+
+    /**
+     * Manual cleanup method that can be called externally
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      console.log('🔧 Manual cleanup requested');
+      this.dispose();
+    }
+
+    /**
+     * Utility method to check if scene is properly disposed
+     */
+  }, {
+    key: "isDisposed",
+    value: function isDisposed() {
+      return this.isDestroyed || !this.scene || !this.renderer || !this.camera;
+    }
+
+    /**
+     * Comprehensive cleanup and disposal
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      console.log('Starting comprehensive scene cleanup...');
+
+      // Stop animation loop by setting a flag
+      this.isDestroyed = true;
+      try {
+        // Use disposal manager for comprehensive cleanup
+        if (this.disposalManager) {
+          try {
+            this.disposalManager.cleanupEventListeners();
+            this.disposalManager.cleanupControls();
+            this.disposalManager.cleanupGlobalReferences();
+          } catch (e) {
+            console.error('Error during disposal manager cleanup:', e);
+          }
+        }
+
+        // Clean up transform controls
+        try {
+          this.cleanupTransformControls();
+        } catch (e) {
+          console.error('Error cleaning up transform controls:', e);
+        }
+
+        // Clean up tooltip manager
+        if (this.tooltipsManager) {
+          try {
+            console.log('Disposing tooltip manager...');
+            this.tooltipsManager.dispose();
+          } catch (e) {
+            console.error('Error disposing tooltip manager:', e);
+          } finally {
+            // Ensure reference is always nullified even if disposal fails
+            this.tooltipsManager = null;
+          }
+        }
+
+        // Dispose of scene objects and materials
+        if (this.disposalManager) {
+          try {
+            this.disposalManager.cleanupScene();
+            this.disposalManager.cleanupRenderer();
+          } catch (e) {
+            console.error('Error during scene and renderer cleanup:', e);
+          } finally {
+            this.disposalManager = null;
+          }
+        }
+        console.log('Scene cleanup completed');
+      } catch (e) {
+        console.error('Unexpected error during scene cleanup:', e);
+      }
+    }
+  }]);
+}();
+
 var _MathUtils;
 /**
  * MathUtils
@@ -36941,6 +38173,7 @@ exports.SceneInitializationManager = SceneInitializationManager;
 exports.SceneOperationsManager = SceneOperationsManager;
 exports.SceneTooltipsManager = SceneTooltipsManager;
 exports.SceneViewer = SceneViewer;
+exports.SceneViewerEnhanced = SceneViewerEnhanced;
 exports.Testing = testing;
 exports.createTransformControls = createTransformControls;
 exports.findObjectByHardcodedUuid = findObjectByHardcodedUuid;