@2112-lab/central-plant 0.1.1 → 0.1.3

package/dist/esm/src/sceneOperationsManager.js

@@ -1,572 +0,0 @@
-import { createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../_virtual/_rollupPluginBabelHelpers.js';
-import { findObjectByHardcodedUuid } from './nameUtils.js';
-
-/**
- * SceneOperationsManager
- * Handles scene loading, clearing, and object management operations
- */
-
-var THREE;
-
-/**
- * Dynamically import ThreeJS when in browser environment
- */
-function importDependencies() {
-  return _importDependencies.apply(this, arguments);
-}
-function _importDependencies() {
-  _importDependencies = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
-    var _t;
-    return _regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
-        case 0:
-          if (!(typeof window !== 'undefined')) {
-            _context.n = 4;
-            break;
-          }
-          _context.p = 1;
-          _context.n = 2;
-          return import('three');
-        case 2:
-          THREE = _context.v;
-          _context.n = 4;
-          break;
-        case 3:
-          _context.p = 3;
-          _t = _context.v;
-          console.error('Failed to load Three.js:', _t);
-          throw new Error('SceneOperationsManager: Required dependencies could not be loaded');
-        case 4:
-          return _context.a(2);
-      }
-    }, _callee, null, [[1, 3]]);
-  }));
-  return _importDependencies.apply(this, arguments);
-}
-
-/**
- * Class for managing scene operations like loading, clearing, and object management
- */
-var SceneOperationsManager = /*#__PURE__*/function () {
-  /**
-   * Create a SceneOperationsManager
-   * @param {Object} component - The component with scene, camera, renderer, etc.
-   */
-  function SceneOperationsManager(component) {
-    _classCallCheck(this, SceneOperationsManager);
-    this.component = component;
-
-    // Initialize if in browser environment
-    if (typeof window !== 'undefined') {
-      importDependencies();
-    }
-  }
-
-  /**
-   * Clear scene objects while preserving base environment
-   */
-  return _createClass(SceneOperationsManager, [{
-    key: "clearSceneObjects",
-    value: function clearSceneObjects() {
-      var component = this.component;
-      console.log('🧹 Starting scene clear operation...');
-
-      // First, deselect any currently selected object
-      this.deselectObject();
-
-      // Store reference to transform controls to ensure it's not removed
-      var transformControlsRef = null;
-      if (component.transformManager && component.transformManager.transformControls) {
-        // Explicitly disable transform controls before clearing
-        console.log('🔧 Disabling transform controls before scene clear');
-        component.transformManager.setEnabled(false);
-        component.transformManager.transformControls.visible = false;
-        transformControlsRef = component.transformManager.transformControls;
-        console.log('🔧 Stored reference to existing transform controls');
-      }
-      var objectsToRemove = [];
-      var transformControlsFound = 0;
-      var totalChildren = 0;
-      component.scene.traverse(function (child) {
-        var _child$userData, _child$userData2, _child$userData3, _child$userData4, _child$geometry;
-        totalChildren++;
-
-        // Check for transform controls using multiple detection methods
-        var isTransformControl = child === transformControlsRef || ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.isTransformControls) || child.isTransformControls || child.type && child.type.includes('TransformControls');
-        if (isTransformControl) {
-          transformControlsFound++;
-          console.log('🔧 Found transform controls, preserving:', child.uuid);
-        }
-
-        // Remove imported scene objects but preserve base ground, walls, lights, and transform controls
-        if (child !== component.scene && !((_child$userData2 = child.userData) !== null && _child$userData2 !== void 0 && _child$userData2.isBrickWall) && !((_child$userData3 = child.userData) !== null && _child$userData3 !== void 0 && _child$userData3.isBaseGround) && !((_child$userData4 = child.userData) !== null && _child$userData4 !== void 0 && _child$userData4.isBaseGrid) && !isTransformControl && !child.isLight && ((_child$geometry = child.geometry) === null || _child$geometry === void 0 ? void 0 : _child$geometry.type) !== 'PlaneGeometry') {
-          objectsToRemove.push(child);
-        }
-      });
-      console.log("\uD83D\uDCCA Scene analysis: ".concat(totalChildren, " total children, ").concat(transformControlsFound, " transform controls found, ").concat(objectsToRemove.length, " objects to remove"));
-      objectsToRemove.forEach(function (obj) {
-        component.scene.remove(obj);
-
-        // Dispose of geometry and materials to prevent memory leaks
-        if (obj.geometry) obj.geometry.dispose();
-        if (obj.material) {
-          if (Array.isArray(obj.material)) {
-            obj.material.forEach(function (mat) {
-              return mat.dispose();
-            });
-          } else {
-            obj.material.dispose();
-          }
-        }
-      });
-
-      // Clear any references to removed objects
-      component.selectedObjectForTransform = null;
-      if (component.transformHistory) {
-        component.transformHistory = [];
-      }
-
-      // Make sure transform controls exist after clearing
-      if (!component.transformManager || !component.transformManager.transformControls) {
-        console.log('🔧 Transform controls missing after scene clear, reinitializing...');
-        if (typeof component.initTransformControls === 'function') {
-          component.initTransformControls();
-        }
-      }
-
-      // Ensure transform controls are still properly attached after scene operations
-      this.ensureTransformControlsAttached(false);
-      console.log('✅ Scene clear operation completed');
-    }
-
-    /**
-     * Ensure transform controls remain properly attached after scene operations
-     * @param {boolean} attachToSelected - Whether to attach to selected object
-     */
-  }, {
-    key: "ensureTransformControlsAttached",
-    value: function ensureTransformControlsAttached() {
-      var attachToSelected = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      var component = this.component;
-      if (component.transformManager) {
-        // Re-enable transform controls after scene operations
-        component.transformManager.setEnabled(true);
-
-        // Reattach to selected object if one exists and flag is true
-        if (attachToSelected && component.selectedObjectForTransform) {
-          component.transformManager.selectObject(component.selectedObjectForTransform);
-        }
-      }
-    }
-
-    /**
-     * Deselect any selected object
-     */
-  }, {
-    key: "deselectObject",
-    value: function deselectObject() {
-      var component = this.component;
-      if (component.transformManager && component.selectedObjectForTransform) {
-        component.transformManager.deselectObject();
-        component.selectedObjectForTransform = null;
-      }
-    }
-
-    /**
-     * Load scene data from JSON
-     * @param {Object|string} sceneData - Scene data object or JSON string
-     */
-  }, {
-    key: "loadSceneData",
-    value: function loadSceneData(sceneData) {
-      var component = this.component;
-      console.log('📥 Starting scene load operation...');
-
-      // Parse JSON if string provided
-      var parsedData = sceneData;
-      if (typeof sceneData === 'string') {
-        try {
-          parsedData = JSON.parse(sceneData);
-        } catch (e) {
-          console.error('❌ Failed to parse scene data:', e);
-          return false;
-        }
-      }
-
-      // Validate scene data format
-      if (!parsedData || !parsedData.scene || !parsedData.scene.object) {
-        console.error('❌ Invalid scene data format');
-        return false;
-      }
-
-      // Store reference to scene data
-      component.currentSceneData = parsedData;
-
-      // Clear existing scene objects
-      this.clearSceneObjects();
-
-      // Load scene objects
-      this._loadSceneObjects(parsedData.scene.object);
-
-      // Load connections if applicable
-      if (parsedData.connections && Array.isArray(parsedData.connections)) {
-        this._loadConnections(parsedData.connections);
-      }
-      console.log('✅ Scene load completed');
-      return true;
-    }
-
-    /**
-     * Load scene objects from parsed scene data
-     * @param {Object} sceneObject - The root scene object from parsed data
-     * @private
-     */
-  }, {
-    key: "_loadSceneObjects",
-    value: function _loadSceneObjects(sceneObject) {
-      var _this = this;
-      var component = this.component;
-
-      // Recursively process all object children
-      if (sceneObject.children && Array.isArray(sceneObject.children)) {
-        sceneObject.children.forEach(function (childData) {
-          var childObject = _this._createObjectFromData(childData);
-          if (childObject) {
-            component.scene.add(childObject);
-          }
-        });
-      }
-    }
-
-    /**
-     * Create a Three.js object from object data
-     * @param {Object} objectData - The object data from parsed scene
-     * @returns {THREE.Object3D} The created object or null if invalid
-     * @private
-     */
-  }, {
-    key: "_createObjectFromData",
-    value: function _createObjectFromData(objectData) {
-      var _this2 = this;
-      // Ensure THREE is loaded
-      if (!THREE) {
-        console.warn('⚠️ THREE.js not loaded, cannot create objects');
-        return null;
-      }
-
-      // Create base object
-      var object = new THREE.Object3D();
-
-      // Set UUID (use hardcoded UUID if possible)
-      if (objectData.uuid) {
-        object.uuid = objectData.uuid;
-      }
-
-      // Set name
-      object.name = objectData.name || 'Unnamed';
-
-      // Set position
-      if (objectData.position) {
-        object.position.set(objectData.position.x || 0, objectData.position.y || 0, objectData.position.z || 0);
-      }
-
-      // Set rotation (convert from degrees to radians)
-      if (objectData.rotation) {
-        object.rotation.set((objectData.rotation.x || 0) * (Math.PI / 180), (objectData.rotation.y || 0) * (Math.PI / 180), (objectData.rotation.z || 0) * (Math.PI / 180));
-      }
-
-      // Set scale
-      if (objectData.scale) {
-        object.scale.set(objectData.scale.x || 1, objectData.scale.y || 1, objectData.scale.z || 1);
-      }
-
-      // Set userData
-      if (objectData.userData) {
-        object.userData = _objectSpread2({}, objectData.userData);
-      }
-
-      // Special handling for different object types
-      this._setupObjectByType(object, objectData);
-
-      // Process children recursively
-      if (objectData.children && Array.isArray(objectData.children)) {
-        objectData.children.forEach(function (childData) {
-          var childObject = _this2._createObjectFromData(childData);
-          if (childObject) {
-            object.add(childObject);
-          }
-        });
-      }
-      return object;
-    }
-
-    /**
-     * Set up object properties based on type
-     * @param {THREE.Object3D} object - The object to set up
-     * @param {Object} objectData - The object data
-     * @private
-     */
-  }, {
-    key: "_setupObjectByType",
-    value: function _setupObjectByType(object, objectData) {
-      var _objectData$userData, _objectData$userData2;
-      // Handle library component objects
-      if ((_objectData$userData = objectData.userData) !== null && _objectData$userData !== void 0 && _objectData$userData.componentType && (_objectData$userData2 = objectData.userData) !== null && _objectData$userData2 !== void 0 && _objectData$userData2.libraryId) {
-        // If model preloader is available, attempt to load model
-        if (this.component.modelPreloader) {
-          this.component.modelPreloader.loadComponentById(objectData.userData.libraryId, function (model) {
-            if (model) {
-              // Copy model but preserve our object's transform and userData
-              var position = object.position.clone();
-              var rotation = object.rotation.clone();
-              var scale = object.scale.clone();
-              var userData = _objectSpread2({}, object.userData);
-
-              // Copy model properties to our object
-              object.copy(model);
-
-              // Restore transform and userData
-              object.position.copy(position);
-              object.rotation.copy(rotation);
-              object.scale.copy(scale);
-              object.userData = userData;
-              console.log("\u2705 Loaded model for ".concat(objectData.name, " (").concat(objectData.userData.libraryId, ")"));
-            }
-          });
-        }
-      }
-
-      // Handle primitive geometry
-      if (objectData.geometry) {
-        var geometry;
-
-        // Create appropriate geometry based on type hint
-        if (objectData.geometry === 'CONNECTOR-GEO') {
-          geometry = new THREE.SphereGeometry(0.5, 16, 16);
-        } else if (objectData.geometry === 'GATEWAY-GEO') {
-          geometry = new THREE.CylinderGeometry(0.5, 0.5, 1, 16);
-        } else {
-          // Default to box geometry for other types
-          geometry = new THREE.BoxGeometry(1, 1, 1);
-        }
-
-        // Create mesh with geometry and basic material
-        var material = new THREE.MeshStandardMaterial({
-          color: 0x999999,
-          transparent: true,
-          opacity: 0.7
-        });
-        var mesh = new THREE.Mesh(geometry, material);
-
-        // Copy transform from parent
-        mesh.position.copy(object.position);
-        mesh.rotation.copy(object.rotation);
-        mesh.scale.copy(object.scale);
-
-        // Reset parent transform since the mesh now has it
-        object.position.set(0, 0, 0);
-        object.rotation.set(0, 0, 0);
-        object.scale.set(1, 1, 1);
-
-        // Add mesh as child of parent
-        object.add(mesh);
-      }
-    }
-
-    /**
-     * Load connections from scene data
-     * @param {Array} connections - Array of connection objects
-     * @private
-     */
-  }, {
-    key: "_loadConnections",
-    value: function _loadConnections(connections) {
-      var component = this.component;
-      if (!component.pathfindingManager) {
-        console.warn('⚠️ Cannot load connections: pathfindingManager not available');
-        return;
-      }
-
-      // Clear existing connections
-      if (component.pathfindingManager.clearAllPaths) {
-        component.pathfindingManager.clearAllPaths();
-      }
-
-      // Process each connection
-      connections.forEach(function (connection) {
-        if (!connection.source || !connection.target) {
-          return;
-        }
-
-        // Find source and target objects
-        var sourceObj = findObjectByHardcodedUuid(component.scene, connection.source);
-        var targetObj = findObjectByHardcodedUuid(component.scene, connection.target);
-        if (sourceObj && targetObj) {
-          // Create connection if objects found
-          component.pathfindingManager.createConnection(sourceObj, targetObj, connection.type || 'default');
-        } else {
-          console.warn("\u26A0\uFE0F Could not create connection: objects not found (".concat(connection.source, " -> ").concat(connection.target, ")"));
-        }
-      });
-    }
-
-    /**
-     * Ensure scene elements are visible
-     * Makes sure all scene elements are properly visible and within camera view
-     */
-  }, {
-    key: "ensureSceneElementsVisible",
-    value: function ensureSceneElementsVisible() {
-      var component = this.component;
-      if (!component.scene || !component.camera) {
-        console.warn('⚠️ Cannot ensure scene elements visibility: scene or camera missing');
-        return false;
-      }
-
-      // Reset camera position if it's too close to origin
-      if (component.camera.position.length() < 5) {
-        component.camera.position.set(10, 10, 10);
-        component.camera.lookAt(0, 0, 0);
-        if (component.controls) {
-          component.controls.target.set(0, 0, 0);
-          component.controls.update();
-        }
-      }
-
-      // Check if scene has any visible objects
-      var hasVisibleObjects = false;
-      component.scene.traverse(function (child) {
-        if (child.visible && child !== component.scene && !child.isLight) {
-          hasVisibleObjects = true;
-        }
-      });
-      if (!hasVisibleObjects) {
-        console.warn('⚠️ Scene has no visible objects');
-      }
-      return hasVisibleObjects;
-    }
-
-    /**
-     * Find object in scene by name
-     * @param {string} name - The name to search for
-     * @returns {THREE.Object3D|null} The found object or null
-     */
-  }, {
-    key: "findObjectByName",
-    value: function findObjectByName(name) {
-      if (!name || !this.component.scene) {
-        return null;
-      }
-      var foundObject = null;
-      this.component.scene.traverse(function (child) {
-        if (child.name === name) {
-          foundObject = child;
-        }
-      });
-      return foundObject;
-    }
-
-    /**
-     * Find object in scene by UUID
-     * @param {string} uuid - The UUID to search for
-     * @returns {THREE.Object3D|null} The found object or null
-     */
-  }, {
-    key: "findObjectByUuid",
-    value: function findObjectByUuid(uuid) {
-      if (!uuid || !this.component.scene) {
-        return null;
-      }
-      var foundObject = null;
-      this.component.scene.traverse(function (child) {
-        if (child.uuid === uuid) {
-          foundObject = child;
-        }
-      });
-      return foundObject;
-    }
-
-    /**
-     * Remove an object from the scene
-     * @param {THREE.Object3D} object - The object to remove
-     */
-  }, {
-    key: "removeObject",
-    value: function removeObject(object) {
-      if (!object || !this.component.scene) {
-        return false;
-      }
-
-      // Deselect if this is the selected object
-      if (this.component.selectedObjectForTransform === object) {
-        this.deselectObject();
-      }
-
-      // Remove from scene
-      this.component.scene.remove(object);
-
-      // Dispose resources
-      if (object.geometry) object.geometry.dispose();
-      if (object.material) {
-        if (Array.isArray(object.material)) {
-          object.material.forEach(function (mat) {
-            return mat.dispose();
-          });
-        } else {
-          object.material.dispose();
-        }
-      }
-      return true;
-    }
-
-    /**
-     * Duplicate an object in the scene
-     * @param {THREE.Object3D} sourceObject - The object to duplicate
-     * @param {Object} [options] - Options for duplication
-     * @param {THREE.Vector3} [options.positionOffset] - Position offset for the duplicate
-     * @returns {THREE.Object3D|null} The duplicated object or null if failed
-     */
-  }, {
-    key: "duplicateObject",
-    value: function duplicateObject(sourceObject) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      if (!sourceObject || !this.component.scene) {
-        return null;
-      }
-
-      // Create clone of source object
-      var clonedObject = sourceObject.clone();
-
-      // Generate new UUID to ensure uniqueness
-      clonedObject.uuid = THREE.MathUtils.generateUUID();
-
-      // Update name to indicate it's a copy
-      if (!clonedObject.name.includes('_copy')) {
-        clonedObject.name = "".concat(clonedObject.name, "_copy");
-      }
-
-      // Apply position offset if specified
-      if (options.positionOffset) {
-        clonedObject.position.add(options.positionOffset);
-      } else {
-        // Default offset if none provided
-        clonedObject.position.x += 2;
-      }
-
-      // Add to scene
-      this.component.scene.add(clonedObject);
-      return clonedObject;
-    }
-  }]);
-}();
-
-/**
- * Factory function to get SceneOperationsManager instance
- * @param {CentralPlantComponent} component - The component instance 
- * @returns {SceneOperationsManager} SceneOperationsManager instance
- */
-function getSceneOperationsManager(component) {
-  return new SceneOperationsManager(component);
-}
-
-export { SceneOperationsManager, SceneOperationsManager as default, getSceneOperationsManager };