@2112-lab/central-plant 0.1.49 → 0.1.51

package/dist/esm/src/managers/pathfinding/PathRenderingManager.js

@@ -156,8 +156,30 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
     value: function createPipePaths(paths, crosscubeTextureSet) {
       var _this3 = this;
       var sceneViewer = this.sceneViewer;
-      var globalSegmentIndex = 0; // Counter for globally unique segment indices
 
+      // Find the highest segment index currently in use (both computed SEGMENT-X and manual Segment-X)
+      var maxExistingIndex = -1;
+      sceneViewer.scene.traverse(function (obj) {
+        if (obj.uuid) {
+          // Check for computed segments: SEGMENT-123
+          var computedMatch = obj.uuid.match(/^SEGMENT-(\d+)$/);
+          if (computedMatch) {
+            var index = parseInt(computedMatch[1], 10);
+            maxExistingIndex = Math.max(maxExistingIndex, index);
+          }
+
+          // Check for manual segments: Segment-123
+          var manualMatch = obj.uuid.match(/^Segment-(\d+)$/);
+          if (manualMatch) {
+            var _index = parseInt(manualMatch[1], 10);
+            maxExistingIndex = Math.max(maxExistingIndex, _index);
+          }
+        }
+      });
+
+      // Start counter after the highest existing index to prevent UUID conflicts
+      var globalSegmentIndex = maxExistingIndex + 1;
+      console.log("\uD83D\uDD22 Starting segment index at ".concat(globalSegmentIndex, " (max existing: ").concat(maxExistingIndex, ")"));
       var pipeRadius = 0.1;
       var pipeMaterial = this.createPipeMaterial(crosscubeTextureSet);
       paths.forEach(function (pathData, index) {
@@ -176,6 +198,10 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             }
           });
 
