@2112-lab/central-plant 0.1.39 → 0.1.41

package/dist/esm/src/managers/scene/sceneOperationsManager.js

@@ -345,11 +345,6 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         // If a gateway appears in the JSON, it's manual by definition
         mesh.userData.isDeclared = true;
       }
-
-      // For gateways, also set origin flag for backward compatibility
-      if (mesh.userData.objectType === 'gateway') {
-        mesh.userData.origin = 'declared'; // Explicit origin marker for manual gateways
-      }
       if (mesh.isMesh) {
         mesh.castShadow = true;
         mesh.receiveShadow = true;
@@ -440,6 +435,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         // Check if we have crosscubeTextureSet from scene loading
         var crosscubeTextureSet = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.crosscubeTextureSet;
         if (crosscubeTextureSet) {
+          // Match PathfindingManager.createPipeMaterial() with textures
           var pathColor = '#245e29'; // Default green color from PathfindingManager.getPathColor()
 
           var materialProps = _objectSpread2(_objectSpread2({}, crosscubeTextureSet.config.materialProps), {}, {
@@ -490,7 +486,6 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       // Initialize userData
       segmentMesh.userData = _objectSpread2(_objectSpread2({}, obj.userData), {}, {
         originalUuid: obj.uuid,
-        isPipeSegment: true,
         isDeclared: true
       });
 
@@ -563,7 +558,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         }
         _connectorMesh.userData = _objectSpread2(_objectSpread2({}, connectorData.userData), {}, {
           originalUuid: connectorData.uuid,
-          objectType: 'connector',
+          objectType: 'segment-connector',
           isManualSegmentConnector: true,
           isDeclared: true // Manual segment connectors are always declared (user-created)
         });
@@ -583,7 +578,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       // Initialize userData
       connectorMesh.userData = _objectSpread2(_objectSpread2({}, connectorData.userData), {}, {
         originalUuid: connectorData.uuid,
-        objectType: 'connector',
+        objectType: 'segment-connector',
         isManualSegmentConnector: true,
         isDeclared: true // Manual segment connectors are always declared (user-created)
       });
@@ -655,18 +650,15 @@ var SceneOperationsManager = /*#__PURE__*/function () {
               jsonObject.userData.position = [worldPos.x, worldPos.y, worldPos.z];
               console.log("\u2705 Set userData.position for ".concat(jsonObject.userData.objectType, " ").concat(jsonObject.uuid, ": [").concat(worldPos.x.toFixed(2), ", ").concat(worldPos.y.toFixed(2), ", ").concat(worldPos.z.toFixed(2), "]"));
 
-              // For gateways, ensure origin and isDeclared flags are in scene data
+              // For gateways, ensure isDeclared flag is in scene data
               if (jsonObject.userData.objectType === 'gateway') {
-                if (!jsonObject.userData.origin) {
-                  jsonObject.userData.origin = 'declared'; // Mark as declared gateway
-                }
                 if (jsonObject.userData.isDeclared === undefined) {
                   jsonObject.userData.isDeclared = true;
                 }
               }
 
               // For manual segment connectors, ensure isDeclared is set in scene data
-              if (jsonObject.userData.isManualSegmentConnector && jsonObject.userData.isDeclared === undefined) {
+              if (jsonObject.userData.objectType === 'segment-connector' && jsonObject.userData.isDeclared === undefined) {
                 jsonObject.userData.isDeclared = true;
                 console.log("\u2705 Set isDeclared=true for manual segment connector in scene data: ".concat(jsonObject.uuid));
               }
@@ -760,6 +752,9 @@ var SceneOperationsManager = /*#__PURE__*/function () {
               _context5.n = 1;
               return this.clearSceneObjects();
             case 1:
+              // Mark all imported objects as declared in the scene data
+              // This ensures manual segment connectors and other objects are recognized as declared
+              this._markImportedObjectsAsDeclared(data);
               component.currentSceneData = data;
             case 2:
               return _context5.a(2);
@@ -771,19 +766,55 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       }
       return _prepareSceneForLoading;
     }()
+    /**
+     * Recursively mark all objects in imported scene data as declared
+     * This ensures that manual segments and their connectors are properly recognized
+     * @param {Object} data - Scene data object
+     */
+    )
+  }, {
+    key: "_markImportedObjectsAsDeclared",
+    value: function _markImportedObjectsAsDeclared(data) {
+      var _data$scene;
+      if (!(data !== null && data !== void 0 && (_data$scene = data.scene) !== null && _data$scene !== void 0 && _data$scene.children)) {
+        return;
+      }
+      var _markChildren = function markChildren(children) {
+        if (!Array.isArray(children)) {
+          return;
+        }
+        children.forEach(function (child) {
+          if (!child.userData) {
+            child.userData = {};
+          }
+
+          // Set isDeclared to true for all imported objects
+          if (child.userData.isDeclared === undefined) {
+            child.userData.isDeclared = true;
+          }
+
+          // Recursively process children (e.g., manual segment connectors)
+          if (child.children && Array.isArray(child.children)) {
+            _markChildren(child.children);
+          }
+        });
+      };
+      _markChildren(data.scene.children);
+      console.log('✅ Marked all imported objects as declared in scene data');
+    }
+
     /**
      * Inject connector children from component dictionary into scene data components
      * This allows scene files to omit connector children since they're defined in the dictionary
      * @param {Object} data - Scene data to modify
      * @param {Object} componentDictionary - Component dictionary with connector definitions
      */
-    )
   }, {
     key: "_injectConnectorChildrenFromDictionary",
     value: function _injectConnectorChildrenFromDictionary(data, componentDictionary) {
-      var _data$scene,
+      var _data$scene2,
         _this3 = this;
-      if (!(data !== null && data !== void 0 && (_data$scene = data.scene) !== null && _data$scene !== void 0 && _data$scene.children) || !componentDictionary) {
+      if (!(data !== null && data !== void 0 && (_data$scene2 = data.scene) !== null && _data$scene2 !== void 0 && _data$scene2.children) || !componentDictionary) {
         return;
       }
       var componentsProcessed = 0;
@@ -1083,7 +1114,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
     key: "loadSceneFromData",
     value: (function () {
       var _loadSceneFromData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(data) {
-        var _data$scene2, _data$scene3, _data$scene4, _data$scene5;
+        var _data$scene3, _data$scene4, _data$scene5, _data$scene6;
         return _regenerator().w(function (_context9) {
           while (1) switch (_context9.n) {
             case 0:
@@ -1093,10 +1124,10 @@ var SceneOperationsManager = /*#__PURE__*/function () {
                 dataType: _typeof(data),
                 hasScene: !!(data !== null && data !== void 0 && data.scene),
                 sceneType: _typeof(data === null || data === void 0 ? void 0 : data.scene),
-                hasChildren: !!(data !== null && data !== void 0 && (_data$scene2 = data.scene) !== null && _data$scene2 !== void 0 && _data$scene2.children),
-                childrenType: data !== null && data !== void 0 && (_data$scene3 = data.scene) !== null && _data$scene3 !== void 0 && _data$scene3.children ? _typeof(data.scene.children) : 'undefined',
-                isArray: Array.isArray(data === null || data === void 0 || (_data$scene4 = data.scene) === null || _data$scene4 === void 0 ? void 0 : _data$scene4.children),
-                childrenLength: data === null || data === void 0 || (_data$scene5 = data.scene) === null || _data$scene5 === void 0 || (_data$scene5 = _data$scene5.children) === null || _data$scene5 === void 0 ? void 0 : _data$scene5.length,
+                hasChildren: !!(data !== null && data !== void 0 && (_data$scene3 = data.scene) !== null && _data$scene3 !== void 0 && _data$scene3.children),
+                childrenType: data !== null && data !== void 0 && (_data$scene4 = data.scene) !== null && _data$scene4 !== void 0 && _data$scene4.children ? _typeof(data.scene.children) : 'undefined',
+                isArray: Array.isArray(data === null || data === void 0 || (_data$scene5 = data.scene) === null || _data$scene5 === void 0 ? void 0 : _data$scene5.children),
+                childrenLength: data === null || data === void 0 || (_data$scene6 = data.scene) === null || _data$scene6 === void 0 || (_data$scene6 = _data$scene6.children) === null || _data$scene6 === void 0 ? void 0 : _data$scene6.length,
                 dataKeys: data ? Object.keys(data) : [],
                 sceneKeys: data !== null && data !== void 0 && data.scene ? Object.keys(data.scene) : []
               });
@@ -1281,6 +1312,470 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         return false;
       }
     }
+
+    // ===== MANUAL SEGMENT AND GATEWAY OPERATIONS =====
+
+    /**
+     * Handle manual segment transformation by creating connectors and restructuring connections
+     * @param {THREE.Object3D} segment - The transformed pipe segment
+     * @param {Object} currentSceneData - Current scene data with connections
+     */
+  }, {
+    key: "manualizeSegment",
+    value: function manualizeSegment(segment, currentSceneData) {
+      var _segment$userData, _this$sceneViewer$man;
+      if (!segment || !((_segment$userData = segment.userData) !== null && _segment$userData !== void 0 && _segment$userData.objectType) === 'segment') {
+        console.log('❌ Object is not a pipe segment:', {
+          isObject: !!segment,
+          hasUserData: !!(segment && segment.userData)
+        });
+        return;
+      }
+      console.log('🔧 Handling manual segment transformation:', segment.uuid);
+
+      // Get access to pathfinding manager's connector manager
+      var pathfindingManager = (_this$sceneViewer$man = this.sceneViewer.managers) === null || _this$sceneViewer$man === void 0 ? void 0 : _this$sceneViewer$man.pathfindingManager;
+      if (!pathfindingManager || !pathfindingManager.connectorManager) {
+        console.error('❌ PathfindingManager or ConnectorManager not available');
+        return;
+      }
+      var connectorManager = pathfindingManager.connectorManager;
+      var sceneDataManager = pathfindingManager.sceneDataManager;
+
+      // IMPORTANT: Rename UUID FIRST to prevent removal by removeComputedObjects()
+      // This must happen before convertConnectedGatewaysToManual() which triggers path regeneration
+      // Change from "SEGMENT-X" to "Segment-X" (capital S to lowercase s)
+      var segmentIndex = segment.userData.segmentIndex;
+      var oldUuid = segment.uuid;
+      segment.uuid = "Segment-".concat(segmentIndex);
+      console.log("\uD83D\uDD27 Renamed segment UUID from ".concat(oldUuid, " to: ").concat(segment.uuid));
+
+      // Calculate segment endpoints in world coordinates
+      var segmentEndpoints = connectorManager.calculateSegmentEndpoints(segment);
+      console.log('📍 Segment endpoints:', segmentEndpoints);
+
+      // Create connectors at the segment endpoints
+      var connectors = connectorManager.createSegmentConnectors(segment, segmentEndpoints);
+      console.log('🔌 Created connectors:', connectors);
+
+      // IMPORTANT: Mark segment as declared FIRST to ensure it exists in scene data
+      // This must happen BEFORE addConnectorsToScene so connectors have a parent to attach to
+      segment.userData.manualConnectors = connectors.map(function (c) {
+        return c.uuid;
+      });
+      sceneDataManager.markObjectAsDeclared(segment, currentSceneData, {});
+      console.log('✅ Segment marked as declared in scene data');
+
+      // Now add connectors to the segment's children array in scene data
+      connectorManager.addConnectorsToScene(connectors);
+
+      // Find the original connection that this segment belongs to (after gateways are converted)
+      var originalConnection = connectorManager.findOriginalConnection(segment, currentSceneData.connections);
+      if (!originalConnection) {
+        console.warn('⚠️ Could not find original connection for segment:', segment.uuid);
+        return;
+      }
+      console.log('🔍 Found original connection:', originalConnection);
+      var authoritativeConnectorUUID = originalConnection.from.includes("Gateway") === false ? originalConnection.from : originalConnection.to;
+      console.log('[SceneOperations] authoritativeConnectorUUID:', authoritativeConnectorUUID);
+
+      // Check and convert connected gateways to manual (declared)
+      // NOTE: This may trigger path regeneration via translateGateway, so segment must already be renamed
+      var convertedGatewayUUIDs = this._convertConnectedGatewaysToManual(connectors, currentSceneData);
+
+      // Restructure connections, passing any converted gateway UUIDs
+      connectorManager.restructureConnections(authoritativeConnectorUUID, connectors, currentSceneData, convertedGatewayUUIDs);
+
+      // Mark segment as manually positioned and declared
+      segment.userData.manualConnectors = connectors.map(function (c) {
+        return c.uuid;
+      });
+
+      // Use shared helper to mark as declared and add to scene data
+      sceneDataManager.markObjectAsDeclared(segment, currentSceneData, {});
+
+      // Verify segment structure in scene data
+      var segmentInSceneData = currentSceneData.scene.children.find(function (child) {
+        return child.uuid === segment.uuid;
+      });
+      if (segmentInSceneData) {
+        var _segmentInSceneData$c, _segmentInSceneData$c2;
+        console.log("\uD83D\uDCCA Segment in scene data:", {
+          uuid: segmentInSceneData.uuid,
+          hasChildren: !!segmentInSceneData.children,
+          childrenCount: ((_segmentInSceneData$c = segmentInSceneData.children) === null || _segmentInSceneData$c === void 0 ? void 0 : _segmentInSceneData$c.length) || 0,
+          childrenUUIDs: ((_segmentInSceneData$c2 = segmentInSceneData.children) === null || _segmentInSceneData$c2 === void 0 ? void 0 : _segmentInSceneData$c2.map(function (c) {
+            return c.uuid;
+          })) || []
+        });
+      }
+      console.log('✅ Manual segment transformation completed');
+    }
+
+    /**
+     * Check and convert gateways at the original path endpoints to manual (declared)
+     * This method now delegates to manualizeGateway to ensure consistent gateway handling
+     * @param {Array} connectors - Array of connector objects (used to get segment reference)
+     * @param {Object} currentSceneData - Current scene data
+     * @returns {Array<string>} Array of converted gateway UUIDs
+     * @private
+     */
+  }, {
+    key: "_convertConnectedGatewaysToManual",
+    value: function _convertConnectedGatewaysToManual(connectors, currentSceneData) {
+      var _connectors$,
+        _segment$userData2,
+        _this5 = this;
+      console.log('🔍 Checking for connected gateways to convert to manual...');
+      var sceneViewer = this.sceneViewer;
+      var convertedGateways = [];
+
+      // Get the segment from the first connector's userData
+      var segment = (_connectors$ = connectors[0]) !== null && _connectors$ !== void 0 && (_connectors$ = _connectors$.userData) !== null && _connectors$ !== void 0 && _connectors$.manualSegmentUuid ? sceneViewer.scene.getObjectByProperty('uuid', connectors[0].userData.manualSegmentUuid) : null;
+      if (!segment || !((_segment$userData2 = segment.userData) !== null && _segment$userData2 !== void 0 && _segment$userData2.objectType) === 'segment') {
+        console.log('❌ Could not find segment for gateway conversion');
+        return [];
+      }
+      var pathFrom = segment.userData.pathFrom;
+      var pathTo = segment.userData.pathTo;
+      console.log("\uD83D\uDD0D Checking original path endpoints for gateways: ".concat(pathFrom, " \u2192 ").concat(pathTo));
+
+      // Check the original path endpoints for gateways
+      [pathFrom, pathTo].forEach(function (endpointUuid) {
+        console.log("\uD83D\uDD0D Checking endpoint: ".concat(endpointUuid));
+
+        // Find the object in the scene that corresponds to this endpoint
+        var endpointObject = null;
+        sceneViewer.scene.traverse(function (obj) {
+          var _obj$userData3;
+          if (obj.uuid === endpointUuid || ((_obj$userData3 = obj.userData) === null || _obj$userData3 === void 0 ? void 0 : _obj$userData3.originalUuid) === endpointUuid) {
+            endpointObject = obj;
+          }
+        });
+        if (endpointObject) {
+          var _endpointObject$userD, _endpointObject$userD2, _endpointObject$userD3, _endpointObject$userD4, _endpointObject$userD5, _endpointObject$userD6;
+          console.log("\uD83D\uDD0D Found endpoint object: ".concat(endpointObject.uuid, " - objectType: ").concat((_endpointObject$userD = endpointObject.userData) === null || _endpointObject$userD === void 0 ? void 0 : _endpointObject$userD.objectType, ", isDeclared: ").concat((_endpointObject$userD2 = endpointObject.userData) === null || _endpointObject$userD2 === void 0 ? void 0 : _endpointObject$userD2.isDeclared));
+
+          // Check if this endpoint is a gateway that needs to be converted to manual
+          // IMPORTANT: Only convert if it's NOT already declared to prevent double-processing
+          if (((_endpointObject$userD3 = endpointObject.userData) === null || _endpointObject$userD3 === void 0 ? void 0 : _endpointObject$userD3.objectType) === 'gateway' && ((_endpointObject$userD4 = endpointObject.userData) === null || _endpointObject$userD4 === void 0 ? void 0 : _endpointObject$userD4.isDeclared) !== true) {
+            console.log("\uD83D\uDD27 Found computed gateway at endpoint: ".concat(endpointObject.uuid, " - converting to manual"));
+
+            // Convert gateway to manual (declared) using manualizeGateway for consistency
+            _this5.manualizeGateway(endpointObject, currentSceneData);
+            convertedGateways.push(endpointObject);
+          } else if (((_endpointObject$userD5 = endpointObject.userData) === null || _endpointObject$userD5 === void 0 ? void 0 : _endpointObject$userD5.objectType) === 'gateway' && ((_endpointObject$userD6 = endpointObject.userData) === null || _endpointObject$userD6 === void 0 ? void 0 : _endpointObject$userD6.isDeclared) === true) {
+            console.log("\u2139\uFE0F Gateway ".concat(endpointObject.uuid, " is already declared (manual), skipping conversion"));
+          }
+        } else {
+          console.log("\u26A0\uFE0F Could not find object for endpoint: ".concat(endpointUuid));
+        }
+      });
+      if (convertedGateways.length > 0) {
+        console.log("\u2705 Converted ".concat(convertedGateways.length, " gateways to manual:"), convertedGateways.map(function (g) {
+          return g.uuid;
+        }));
+      } else {
+        console.log('ℹ️ No computed gateways found to convert (all may already be declared)');
+      }
+
+      // Return array of gateway UUIDs
+      return convertedGateways.map(function (g) {
+        return g.uuid;
+      });
+    }
+
+    /**
+     * Handle manual gateway transformation by converting it to declared status and processing connections
+     * @param {THREE.Object3D} gateway - The transformed gateway object
+     * @param {Object} currentSceneData - Current scene data with connections
+     */
+  }, {
+    key: "manualizeGateway",
+    value: function manualizeGateway(gateway, currentSceneData) {
+      var _this$sceneViewer$man2;
+      console.log("[SceneOperations] manualizeGateway started:", gateway);
+      if (!gateway || !gateway.userData || gateway.userData.objectType !== 'gateway') {
+        console.log('❌ Object is not a gateway:', {
+          isObject: !!gateway,
+          hasUserData: !!(gateway && gateway.userData)
+        });
+        return;
+      }
+      console.log('🔧 Handling manual gateway transformation:', gateway.uuid);
+
+      // Get access to pathfinding manager's scene data manager
+      var pathfindingManager = (_this$sceneViewer$man2 = this.sceneViewer.managers) === null || _this$sceneViewer$man2 === void 0 ? void 0 : _this$sceneViewer$man2.pathfindingManager;
+      if (!pathfindingManager || !pathfindingManager.sceneDataManager) {
+        console.error('❌ PathfindingManager or SceneDataManager not available');
+        return;
+      }
+      var sceneDataManager = pathfindingManager.sceneDataManager;
+
+      // IMPORTANT: Check if gateway is already declared to prevent double-processing of connections
+      if (gateway.userData.isDeclared === true) {
+        console.log("\u2139\uFE0F Gateway ".concat(gateway.uuid, " is already declared (manual)"));
+
+        // Update position in scene data for subsequent moves
+        sceneDataManager.markObjectAsDeclared(gateway, currentSceneData, {});
+        console.log('✅ Updated gateway position in scene data');
+        return;
+      }
+
+      // Convert gateway from computed to declared status (first-time manualization)
+      console.log('🔧 Converting gateway to declared status via convertGatewayToManual');
+      this.convertGatewayToManual(gateway, currentSceneData);
+      console.log('✅ Manual gateway transformation completed');
+    }
+
+    /**
+     * Convert a gateway from computed to manual (declared) - reusing logic from sceneOperationsManager
+     * @param {THREE.Object3D} gateway - The gateway object to convert
+     * @param {Object} currentSceneData - Current scene data
+     */
+  }, {
+    key: "convertGatewayToManual",
+    value: function convertGatewayToManual(gateway, currentSceneData) {
+      var _this$sceneViewer$man3, _gateway$userData;
+      console.log("\uD83D\uDD27 Converting gateway from computed to declared: ".concat(gateway.uuid, " (").concat(gateway.uuid, ")"));
+      console.log("[SceneOperations] currentSceneData:", currentSceneData);
+
+      // Get access to pathfinding manager's scene data manager
+      var pathfindingManager = (_this$sceneViewer$man3 = this.sceneViewer.managers) === null || _this$sceneViewer$man3 === void 0 ? void 0 : _this$sceneViewer$man3.pathfindingManager;
+      if (!pathfindingManager || !pathfindingManager.sceneDataManager) {
+        console.error('❌ PathfindingManager or SceneDataManager not available');
+        return;
+      }
+      var sceneDataManager = pathfindingManager.sceneDataManager;
+
+      // Use shared helper to mark as declared
+      sceneDataManager.markObjectAsDeclared(gateway, currentSceneData, {});
+
+      // Process gateway connections (same logic as in sceneOperationsManager)
+      if ((_gateway$userData = gateway.userData) !== null && _gateway$userData !== void 0 && _gateway$userData.connections && currentSceneData.connections) {
+        console.log('🔗 Processing gateway connections for filtering:', gateway.userData.connections);
+        var gatewayConnections = gateway.userData.connections;
+
+        // Filter out removed connections (creates new array, doesn't mutate)
+        if (gatewayConnections.removed && Array.isArray(gatewayConnections.removed)) {
+          console.log('🗑️ Filtering out removed connections:', gatewayConnections.removed);
+          currentSceneData.connections = currentSceneData.connections.filter(function (connection) {
+            var isRemoved = gatewayConnections.removed.some(function (removedConn) {
+              return removedConn.from === connection.from && removedConn.to === connection.to || removedConn.from === connection.to && removedConn.to === connection.from;
+            });
+            if (isRemoved) {
+              console.log("\uD83D\uDDD1\uFE0F Removed connection: ".concat(connection.from, " \u2192 ").concat(connection.to));
+            }
+            return !isRemoved;
+          });
+        }
+
+        // Add new connections (deep copy to prevent reference issues)
+        if (gatewayConnections.added && Array.isArray(gatewayConnections.added)) {
+          console.log('➕ Adding new connections:', gatewayConnections.added);
+          gatewayConnections.added.forEach(function (newConnection) {
+            // Check if connection already exists to avoid duplicates
+            var alreadyExists = currentSceneData.connections.some(function (conn) {
+              return conn.from === newConnection.from && conn.to === newConnection.to || conn.from === newConnection.to && conn.to === newConnection.from;
+            });
+            if (!alreadyExists) {
+              // Deep copy the connection object to prevent reference issues
+              currentSceneData.connections.push(_objectSpread2({}, newConnection));
+              console.log("\u2795 Added new connection: ".concat(newConnection.from, " \u2192 ").concat(newConnection.to));
+            } else {
+              console.log("\u26A0\uFE0F Connection already exists, skipping: ".concat(newConnection.from, " \u2192 ").concat(newConnection.to));
+            }
+          });
+        }
+        console.log('✅ Gateway connections processing completed. Total connections:', currentSceneData.connections.length);
+      }
+      console.log("\u2705 Gateway ".concat(gateway.uuid, " successfully converted to manual (declared)"));
+    }
+
+    /**
+     * Split a pipe segment in half at its midpoint
+     * Creates two simple pipe meshes without manualization
+     * @param {string|THREE.Object3D} segmentIdOrObject - The UUID or Three.js object of the segment to split
+     * @returns {Object|null} Object with the two new segments {segment1, segment2} or null on failure
+     */
+  }, {
+    key: "splitSegment",
+    value: function splitSegment(segmentIdOrObject) {
+      var _segment$userData3,
+        _this6 = this;
+      console.log('✂️ splitSegment started:', segmentIdOrObject);
+
+      // Find the segment object
+      var segment = null;
+      if (typeof segmentIdOrObject === 'string') {
+        this.sceneViewer.scene.traverse(function (child) {
+          var _child$userData10;
+          if (child.uuid === segmentIdOrObject || ((_child$userData10 = child.userData) === null || _child$userData10 === void 0 ? void 0 : _child$userData10.originalUuid) === segmentIdOrObject) {
+            segment = child;
+          }
+        });
+      } else if (segmentIdOrObject && segmentIdOrObject.isObject3D) {
+        segment = segmentIdOrObject;
+      }
+
+      // Validate segment
+      if (!segment || ((_segment$userData3 = segment.userData) === null || _segment$userData3 === void 0 ? void 0 : _segment$userData3.objectType) !== 'segment') {
+        console.error('❌ splitSegment(): Invalid segment or not found');
+        return null;
+      }
+      console.log('✂️ Splitting segment:', segment.uuid);
+
+      // Get segment geometry to calculate split point
+      var geometry = segment.geometry;
+      if (!geometry || !geometry.parameters) {
+        console.error('❌ splitSegment(): Segment has invalid geometry');
+        return null;
+      }
+      var segmentLength = geometry.parameters.height || 1;
+      var segmentRadius = geometry.parameters.radiusTop || 0.1;
+
+      // Calculate segment direction vector
+      var direction = new THREE.Vector3(0, 1, 0);
+      direction.applyQuaternion(segment.quaternion);
+      direction.normalize();
+
+      // Calculate segment endpoints
+      var startPoint = new THREE.Vector3();
+      startPoint.copy(segment.position).sub(direction.clone().multiplyScalar(segmentLength / 2));
+      var endPoint = new THREE.Vector3();
+      endPoint.copy(segment.position).add(direction.clone().multiplyScalar(segmentLength / 2));
+
+      // Check for component connectors at endpoints
+      var findConnectorsAtPosition = function findConnectorsAtPosition(position) {
+        var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.15;
+        var connectors = [];
+        _this6.sceneViewer.scene.traverse(function (child) {
+          var _child$userData11;
+          if (((_child$userData11 = child.userData) === null || _child$userData11 === void 0 ? void 0 : _child$userData11.objectType) === 'connector') {
+            var connectorWorldPos = new THREE.Vector3();
+            child.getWorldPosition(connectorWorldPos);
+            var distance = connectorWorldPos.distanceTo(position);
+            if (distance <= tolerance) {
+              connectors.push(child);
+            }
+          }
+        });
+        return connectors.filter(function (c) {
+          var _c$userData;
+          return ((_c$userData = c.userData) === null || _c$userData === void 0 ? void 0 : _c$userData.objectType) !== 'segment-connector';
+        });
+      };
+      var startConnectors = findConnectorsAtPosition(startPoint);
+      var endConnectors = findConnectorsAtPosition(endPoint);
+
+      // Determine split position: 0.5 on component connector side, remaining on free side
+      var segment1Length, segment2Length, splitPoint;
+      var fixedLength = 0.5; // Fixed length for component connector side
+
+      if (startConnectors.length > 0) {
+        // Component connector at start - make segment1 = 0.5, segment2 = remaining
+        segment1Length = fixedLength;
+        segment2Length = segmentLength - fixedLength;
+        splitPoint = new THREE.Vector3();
+        splitPoint.copy(startPoint).add(direction.clone().multiplyScalar(fixedLength));
+        console.log("\uD83D\uDCCD Component connector at START - split: ".concat(segment1Length, " (start) + ").concat(segment2Length, " (end)"));
+      } else if (endConnectors.length > 0) {
+        // Component connector at end - make segment1 = remaining, segment2 = 0.5
+        segment1Length = segmentLength - fixedLength;
+        segment2Length = fixedLength;
+        splitPoint = new THREE.Vector3();
+        splitPoint.copy(endPoint).sub(direction.clone().multiplyScalar(fixedLength));
+        console.log("\uD83D\uDCCD Component connector at END - split: ".concat(segment1Length, " (start) + ").concat(segment2Length, " (end)"));
+      } else {
+        // No component connectors - split at midpoint (default behavior)
+        segment1Length = segmentLength / 2;
+        segment2Length = segmentLength / 2;
+        splitPoint = new THREE.Vector3();
+        splitPoint.copy(segment.position);
+        console.log("\uD83D\uDCCD No component connectors - split at midpoint: ".concat(segment1Length, " + ").concat(segment2Length));
+      }
+      console.log('📍 Segment split points:', {
+        start: startPoint.toArray(),
+        split: splitPoint.toArray(),
+        end: endPoint.toArray(),
+        length: segmentLength,
+        segment1Length: segment1Length,
+        segment2Length: segment2Length,
+        originalUuid: segment.uuid
+      });
+
+      // Get material from existing segment
+      var material = segment.material;
+
+      // Create first segment (start to split point)
+      var segment1Geometry = new THREE.CylinderGeometry(segmentRadius, segmentRadius, segment1Length, 16, 1, false);
+      var segment1 = new THREE.Mesh(segment1Geometry, material);
+
+      // Position segment1 between start and split point
+      var segment1Position = new THREE.Vector3();
+      segment1Position.lerpVectors(startPoint, splitPoint, 0.5);
+      segment1.position.copy(segment1Position);
+      segment1.quaternion.copy(segment.quaternion);
+
+      // Set UUID and copy userData
+      segment1.uuid = "".concat(segment.uuid, "-part1");
+      segment1.userData = _objectSpread2(_objectSpread2({}, segment.userData), {}, {
+        originalUuid: segment1.uuid,
+        splitFromUuid: segment.uuid
+      });
+
+      // Mark segment1 as non-selectable/non-transformable if it's the 0.5 stub
+      if (startConnectors.length > 0 && segment1Length === fixedLength) {
+        segment1.userData.isStub = true;
+        segment1.userData.selectable = false;
+        segment1.userData.transformable = false;
+        console.log("\uD83D\uDD12 Segment1 marked as non-selectable stub (length: ".concat(fixedLength, ")"));
+      }
+
+      // Create second segment (split point to end)
+      var segment2Geometry = new THREE.CylinderGeometry(segmentRadius, segmentRadius, segment2Length, 16, 1, false);
+      var segment2 = new THREE.Mesh(segment2Geometry, material);
+
+      // Position segment2 between split point and end
+      var segment2Position = new THREE.Vector3();
+      segment2Position.lerpVectors(splitPoint, endPoint, 0.5);
+      segment2.position.copy(segment2Position);
+      segment2.quaternion.copy(segment.quaternion);
+
+      // Set UUID and copy userData
+      segment2.uuid = "".concat(segment.uuid, "-part2");
+      segment2.userData = _objectSpread2(_objectSpread2({}, segment.userData), {}, {
+        originalUuid: segment2.uuid,
+        splitFromUuid: segment.uuid
+      });
+
+      // Mark segment2 as non-selectable/non-transformable if it's the 0.5 stub
+      if (endConnectors.length > 0 && segment2Length === fixedLength) {
+        segment2.userData.isStub = true;
+        segment2.userData.selectable = false;
+        segment2.userData.transformable = false;
+        console.log("\uD83D\uDD12 Segment2 marked as non-selectable stub (length: ".concat(fixedLength, ")"));
+      }
+
+      // Add new segments to scene
+      this.sceneViewer.scene.add(segment1);
+      this.sceneViewer.scene.add(segment2);
+      console.log('✅ Created two new segments:', {
+        segment1: segment1.uuid,
+        segment2: segment2.uuid,
+        originalSegment: segment.uuid
+      });
+
+      // Remove the original segment
+      this.sceneViewer.scene.remove(segment);
+      if (segment.geometry) segment.geometry.dispose();
+      console.log('🗑️ Removed original segment:', segment.uuid);
+      console.log('✅ Segment split completed successfully');
+      return {
+        segment1: segment1,
+        segment2: segment2
+      };
+    }
   }]);
 }();
 

package/dist/esm/src/managers/scene/sceneTooltipsManager.js

@@ -2,7 +2,6 @@ import { inherits as _inherits, createClass as _createClass, classCallCheck as _
 import { CSS2DRenderer, CSS2DObject } from '../../../node_modules/three/examples/jsm/renderers/CSS2DRenderer.js';
 import * as THREE from 'three';
 import { BaseDisposable } from '../../core/baseDisposable.js';
-import { isSegment } from '../../utils/objectTypes.js';
 
 // Add a simple debug logger for tooltip events
 var tooltipLogger = {
@@ -399,7 +398,7 @@ var SceneTooltipsManager = /*#__PURE__*/function (_BaseDisposable) {
       };
 
       // If transform controls are available and have a selected object
-      if (this.transformControlsManager && this.transformControlsManager.selectedObject === this.selectedMesh) {
+      if (this.transformControlsManager && this.transformControlsManager.selectedObjects && this.transformControlsManager.selectedObjects.length > 0 && this.transformControlsManager.selectedObjects[0] === this.selectedMesh) {
         try {
           // Get world transform data from transform controls
           var worldTransform = this.transformControlsManager.getWorldTransformData();
@@ -608,16 +607,10 @@ var SceneTooltipsManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "isSelectableComponent",
     value: function isSelectableComponent(object) {
-      var _object$userData;
       // Check if the object has component data
       if (object && object.userData && object.userData.component) {
         return true;
       }
-
-      // Check if the object is a pipe segment or junction
-      if (object && (isSegment(object) || (_object$userData = object.userData) !== null && _object$userData !== void 0 && _object$userData.isPipeJunction)) {
-        return true;
-      }
       return false;
     }
   }, {