@2112-lab/central-plant 0.1.39 → 0.1.41

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

@@ -0,0 +1,361 @@
+import { inherits as _inherits, createClass as _createClass, objectSpread2 as _objectSpread2, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, createForOfIteratorHelper as _createForOfIteratorHelper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import { BaseDisposable } from '../../core/baseDisposable.js';
+
+var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
+  function ConnectorManager(sceneViewer) {
+    var _this;
+    _classCallCheck(this, ConnectorManager);
+    _this = _callSuper(this, ConnectorManager);
+    _this.sceneViewer = sceneViewer;
+    return _this;
+  }
+
+  /**
+   * Create connector objects at segment endpoints
+   * @param {THREE.Object3D} segment - The pipe segment
+   * @param {Object} endpoints - Object with start and end points
+   * @returns {Array} Array of connector objects [startConnector, endConnector]
+   */
+  _inherits(ConnectorManager, _BaseDisposable);
+  return _createClass(ConnectorManager, [{
+    key: "createSegmentConnectors",
+    value: function createSegmentConnectors(segment, endpoints) {
+      var segmentData = segment.userData;
+      var segmentId = segmentData.segmentId;
+      var segmentIndex = segmentData.segmentIndex;
+      var connectors = [];
+
+      // Reuse the segment's material for both connectors
+      var segmentMaterial = segment.material;
+      var sphereRadius = 0.1;
+      var sphereSegments = 16;
+
+      // Create start connector
+      var startConnector = new THREE.Mesh(new THREE.SphereGeometry(sphereRadius, sphereSegments, sphereSegments), segmentMaterial // Reuse segment material
+      );
+
+      // Convert world position to local position relative to segment
+      var localStartPosition = segment.worldToLocal(endpoints.start.clone());
+      startConnector.position.copy(localStartPosition);
+      startConnector.uuid = "SEGMENT-".concat(segmentIndex, "-CONNECTOR-1");
+      startConnector.userData = {
+        objectType: 'segment-connector',
+        isManualSegmentConnector: true,
+        segmentId: segmentId,
+        connectorType: 'start',
+        manualSegmentUuid: segment.uuid,
+        isDeclared: true
+      };
+
+      // Add start connector as child of segment
+      segment.add(startConnector);
+
+      // Create end connector
+      var endConnector = new THREE.Mesh(new THREE.SphereGeometry(sphereRadius, sphereSegments, sphereSegments), segmentMaterial // Reuse segment material
+      );
+
+      // Convert world position to local position relative to segment
+      var localEndPosition = segment.worldToLocal(endpoints.end.clone());
+      endConnector.position.copy(localEndPosition);
+      endConnector.uuid = "SEGMENT-".concat(segmentIndex, "-CONNECTOR-2");
+      endConnector.userData = {
+        objectType: 'segment-connector',
+        isManualSegmentConnector: true,
+        segmentId: segmentId,
+        connectorType: 'end',
+        manualSegmentUuid: segment.uuid,
+        isDeclared: true
+      };
+
+      // Add end connector as child of segment
+      segment.add(endConnector);
+      connectors.push(startConnector, endConnector);
+      return connectors;
+    }
+
+    /**
+     * Calculate the start and end points of a pipe segment in world coordinates
+     * @param {THREE.Object3D} segment - The pipe segment
+     * @returns {Object} Object with start and end points { start: Vector3, end: Vector3 }
+     */
+  }, {
+    key: "calculateSegmentEndpoints",
+    value: function calculateSegmentEndpoints(segment) {
+      // Get the segment's geometry to determine its length and orientation
+      var geometry = segment.geometry;
+      var length = geometry.parameters.height || 1;
+
+      // Calculate start and end points based on segment position and orientation
+      var startPoint = new THREE.Vector3();
+      var endPoint = new THREE.Vector3();
+
+      // Get the segment's direction vector
+      var direction = new THREE.Vector3(0, 1, 0);
+      direction.applyQuaternion(segment.quaternion);
+
+      // Calculate start point (half length back from center)
+      startPoint.copy(segment.position).sub(direction.clone().multiplyScalar(length / 2));
+
+      // Calculate end point (half length forward from center)
+      endPoint.copy(segment.position).add(direction.clone().multiplyScalar(length / 2));
+      return {
+        start: startPoint,
+        end: endPoint
+      };
+    }
+
+    /**
+     * Add connectors to the scene and scene data
+     * Note: Connectors are already children of the segment in the Three.js scene.
+     * @param {Array} connectors - Array of connector objects
+     */
+  }, {
+    key: "addConnectorsToScene",
+    value: function addConnectorsToScene(connectors) {
+      var sceneViewer = this.sceneViewer;
+      connectors.forEach(function (connector) {
+        // Connectors are already children of the segment in Three.js, no need to add to scene
+        console.log("\uD83D\uDD0C Connector already added as child of segment: ".concat(connector.uuid));
+
+        // Add to scene data structure as children of the segment (not at top level)
+        if (sceneViewer.currentSceneData && sceneViewer.currentSceneData.scene) {
+          // Helper function to clean up floating-point precision errors
+          var cleanPosition = function cleanPosition(value) {
+            // Round values very close to zero to exactly zero
+            return Math.abs(value) < 1e-10 ? 0 : value;
+          };
+
+          // Get world position for scene data (since connectors are now in local space)
+          var worldPosition = new THREE.Vector3();
+          connector.getWorldPosition(worldPosition);
+
+          // Get the segment UUID from connector's userData
+          var segmentUuid = connector.userData.manualSegmentUuid;
+          if (!segmentUuid) {
+            console.warn("\u26A0\uFE0F Connector ".concat(connector.uuid, " missing manualSegmentUuid, cannot add to scene data"));
+            return;
+          }
+
+          // Find the segment in scene data
+          var _findSegment = function findSegment(children) {
+            var _iterator = _createForOfIteratorHelper(children),
+              _step;
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var child = _step.value;
+                if (child.uuid === segmentUuid) {
+                  return child;
+                }
+                if (child.children) {
+                  var found = _findSegment(child.children);
+                  if (found) return found;
+                }
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+            return null;
+          };
+          var segmentInSceneData = _findSegment(sceneViewer.currentSceneData.scene.children);
+          if (!segmentInSceneData) {
+            console.warn("\u26A0\uFE0F Could not find segment ".concat(segmentUuid, " in scene data for connector ").concat(connector.uuid));
+            return;
+          }
+
+          // Ensure segment has a children array in scene data
+          if (!segmentInSceneData.children) {
+            segmentInSceneData.children = [];
+          }
+          var sceneDataConnector = {
+            uuid: connector.uuid,
+            userData: _objectSpread2(_objectSpread2({}, connector.userData), {}, {
+              isDeclared: true,
+              // Mark manual segment connectors as declared
+              // Position MUST be an array [x, y, z] for pathfinder compatibility
+              position: [cleanPosition(worldPosition.x), cleanPosition(worldPosition.y), cleanPosition(worldPosition.z)]
+            })
+          };
+
+          // Add connector as child of segment in scene data (not at top level)
+          segmentInSceneData.children.push(sceneDataConnector);
+          console.log("\uD83D\uDD0C Added connector to scene data as child of segment ".concat(segmentUuid, ": ").concat(connector.uuid));
+        } else {
+          console.warn('⚠️ Could not add connector to scene data - currentSceneData not available');
+        }
+      });
+    }
+
+    /**
+     * Restructure connections to use the new connectors
+     * @param {string} authoritativeConnectorUUID - The authoritative connector UUID
+     * @param {Array} connectors - Array of connector objects (0: start, 1: end)
+     * @param {Object} currentSceneData - Current scene data
+     * @param {Array<string>} convertedGatewayUUIDs - Array of gateway UUIDs that were converted to manual (optional)
+     */
+  }, {
+    key: "restructureConnections",
+    value: function restructureConnections(authoritativeConnectorUUID, connectors, currentSceneData) {
+      var convertedGatewayUUIDs = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+      // Extract connector UUIDs from the passed connectors array
+      var startConnectorUUID = connectors[0].uuid; // SEGMENT-X-CONNECTOR-1
+      var endConnectorUUID = connectors[1].uuid; // SEGMENT-X-CONNECTOR-2
+
+      console.log("\uD83D\uDD27 [restructureConnections] connectors:", JSON.parse(JSON.stringify(connectors)));
+      console.log("\uD83D\uDD27 [restructureConnections] convertedGatewayUUIDs:", convertedGatewayUUIDs);
+
+      // Deep copy connections array to prevent unintended mutations during iteration
+      // Then map to update references, creating new connection objects
+      currentSceneData.connections = currentSceneData.connections.map(function (connection) {
+        console.log("[restructureConnections] connection:", connection);
+
+        // Create a shallow copy of the connection object
+        var updatedConnection = _objectSpread2({}, connection);
+        if (connection.from === authoritativeConnectorUUID) {
+          updatedConnection.from = endConnectorUUID;
+          console.log("\u2705 [restructureConnections] Updated connection.from to ".concat(endConnectorUUID));
+        }
+        if (connection.to === authoritativeConnectorUUID) {
+          updatedConnection.to = endConnectorUUID;
+          console.log("\u2705 [restructureConnections] Updated connection.to to ".concat(endConnectorUUID));
+        }
+        return updatedConnection;
+      });
+
+      // Check if the new connection already exists to prevent duplicates
+      var newConnectionExists = currentSceneData.connections.some(function (conn) {
+        return conn.from === authoritativeConnectorUUID && conn.to === startConnectorUUID || conn.from === startConnectorUUID && conn.to === authoritativeConnectorUUID;
+      });
+      if (!newConnectionExists) {
+        // Add new connection from authoritative connector to the segment start
+        currentSceneData.connections.push({
+          from: authoritativeConnectorUUID,
+          to: startConnectorUUID
+        });
+        console.log("\u2705 [restructureConnections] Added new connection: ".concat(authoritativeConnectorUUID, " \u2192 ").concat(startConnectorUUID));
+      } else {
+        console.log("\u26A0\uFE0F [restructureConnections] Connection already exists, skipping: ".concat(authoritativeConnectorUUID, " \u2192 ").concat(startConnectorUUID));
+      }
+
+      // Log converted gateways for tracking
+      if (convertedGatewayUUIDs.length > 0) {
+        console.log("\uD83D\uDD27 [restructureConnections] Converted gateways available: ".concat(convertedGatewayUUIDs.join(', ')));
+      }
+      console.log("\u2705 [restructureConnections] currentSceneData.connections:", JSON.parse(JSON.stringify(currentSceneData.connections)));
+    }
+
+    /**
+     * Find the original connection that a segment belongs to
+     * @param {THREE.Object3D} segment - The pipe segment
+     * @param {Array} connections - Array of connections
+     * @returns {Object|null} The original connection or null
+     */
+  }, {
+    key: "findOriginalConnection",
+    value: function findOriginalConnection(segment, connections) {
+      var _fromObject$userData, _toObject$userData;
+      var segmentData = segment.userData;
+      var pathFrom = segmentData.pathFrom;
+      var pathTo = segmentData.pathTo;
+      console.log('🔍 Looking for connection:', {
+        pathFrom: pathFrom,
+        pathTo: pathTo
+      });
+      console.log('🔍 Available connections:', connections);
+
+      // First try: direct connection match
+      var foundConnection = connections.find(function (conn) {
+        return conn.from === pathFrom && conn.to === pathTo || conn.from === pathTo && conn.to === pathFrom;
+      });
+      if (foundConnection) {
+        console.log('🔍 Found direct connection match:', foundConnection);
+        return foundConnection;
+      }
+
+      // Second try: look for connections that might involve gateways
+      // This can happen when the original connection involves a gateway that was computed
+      console.log('🔍 No direct match found, checking for gateway-involved connections...');
+      var sceneViewer = this.sceneViewer;
+
+      // Look for objects in the scene that might be the pathFrom or pathTo
+      var fromObject = null;
+      var toObject = null;
+      sceneViewer.scene.traverse(function (obj) {
+        var _obj$userData, _obj$userData2;
+        if (obj.uuid === pathFrom || ((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.originalUuid) === pathFrom) {
+          fromObject = obj;
+        }
+        if (obj.uuid === pathTo || ((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.originalUuid) === pathTo) {
+          toObject = obj;
+        }
+      });
+      console.log('🔍 Scene objects found:', {
+        fromObject: fromObject ? {
+          uuid: fromObject.uuid,
+          name: fromObject.uuid,
+          objectType: (_fromObject$userData = fromObject.userData) === null || _fromObject$userData === void 0 ? void 0 : _fromObject$userData.objectType
+        } : null,
+        toObject: toObject ? {
+          uuid: toObject.uuid,
+          name: toObject.uuid,
+          objectType: (_toObject$userData = toObject.userData) === null || _toObject$userData === void 0 ? void 0 : _toObject$userData.objectType
+        } : null
+      });
+
+      // If we found the objects, look for connections involving their UUIDs
+      if (fromObject && toObject) {
+        foundConnection = connections.find(function (conn) {
+          return conn.from === fromObject.uuid && conn.to === toObject.uuid || conn.from === toObject.uuid && conn.to === fromObject.uuid;
+        });
+        if (foundConnection) {
+          console.log('🔍 Found connection via object UUIDs:', foundConnection);
+          return foundConnection;
+        }
+      }
+
+      // Third try: look for any connection that might be related to this segment
+      // This is a fallback for cases where the connection structure is complex
+      console.log('🔍 Trying fallback: looking for any connection that might be related...');
+
+      // Look for connections that might involve the segment's path information
+      var possibleConnections = connections.filter(function (conn) {
+        var _sceneViewer$scene$ge, _sceneViewer$scene$ge2;
+        // Check if either end of the connection might be related to our segment
+        var fromMatches = conn.from === pathFrom || conn.from === pathTo;
+        var toMatches = conn.to === pathFrom || conn.to === pathTo;
+
+        // Also check if the connection involves any gateway or component that might be related
+        var fromIsGateway = ((_sceneViewer$scene$ge = sceneViewer.scene.getObjectByProperty('uuid', conn.from)) === null || _sceneViewer$scene$ge === void 0 || (_sceneViewer$scene$ge = _sceneViewer$scene$ge.userData) === null || _sceneViewer$scene$ge === void 0 ? void 0 : _sceneViewer$scene$ge.objectType) === 'gateway';
+        var toIsGateway = ((_sceneViewer$scene$ge2 = sceneViewer.scene.getObjectByProperty('uuid', conn.to)) === null || _sceneViewer$scene$ge2 === void 0 || (_sceneViewer$scene$ge2 = _sceneViewer$scene$ge2.userData) === null || _sceneViewer$scene$ge2 === void 0 ? void 0 : _sceneViewer$scene$ge2.objectType) === 'gateway';
+        return fromMatches || toMatches || fromIsGateway || toIsGateway;
+      });
+      if (possibleConnections.length > 0) {
+        console.log('🔍 Found possible related connections:', possibleConnections);
+        // Return the first one as a best guess
+        return possibleConnections[0];
+      }
+      console.log('❌ No connection found for segment');
+      return null;
+    }
+
+    /**
+     * Dispose of connector manager resources
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      console.log('🗑️ Disposing ConnectorManager...');
+
+      // Call parent dispose to clean up registered resources
+      _superPropGet(ConnectorManager, "dispose", this, 3)([]);
+
+      // Nullify properties
+      this.sceneViewer = null;
+      console.log('✅ ConnectorManager disposed');
+    }
+  }]);
+}(BaseDisposable);
+
+export { ConnectorManager };