+          // Check if endpoints are component connectors (from pathfinder result)
+          var fromIsComponentConnector = pathData.fromObjectType === 'component-connector';
+          var toIsComponentConnector = pathData.toObjectType === 'component-connector';
+
           // Create one cylinder per segment (after colinear optimization, this should be minimal segments)
           for (var j = 0; j < pathPoints.length - 1; j++) {
             var start = pathPoints[j];
@@ -204,13 +230,19 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             // Make pipe segments selectable and add identifying data
             var segmentId = cylinder.uuid;
 
+            // Determine if this segment should be immutable (first or last 0.5-unit segment connected to component)
+            var isFirstSegment = j === 0;
+            var isLastSegment = j === pathPoints.length - 2;
+            var isImmutable = fromIsComponentConnector && isFirstSegment || toIsComponentConnector && isLastSegment;
+
             // Add userData to make pipe segments selectable and for tooltip display
             cylinder.userData = {
               objectType: 'segment',
               segmentId: segmentId,
               segmentIndex: globalSegmentIndex,
               pathFrom: pathData.from,
-              pathTo: pathData.to
+              pathTo: pathData.to,
+              immutable: isImmutable // Mark segments connected to component connectors as immutable
             };
 
             // Increment global segment counter
@@ -275,6 +307,8 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
         pathFrom: pathData.from,
         pathTo: pathData.to,
         angle: (angle * 180 / Math.PI).toFixed(1),
+        immutable: true,
+        // Mark computed elbows as immutable
         // Add component data for tooltips
         component: {
           type: 'PipeElbow',

package/dist/esm/src/managers/pathfinding/pathfindingManager.js

@@ -1,4 +1,4 @@
-import { inherits as _inherits, createClass as _createClass, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, objectSpread2 as _objectSpread2 } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { inherits as _inherits, createClass as _createClass, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import 'three';
 import { Pathfinder } from '@2112-lab/pathfinder';
 import { BaseDisposable } from '../../core/baseDisposable.js';
@@ -123,13 +123,6 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
           connectionsCopy,
           simplifiedSceneData,
           pathfindingResult,
-          intersectionCheck,
-          _this$sceneViewer,
-          operationHistoryManager,
-          lastOp,
-          undoSuccess,
-          correctedResult,
-          _this$sceneViewer2,
           _args = arguments;
         return _regenerator().w(function (_context) {
           while (1) switch (_context.n) {
@@ -164,93 +157,79 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               console.log('Rewired connections:', JSON.parse(JSON.stringify(pathfindingResult.rewiredConnections)));
               console.log("intersectionCheck input:", pathfindingResult.paths);
 
-              // Check for path intersections (including manual segments)
-              intersectionCheck = this.checkPathIntersections(pathfindingResult.paths, 0.2, true);
-              pathfindingResult.intersections = intersectionCheck;
-              console.log("intersectionCheck:", intersectionCheck);
-              console.log("intersectionCheck.hasIntersections:", intersectionCheck.hasIntersections);
-
-              // Handle intersection detection - undo last operation if intersections found
-              // Skip this if we're already in the middle of an undo operation
-              if (!(intersectionCheck.hasIntersections && !this.isUndoInProgress)) {
-                _context.n = 8;
-                break;
-              }
-              console.warn('⚠️ Path intersections detected! Attempting to undo last operation...');
-
-              // Set flag to prevent recursive undo attempts
-              this.isUndoInProgress = true;
-
-              // Access operationHistoryManager through sceneViewer.managers.operationHistory
-              operationHistoryManager = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.operationHistory;
-              if (!operationHistoryManager) {
-                _context.n = 6;
-                break;
-              }
-              lastOp = operationHistoryManager.getLastOperation();
-              if (!lastOp) {
-                _context.n = 4;
-                break;
-              }
-              console.warn("\u26A0\uFE0F Intersection caused by operation: ".concat(lastOp.operationName), lastOp.params);
-
-              // Attempt to undo the operation FIRST (before removing computed objects)
-              // This is important because undo needs to find the segment that was moved
-              undoSuccess = operationHistoryManager.undoLastOperation();
-              if (!undoSuccess) {
-                _context.n = 2;
-                break;
-              }
-              console.log('✅ Successfully undid operation that caused intersection');
+              // // Check for path intersections (including manual segments)
+              // const intersectionCheck = this.checkPathIntersections(pathfindingResult.paths, 0.2, true);
+              // pathfindingResult.intersections = intersectionCheck;
+
+              // console.log("intersectionCheck:", intersectionCheck);
+              // console.log("intersectionCheck.hasIntersections:", intersectionCheck.hasIntersections);
+
+              // // Handle intersection detection - undo last operation if intersections found
+              // // Skip this if we're already in the middle of an undo operation
+              // if (intersectionCheck.hasIntersections && !this.isUndoInProgress) {
+              //   console.warn('⚠️ Path intersections detected! Attempting to undo last operation...');
+
+              //   // Set flag to prevent recursive undo attempts
+              //   this.isUndoInProgress = true;
+
+              //   // Access operationHistoryManager through sceneViewer.managers.operationHistory
+              //   const operationHistoryManager = this.sceneViewer?.managers?.operationHistory;
+
+              //   if (operationHistoryManager) {
+              //     const lastOp = operationHistoryManager.getLastOperation();
+
+              //     if (lastOp) {
+              //       console.warn(`⚠️ Intersection caused by operation: ${lastOp.operationName}`, lastOp.params);
+
+              //       // Attempt to undo the operation FIRST (before removing computed objects)
+              //       // This is important because undo needs to find the segment that was moved
+              //       const undoSuccess = operationHistoryManager.undoLastOperation();
+
+              //       if (undoSuccess) {
+              //         console.log('✅ Successfully undid operation that caused intersection');
+
+              //         // Now remove the buggy computed objects that were created with the invalid state
+              //         console.log('🗑️ Removing buggy computed objects after undo...');
+              //         this.removeComputedObjects();
+
+              //         // Re-run pathfinding after undo to restore valid state
+              //         console.log('🔄 Re-running pathfinding after undo to restore clean state...');
+
+              //         // Recursively call _executePathfinding with the corrected scene state
+              //         // This is safe because we've undone the operation, so we won't get into an infinite loop
+              //         const correctedResult = await this._executePathfinding(
+              //           sceneData,
+              //           connections,
+              //           { ...options, context: `${context} (After Undo)` }
+              //         );
+
+              //         // Mark that we performed an undo and return the corrected result
+              //         correctedResult.undoPerformed = true;
+              //         correctedResult.undoneOperation = lastOp;
+
+              //         // Clear the undo flag before returning
+              //         this.isUndoInProgress = false;
+
+              //         return correctedResult;
+              //       } else {
+              //         console.error('❌ Failed to undo operation that caused intersection');
+              //         pathfindingResult.undoFailed = true;
+              //         // Clear the undo flag even on failure
+              //         this.isUndoInProgress = false;
+              //       }
+              //     } else {
+              //       console.warn('⚠️ No operation in history to undo');
+              //       this.isUndoInProgress = false;
+              //     }
+              //   } else {
+              //     console.error('❌ OperationHistoryManager not available for undo');
+              //     console.error('  Available managers:', Object.keys(this.sceneViewer?.managers || {}));
+              //     this.isUndoInProgress = false;
+              //   }
+              // } else if (intersectionCheck.hasIntersections && this.isUndoInProgress) {
+              //   console.log('⏭️ Skipping intersection handling - undo already in progress');
+              // }
 
-              // Now remove the buggy computed objects that were created with the invalid state
-              console.log('🗑️ Removing buggy computed objects after undo...');
-              this.removeComputedObjects();
-
-              // Re-run pathfinding after undo to restore valid state
-              console.log('🔄 Re-running pathfinding after undo to restore clean state...');
-
-              // Recursively call _executePathfinding with the corrected scene state
-              // This is safe because we've undone the operation, so we won't get into an infinite loop
-              _context.n = 1;
-              return this._executePathfinding(sceneData, connections, _objectSpread2(_objectSpread2({}, options), {}, {
-                context: "".concat(context, " (After Undo)")
-              }));
-            case 1:
-              correctedResult = _context.v;
-              // Mark that we performed an undo and return the corrected result
-              correctedResult.undoPerformed = true;
-              correctedResult.undoneOperation = lastOp;
-
-              // Clear the undo flag before returning
-              this.isUndoInProgress = false;
-              return _context.a(2, correctedResult);
-            case 2:
-              console.error('❌ Failed to undo operation that caused intersection');
-              pathfindingResult.undoFailed = true;
-              // Clear the undo flag even on failure
-              this.isUndoInProgress = false;
-            case 3:
-              _context.n = 5;
-              break;
-            case 4:
-              console.warn('⚠️ No operation in history to undo');
-              this.isUndoInProgress = false;
-            case 5:
-              _context.n = 7;
-              break;
-            case 6:
-              console.error('❌ OperationHistoryManager not available for undo');
-              console.error('  Available managers:', Object.keys(((_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.managers) || {}));
-              this.isUndoInProgress = false;
-            case 7:
-              _context.n = 9;
-              break;
-            case 8:
-              if (intersectionCheck.hasIntersections && this.isUndoInProgress) {
-                console.log('⏭️ Skipping intersection handling - undo already in progress');
-              }
-            case 9:
               // Create gateways in the scene if requested
               if (options.createGateways && pathfindingResult.gateways) {
                 this.renderingManager.createGateways(pathfindingResult);

package/dist/esm/src/managers/pathfinding/sceneDataManager.js

@@ -95,10 +95,23 @@ var SceneDataManager = /*#__PURE__*/function () {
             worldBoundingBox: worldBoundingBox
           })
         };
+
+        // For connectors and gateways, add world position
         if (obj.userData.objectType.includes('connector') || obj.userData.objectType === 'gateway') {
           var worldPosition = new THREE.Vector3();
           obj.getWorldPosition(worldPosition);
           results.userData.position = [worldPosition.x, worldPosition.y, worldPosition.z];
+
+          // Differentiate component connectors from segment connectors for pathfinder
+          // Component connectors are children of components
+          if (obj.userData.objectType === 'connector') {
+            var _parent$userData;
+            // Check if parent is a component (not a segment)
+            var parent = obj.parent;
+            if (parent && ((_parent$userData = parent.userData) === null || _parent$userData === void 0 ? void 0 : _parent$userData.objectType) === 'component') {
+              results.userData.objectType = 'component-connector';
+            }
+          }
         }
         return results;
       });

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

@@ -1328,7 +1328,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "manualizeSegment",
     value: function manualizeSegment(segment, currentSceneData) {
-      var _segment$userData, _this$sceneViewer$man;
+      var _segment$userData, _segment$material$use, _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,
@@ -1345,6 +1345,16 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         return;
       }
 
+      // CRITICAL: Clone the material BEFORE changing its color
+      // This prevents the color change from affecting other segments that share the same material instance
+      if (segment.material && !((_segment$material$use = segment.material.userData) !== null && _segment$material$use !== void 0 && _segment$material$use.isCloned)) {
+        var originalMaterial = segment.material;
+        segment.material = originalMaterial.clone();
+        segment.material.userData = segment.material.userData || {};
+        segment.material.userData.isCloned = true;
+        console.log('📋 Cloned segment material to prevent shared material mutation');
+      }
+
       // Override material color to blue in dev mode
       var isDev = false;
       if (typeof window !== 'undefined') {
@@ -1369,7 +1379,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       // 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);
+      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
@@ -1626,147 +1636,6 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       }
       console.log("\u2705 Gateway ".concat(gateway.uuid, " successfully converted to manual (declared)"));
     }
-
-    /**
-     * Split a segment by manualizing it and shortening it by 0.5 units
-     * The segment gets converted to a declared (manual) segment with connectors,
-     * and is shortened from the end that has a component connector (or the end if no connectors)
-     * @param {string|THREE.Object3D} segmentIdOrObject - The UUID or Three.js object of the segment to split
-     * @param {Object} currentSceneData - Current scene data with connections
-     * @returns {THREE.Object3D|null} The shortened manual segment or null on failure
-     */
-  }, {
-    key: "splitSegment",
-    value: function splitSegment(segmentIdOrObject, currentSceneData) {
-      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;
-      }
-      if (!currentSceneData) {
-        console.error('❌ splitSegment(): currentSceneData is required');
-        return null;
-      }
-      console.log('✂️ Splitting/shortening segment:', segment.uuid);
-
-      // Get segment geometry to calculate endpoints
-      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;
-      var shortenAmount = 0.5;
-      var newLength = segmentLength - shortenAmount;
-      if (newLength <= 0) {
-        console.error('❌ splitSegment(): Segment too short to shorten by 0.5');
-        return null;
-      }
-
-      // Calculate segment direction vector
-      var direction = new THREE.Vector3(0, 1, 0);
-      direction.applyQuaternion(segment.quaternion);
-      direction.normalize();
-
-      // Calculate original 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 which end to shorten from
-      var newStartPoint, newEndPoint;
-      if (endConnectors.length > 0) {
-        // Component connector at end - shorten from end
-        newStartPoint = startPoint.clone();
-        newEndPoint = endPoint.clone().sub(direction.clone().multiplyScalar(shortenAmount));
-        console.log("\uD83D\uDCCD Component connector at END - shortening from end by ".concat(shortenAmount));
-      } else if (startConnectors.length > 0) {
-        // Component connector at start - shorten from start
-        newStartPoint = startPoint.clone().add(direction.clone().multiplyScalar(shortenAmount));
-        newEndPoint = endPoint.clone();
-        console.log("\uD83D\uDCCD Component connector at START - shortening from start by ".concat(shortenAmount));
-      } else {
-        // No component connectors - shorten from end (default)
-        newStartPoint = startPoint.clone();
-        newEndPoint = endPoint.clone().sub(direction.clone().multiplyScalar(shortenAmount));
-        console.log("\uD83D\uDCCD No component connectors - shortening from end by ".concat(shortenAmount));
-      }
-      console.log('📍 Segment shortening:', {
-        originalStart: startPoint.toArray(),
-        originalEnd: endPoint.toArray(),
-        newStart: newStartPoint.toArray(),
-        newEnd: newEndPoint.toArray(),
-        originalLength: segmentLength,
-        newLength: newLength,
-        shortenAmount: shortenAmount
-      });
-
-      // Get material from existing segment
-      segment.material;
-
-      // Dispose old geometry and create new shortened geometry
-      if (segment.geometry) {
-        segment.geometry.dispose();
-      }
-      var newGeometry = new THREE.CylinderGeometry(segmentRadius, segmentRadius, newLength, 16, 1, false);
-      segment.geometry = newGeometry;
-
-      // Reposition the segment to the new center
-      var newPosition = new THREE.Vector3();
-      newPosition.lerpVectors(newStartPoint, newEndPoint, 0.5);
-      segment.position.copy(newPosition);
-      // Quaternion stays the same
-
-      console.log('✅ Segment geometry updated and repositioned');
-
-      // Now manualize the shortened segment
-      console.log('🔧 Manualizing the shortened segment...');
-      this.manualizeSegment(segment, currentSceneData);
-      console.log('✅ Segment split completed successfully - segment shortened and manualized');
-      return segment;
-    }
   }]);
 }();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2112-lab/central-plant",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "description": "Utility modules for the Central Plant Application",
   "main": "dist/bundle/index.js",
   "module": "dist/esm/index.js",
@@ -30,7 +30,7 @@
   "author": "CentralPlant Team",
   "license": "MIT",
   "dependencies": {
-    "@2112-lab/pathfinder": "1.0.31",
+    "@2112-lab/pathfinder": "1.0.32",
     "stats.js": "^0.17.0",
     "three": "^0.177.0"
   },