@2112-lab/central-plant 0.1.4 → 0.1.5

package/dist/cjs/src/core/centralPlant.js

@@ -1 +1,1149 @@
-"use strict";Object.defineProperty(exports,"t",{value:!0});var e=require("../../_virtual/_rollupPluginBabelHelpers.js"),t=require("../managers/controls/transformControlsManager.js"),n=require("../managers/system/hotReloadManager.js"),i=require("../managers/system/disposalManager.js"),a=require("../managers/scene/sceneExportManager.js"),s=require("../managers/components/componentManager.js"),r=require("../managers/scene/sceneInitializationManager.js"),o=require("../managers/environment/environmentManager.js"),u=require("../managers/controls/keyboardControlsManager.js"),l=require("../managers/components/pathfindingManager.js"),c=require("../managers/scene/sceneOperationsManager.js"),h=require("../managers/components/animationManager.js"),d=require("../managers/controls/cameraControlsManager.js"),v=require("../managers/scene/sceneTooltipsManager.js"),f=require("./nameUtils.js"),m=require("./debugLogger.js"),p=require("../rendering/modelPreloader.js"),g=require("../managers/controls/dragDropManager.js"),y=require("../helpers/sceneHelper.js"),w=function(){return e.createClass(function t(){var n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null;e.classCallCheck(this,t),this.sceneViewer=n,this.managers={},this.utilities={},this.isInitialized=!1,this.importedSceneData=null,this.metadata={},this.transformHistory={lastTransform:null},this.setDefaultSceneMetadata(),this.initializeUtilities(),n&&(this.initializeManagers(),this.isInitialized=!0)},[{key:"setSceneViewer",value:function(e){this.sceneViewer=e,!this.isInitialized&&e&&(this.initializeManagers(),this.isInitialized=!0)}},{key:"initializeManagers",value:function(){this.sceneViewer&&(this.managers.hotReloadManager=new n.HotReloadManager(this.sceneViewer),this.managers.disposalManager=new i.DisposalManager(this.sceneViewer),this.managers.sceneExportManager=new a.SceneExportManager(this.sceneViewer),this.managers.componentManager=new s.ComponentManager(this.sceneViewer),this.managers.sceneInitializationManager=new r.SceneInitializationManager(this.sceneViewer),this.managers.environmentManager=new o.EnvironmentManager(this.sceneViewer),this.managers.keyboardControlsManager=new u.KeyboardControlsManager(this.sceneViewer),this.managers.pathfindingManager=new l.PathfindingManager(this.sceneViewer),this.managers.sceneOperationsManager=new c.SceneOperationsManager(this.sceneViewer),this.managers.animationManager=new h.AnimationManager(this.sceneViewer),this.managers.cameraControlsManager=new d.CameraControlsManager(this.sceneViewer))}},{key:"initializeUtilities",value:function(){this.utilities.createTransformControls=t.createTransformControls,this.utilities.generateUuidFromName=f.generateUuidFromName,this.utilities.getHardcodedUuid=f.getHardcodedUuid,this.utilities.logger=m.logger,this.utilities.transformLogger=m.transformLogger,this.utilities.pathfinderLogger=m.pathfinderLogger,this.utilities.modelLogger=m.modelLogger,this.utilities.modelPreloader=p.default,this.utilities.SceneHelper=y.SceneHelper,this.utilities.DragDropManager=g.default}},{key:"attachToComponent",value:function(){var e=this;this.sceneViewer&&(this.isInitialized||this.initializeManagers(),Object.keys(this.managers).forEach(function(t){e.sceneViewer[t]=e.managers[t]}),Object.keys(this.utilities).forEach(function(t){e.sceneViewer[t]=e.utilities[t]}))}},{key:"initializePostSceneManagers",value:function(){this.sceneViewer.$refs.container&&this.sceneViewer.camera&&this.sceneViewer.scene&&(this.managers.tooltipsManager=new v.SceneTooltipsManager(this.sceneViewer.$refs.container,this.sceneViewer.camera,this.sceneViewer.scene),this.sceneViewer.tooltipsManager=this.managers.tooltipsManager),this.sceneViewer.scene&&this.sceneViewer.camera&&(this.managers.dragDropManager=new g.default({scene:this.sceneViewer.scene,camera:this.sceneViewer.camera,transformManager:this.sceneViewer.transformManager,modelPreloader:this.utilities.modelPreloader,componentManager:this.sceneViewer.componentManager}),this.sceneViewer.dragDropManager=this.managers.dragDropManager),this.sceneViewer.scene&&this.sceneViewer.camera&&this.sceneViewer.renderer&&(this.utilities.sceneHelper=new y.SceneHelper({scene:this.sceneViewer.scene,camera:this.sceneViewer.camera,renderer:this.sceneViewer.renderer,controls:this.sceneViewer.controls,transformManager:this.sceneViewer.transformManager,componentManager:this.sceneViewer.componentManager,pathfindingManager:this.sceneViewer.pathfindingManager,currentSceneData:this.sceneViewer.currentSceneData,logger:this.utilities.logger}),this.sceneViewer.sceneHelper=this.utilities.sceneHelper)}},{key:"updateSceneHelperData",value:function(e){this.utilities.sceneHelper&&"function"==typeof this.utilities.sceneHelper.updateSceneData&&this.utilities.sceneHelper.updateSceneData(e)}},{key:"setImportedSceneData",value:function(t){this.importedSceneData=e.objectSpread2({},t),this.setDefaultImportedSceneMetadata(t),this.utilities.sceneHelper&&"function"==typeof this.utilities.sceneHelper.updateSceneData&&this.utilities.sceneHelper.updateSceneData(t)}},{key:"getImportedSceneData",value:function(){return this.importedSceneData}},{key:"getImportedConnections",value:function(){var e;return(null===(e=this.importedSceneData)||void 0===e?void 0:e.connections)||[]}},{key:"getImportedSceneObjects",value:function(){var e;return(null===(e=this.importedSceneData)||void 0===e||null===(e=e.scene)||void 0===e?void 0:e.object)||null}},{key:"clearImportedSceneData",value:function(){this.importedSceneData=null}},{key:"setMetadata",value:function(e,t){this.metadata[e]=t}},{key:"getMetadata",value:function(e){return this.metadata[e]}},{key:"getAllMetadata",value:function(){return e.objectSpread2({},this.metadata)}},{key:"removeMetadata",value:function(e){delete this.metadata[e]}},{key:"clearAllMetadata",value:function(){this.metadata={}}},{key:"clearAllData",value:function(){this.metadata={},this.transformHistory.lastTransform=null}},{key:"recordTransform",value:function(e){var t,n;if(e&&e.object){e.previousValues;var i={type:e.type,object:e.object,values:e.values,previousValues:e.previousValues,timestamp:(new Date).toISOString(),objectId:(null===(t=e.object)||void 0===t?void 0:t.uuid)||(null===(n=e.object)||void 0===n?void 0:n.id)||"unknown"};this.transformHistory.lastTransform=i}}},{key:"getLastTransform",value:function(){return this.transformHistory.lastTransform}},{key:"getTransformHistory",value:function(){return e.objectSpread2({},this.transformHistory)}},{key:"clearTransformHistory",value:function(){this.transformHistory.lastTransform=null}},{key:"hasMetadata",value:function(e){return e in this.metadata}},{key:"setDefaultSceneMetadata",value:function(){var e=this,t={sceneInfo:{name:"Untitled Central Plant Scene",description:"A central plant facility scene",version:"1.0.0",created:(new Date).toISOString(),lastModified:(new Date).toISOString(),author:"Engineering Team"},projectSettings:{units:"metric",scale:1,gridSize:1,snapToGrid:!0,showGrid:!0,showAxes:!0},viewportSettings:{defaultViewMode:"perspective",backgroundType:"skybox",showEnvironment:!0,autoRotate:!1,cameraPosition:{x:10,y:10,z:10},cameraTarget:{x:0,y:0,z:0}},componentSettings:{defaultComponentScale:1,showBoundingBoxes:!1,showConnectionPaths:!0,highlightOnHover:!0,selectionOutlineColor:"#00ff00"},spatialBoundaries:{min:{x:-60,y:-16,z:-60},max:{x:60,y:16,z:60},center:{x:0,y:4,z:0}},systemInfo:{centralPlantVersion:"2.0.0",buildDate:(new Date).toISOString(),platform:"undefined"!=typeof window?window.navigator.platform:"Unknown",userAgent:"undefined"!=typeof window?window.navigator.userAgent:"Unknown"}};Object.keys(t).forEach(function(n){e.hasMetadata(n)||e.setMetadata(n,t[n])})}},{key:"setDefaultImportedSceneMetadata",value:function(t){var n,i,a,s=(new Date).toISOString(),r=(null===(n=t.connections)||void 0===n?void 0:n.length)||0,o=(null===(i=t.scene)||void 0===i||null===(i=i.object)||void 0===i||null===(i=i.children)||void 0===i?void 0:i.length)||0,u={};null!==(a=t.scene)&&void 0!==a&&null!==(a=a.object)&&void 0!==a&&a.children&&t.scene.object.children.forEach(function(e){var t,n=(null===(t=e.userData)||void 0===t?void 0:t.componentType)||"unknown";u[n]=(u[n]||0)+1});var l={importInfo:{importTimestamp:s,originalFileName:null,fileSize:null,importMethod:"file-upload",importVersion:"1.0.0"},sceneAnalysis:{totalComponents:o,totalConnections:r,componentTypes:u,sceneComplexity:this.calculateSceneComplexity(r,o),hasValidStructure:this.validateImportedSceneStructure(t)},dataQuality:{hasConnections:r>0,hasComponents:o>0,hasValidScene:!!t.scene,missingData:this.identifyMissingData(t),warnings:this.generateImportWarnings(t)},processingStats:{processedAt:s,processingDuration:null,memoryUsage:this.estimateMemoryUsage(t),cacheStatus:"pending"}};if(this.setMetadata("lastImport",l),this.hasMetadata("sceneInfo")){var c=this.getMetadata("sceneInfo");this.setMetadata("sceneInfo",e.objectSpread2(e.objectSpread2({},c),{},{lastModified:s,importSource:"file-import",dataSourceType:"json"}))}}},{key:"calculateSceneComplexity",value:function(e,t){var n=e+t;return n<=10?"simple":n<=50?"moderate":n<=200?"complex":"very-complex"}},{key:"validateImportedSceneStructure",value:function(e){return!!(e&&e.scene&&e.scene.object&&Array.isArray(e.connections))}},{key:"identifyMissingData",value:function(e){var t,n=[];return e.connections&&0!==e.connections.length||n.push("No connection data found"),null!==(t=e.scene)&&void 0!==t&&null!==(t=t.object)&&void 0!==t&&t.children&&0!==e.scene.object.children.length||n.push("No component data found"),e.metadata||n.push("No metadata found"),e.version||n.push("No version information"),n}},{key:"generateImportWarnings",value:function(e){var t,n,i=[],a=(null===(t=e.scene)||void 0===t||null===(t=t.object)||void 0===t||null===(t=t.children)||void 0===t?void 0:t.length)||0;a>100&&i.push("Large scene detected (".concat(a," components) - may impact performance"));var s=(null===(n=e.connections)||void 0===n?void 0:n.length)||0;return a>0&&0===s&&i.push("Components found but no connections - scene may be incomplete"),e.version&&parseFloat(e.version)<1&&i.push("Scene data version is older than current - some features may not work correctly"),i}},{key:"estimateMemoryUsage",value:function(e){var t=JSON.stringify(e).length,n=(t/1024/1024).toFixed(2);return{jsonSizeBytes:t,estimatedMB:parseFloat(n),category:n<1?"small":n<10?"medium":"large"}}},{key:"updateMetadataCategory",value:function(t,n){if(this.hasMetadata(t)){var i=this.getMetadata(t);this.setMetadata(t,e.objectSpread2(e.objectSpread2({},i),n))}else this.setMetadata(t,n)}},{key:"undoTransform",value:function(){var e=this.getLastTransform();if(!e)return!1;try{var t,n=e.object,i=e.type,a=e.previousValues;if(!n||!a)return!1;if(this.debugTransformState(n,"Before Undo"),this.sceneViewer&&this.sceneViewer.scene){var s=!1;if(this.sceneViewer.scene.traverse(function(e){e===n&&(s=!0)}),!s)return!1}switch(i){case"translate":case"position":a.position?(void 0!==a.position.x&&(n.position.x=a.position.x),void 0!==a.position.y&&(n.position.y=a.position.y),void 0!==a.position.z&&(n.position.z=a.position.z)):(void 0!==a.x&&(n.position.x=a.x),void 0!==a.y&&(n.position.y=a.y),void 0!==a.z&&(n.position.z=a.z));break;case"rotate":case"rotation":a.rotation?(void 0!==a.rotation.x&&(n.rotation.x=a.rotation.x),void 0!==a.rotation.y&&(n.rotation.y=a.rotation.y),void 0!==a.rotation.z&&(n.rotation.z=a.rotation.z)):(void 0!==a.x&&(n.rotation.x=a.x),void 0!==a.y&&(n.rotation.y=a.y),void 0!==a.z&&(n.rotation.z=a.z));break;case"scale":a.scale?(void 0!==a.scale.x&&(n.scale.x=a.scale.x),void 0!==a.scale.y&&(n.scale.y=a.scale.y),void 0!==a.scale.z&&(n.scale.z=a.scale.z)):(void 0!==a.x&&(n.scale.x=a.x),void 0!==a.y&&(n.scale.y=a.y),void 0!==a.z&&(n.scale.z=a.z));break;default:return!1}n.updateMatrix(),n.updateMatrixWorld(!0);var r=null===(t=this.sceneViewer)||void 0===t?void 0:t.transformManager;if(r&&r.transformControls){var o=r.transformControls;o.object===n&&(o.detach(),r.ensureSceneAttachment&&r.ensureSceneAttachment(!0),o.attach(n),r.selectedObject=n,r.updateBoundingBox&&r.updateBoundingBox(),r.boundingBoxCache&&r.boundingBoxCache.has(n)&&r.boundingBoxCache.delete(n))}if(this.sceneViewer&&this.sceneViewer.sceneOperationsManager&&this.sceneViewer.currentSceneData)try{this.sceneViewer.onTransformEnd(n)}catch(e){}if("undefined"!=typeof window){var u=new CustomEvent("sceneUpdateComplete",{detail:{timestamp:Date.now(),action:"undo-transform",objectId:n.uuid||n.id||"unknown"}});window.dispatchEvent(u)}return this.clearTransformHistory(),this.ensureObjectSelectable(n),this.debugTransformState(n,"After Undo"),!0}catch(e){return!1}}},{key:"ensureObjectSelectable",value:function(e){if(!e||!this.sceneViewer)return!1;try{var t=this.sceneViewer.transformManager;return!!t&&(t.recoverTransformControls?t.recoverTransformControls(e):(e.updateMatrixWorld(!0),t.boundingBoxCache&&t.boundingBoxCache.has(e)&&t.boundingBoxCache.delete(e),t.ensureSceneAttachment&&t.ensureSceneAttachment(!0),t.selectedObject===e&&(t.deselectObject(),requestAnimationFrame(function(){t.selectObjectForTransformOnly(e)})),!0))}catch(e){return!1}}},{key:"debugTransformState",value:function(e){}},{key:"fixTransformControlsSelection",value:function(){if(!this.sceneViewer||!this.sceneViewer.transformManager)return!1;var e=this.sceneViewer.transformManager;if(e.recoverTransformControls&&e.recoverTransformControls())return!0;try{var t=e.currentMode,n=e.currentSpace;return e.transformControls&&(e.transformControls.detach(),e.scene.remove(e.transformControls),e.transformControls.dispose(),e.transformControls=null),e.createTransformControls(),e.setupEventListeners(),e.setMode(t),e.setSpace(n),!0}catch(e){return!1}}},{key:"isObjectInScene",value:function(e){if(!this.sceneViewer||!this.sceneViewer.scene)return!1;var t=!1;return this.sceneViewer.scene.traverse(function(n){n===e&&(t=!0)}),t}}])}();exports.CentralPlant=w,exports.default=w;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
+var transformControlsManager = require('../managers/controls/transformControlsManager.js');
+var hotReloadManager = require('../managers/system/hotReloadManager.js');
+var disposalManager = require('../managers/system/disposalManager.js');
+var sceneExportManager = require('../managers/scene/sceneExportManager.js');
+var componentManager = require('../managers/components/componentManager.js');
+var sceneInitializationManager = require('../managers/scene/sceneInitializationManager.js');
+var environmentManager = require('../managers/environment/environmentManager.js');
+var keyboardControlsManager = require('../managers/controls/keyboardControlsManager.js');
+var pathfindingManager = require('../managers/components/pathfindingManager.js');
+var sceneOperationsManager = require('../managers/scene/sceneOperationsManager.js');
+var animationManager = require('../managers/components/animationManager.js');
+var cameraControlsManager = require('../managers/controls/cameraControlsManager.js');
+var sceneTooltipsManager = require('../managers/scene/sceneTooltipsManager.js');
+var nameUtils = require('./nameUtils.js');
+var debugLogger = require('./debugLogger.js');
+var modelPreloader = require('../rendering/modelPreloader.js');
+var dragDropManager = require('../managers/controls/dragDropManager.js');
+var sceneHelper = require('../helpers/sceneHelper.js');
+
+/**
+ * CentralPlant class that manages all scene utility instances
+ */
+var CentralPlant = /*#__PURE__*/function () {
+  /**
+   * Initialize the CentralPlant manager
+   * @param {Object} sceneViewer - The SceneViewerEnhanced component instance
+   */
+  function CentralPlant() {
+    var sceneViewer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    _rollupPluginBabelHelpers.classCallCheck(this, CentralPlant);
+    this.sceneViewer = sceneViewer;
+    this.managers = {};
+    this.utilities = {};
+    this.isInitialized = false;
+
+    // Store imported scene data directly
+    this.importedSceneData = null;
+
+    // Add metadata storage
+    this.metadata = {};
+
+    // Add transform history tracking
+    this.transformHistory = {
+      lastTransform: null
+    };
+
+    // Set default scene metadata
+    this.setDefaultSceneMetadata();
+
+    // Initialize utilities immediately (they don't need scene viewer)
+    this.initializeUtilities();
+
+    // Initialize managers only if sceneViewer is provided
+    if (sceneViewer) {
+      this.initializeManagers();
+      this.isInitialized = true;
+    }
+  }
+
+  /**
+   * Set the scene viewer instance and initialize managers if not already done
+   * @param {Object} sceneViewer - The SceneViewerEnhanced component instance
+   */
+  return _rollupPluginBabelHelpers.createClass(CentralPlant, [{
+    key: "setSceneViewer",
+    value: function setSceneViewer(sceneViewer) {
+      this.sceneViewer = sceneViewer;
+      if (!this.isInitialized && sceneViewer) {
+        this.initializeManagers();
+        this.isInitialized = true;
+      }
+    }
+
+    /**
+     * Initialize all manager instances
+     */
+  }, {
+    key: "initializeManagers",
+    value: function initializeManagers() {
+      if (!this.sceneViewer) {
+        console.warn('⚠️ Cannot initialize managers without scene viewer');
+        return;
+      }
+
+      // Initialize all managers consistently
+      this.managers.hotReloadManager = new hotReloadManager.HotReloadManager(this.sceneViewer);
+      this.managers.disposalManager = new disposalManager.DisposalManager(this.sceneViewer);
+      this.managers.sceneExportManager = new sceneExportManager.SceneExportManager(this.sceneViewer);
+      this.managers.componentManager = new componentManager.ComponentManager(this.sceneViewer);
+      this.managers.sceneInitializationManager = new sceneInitializationManager.SceneInitializationManager(this.sceneViewer);
+      this.managers.environmentManager = new environmentManager.EnvironmentManager(this.sceneViewer);
+      this.managers.keyboardControlsManager = new keyboardControlsManager.KeyboardControlsManager(this.sceneViewer);
+      this.managers.pathfindingManager = new pathfindingManager.PathfindingManager(this.sceneViewer);
+      this.managers.sceneOperationsManager = new sceneOperationsManager.SceneOperationsManager(this.sceneViewer);
+      this.managers.animationManager = new animationManager.AnimationManager(this.sceneViewer);
+      this.managers.cameraControlsManager = new cameraControlsManager.CameraControlsManager(this.sceneViewer);
+
+      // All managers are now stored in the managers collection and will be attached via attachToComponent()
+    }
+
+    /**
+     * Initialize utility functions and objects
+     */
+  }, {
+    key: "initializeUtilities",
+    value: function initializeUtilities() {
+      // Transform controls factory function
+      this.utilities.createTransformControls = transformControlsManager.createTransformControls;
+
+      // Name utilities
+      this.utilities.generateUuidFromName = nameUtils.generateUuidFromName;
+      this.utilities.getHardcodedUuid = nameUtils.getHardcodedUuid;
+
+      // Loggers
+      this.utilities.logger = debugLogger.logger;
+      this.utilities.transformLogger = debugLogger.transformLogger;
+      this.utilities.pathfinderLogger = debugLogger.pathfinderLogger;
+      this.utilities.modelLogger = debugLogger.modelLogger;
+
+      // Model preloader
+      this.utilities.modelPreloader = modelPreloader["default"];
+
+      // Scene helper utility
+      this.utilities.SceneHelper = sceneHelper.SceneHelper;
+
+      // Drag drop manager factory (will be initialized after scene is ready)
+      this.utilities.DragDropManager = dragDropManager["default"];
+    }
+
+    /**
+     * Set all managers and utilities on the scene viewer instance
+     */
+  }, {
+    key: "attachToComponent",
+    value: function attachToComponent() {
+      var _this = this;
+      if (!this.sceneViewer) {
+        console.warn('⚠️ Cannot attach to component: no scene viewer set');
+        return;
+      }
+
+      // Initialize managers if not already done
+      if (!this.isInitialized) {
+        this.initializeManagers();
+      }
+
+      // Attach all managers to the scene viewer instance
+      Object.keys(this.managers).forEach(function (key) {
+        _this.sceneViewer[key] = _this.managers[key];
+      });
+
+      // Attach utilities to the scene viewer instance
+      Object.keys(this.utilities).forEach(function (key) {
+        _this.sceneViewer[key] = _this.utilities[key];
+      });
+    }
+
+    /**
+     * Initialize specific managers that need to be created after scene setup
+     */
+  }, {
+    key: "initializePostSceneManagers",
+    value: function initializePostSceneManagers() {
+      // Initialize the tooltip manager (needs container, camera, scene)
+      if (this.sceneViewer.$refs.container && this.sceneViewer.camera && this.sceneViewer.scene) {
+        this.managers.tooltipsManager = new sceneTooltipsManager.SceneTooltipsManager(this.sceneViewer.$refs.container, this.sceneViewer.camera, this.sceneViewer.scene);
+        this.sceneViewer.tooltipsManager = this.managers.tooltipsManager;
+        console.log('🔍 Tooltip manager initialized:', this.managers.tooltipsManager);
+      }
+
+      // Initialize the drag and drop manager (needs scene, camera, etc.)
+      if (this.sceneViewer.scene && this.sceneViewer.camera) {
+        this.managers.dragDropManager = new dragDropManager["default"]({
+          scene: this.sceneViewer.scene,
+          camera: this.sceneViewer.camera,
+          transformManager: this.sceneViewer.transformManager,
+          modelPreloader: this.utilities.modelPreloader,
+          componentManager: this.sceneViewer.componentManager
+        });
+        this.sceneViewer.dragDropManager = this.managers.dragDropManager;
+        console.log('🎯 Drag and drop manager initialized');
+      }
+
+      // Initialize the scene helper utility (needs scene, camera, renderer, etc.)
+      if (this.sceneViewer.scene && this.sceneViewer.camera && this.sceneViewer.renderer) {
+        this.utilities.sceneHelper = new sceneHelper.SceneHelper({
+          scene: this.sceneViewer.scene,
+          camera: this.sceneViewer.camera,
+          renderer: this.sceneViewer.renderer,
+          controls: this.sceneViewer.controls,
+          transformManager: this.sceneViewer.transformManager,
+          componentManager: this.sceneViewer.componentManager,
+          pathfindingManager: this.sceneViewer.pathfindingManager,
+          currentSceneData: this.sceneViewer.currentSceneData,
+          logger: this.utilities.logger
+        });
+        this.sceneViewer.sceneHelper = this.utilities.sceneHelper;
+        console.log('🔧 Scene helper utility initialized:', this.utilities.sceneHelper);
+      }
+    }
+
+    /**
+     * Update scene helper with new scene data
+     * @param {Object} sceneData - Updated scene data
+     */
+  }, {
+    key: "updateSceneHelperData",
+    value: function updateSceneHelperData(sceneData) {
+      if (this.utilities.sceneHelper && typeof this.utilities.sceneHelper.updateSceneData === 'function') {
+        this.utilities.sceneHelper.updateSceneData(sceneData);
+        console.log('🔄 Scene helper data updated');
+      }
+    }
+
+    /**
+     * Set imported scene data directly in CentralPlant
+     * @param {Object} sceneData - The imported scene data (from cp-01-01.json or other scene files)
+     */
+  }, {
+    key: "setImportedSceneData",
+    value: function setImportedSceneData(sceneData) {
+      var _this$importedSceneDa, _this$importedSceneDa2;
+      this.importedSceneData = _rollupPluginBabelHelpers.objectSpread2({}, sceneData);
+      console.log('📥 Imported scene data stored in CentralPlant:', {
+        connections: ((_this$importedSceneDa = this.importedSceneData.connections) === null || _this$importedSceneDa === void 0 ? void 0 : _this$importedSceneDa.length) || 0,
+        sceneObjects: ((_this$importedSceneDa2 = this.importedSceneData.scene) === null || _this$importedSceneDa2 === void 0 || (_this$importedSceneDa2 = _this$importedSceneDa2.object) === null || _this$importedSceneDa2 === void 0 || (_this$importedSceneDa2 = _this$importedSceneDa2.children) === null || _this$importedSceneDa2 === void 0 ? void 0 : _this$importedSceneDa2.length) || 0,
+        timestamp: new Date().toISOString()
+      });
+
+      // Set default metadata for imported scene data
+      this.setDefaultImportedSceneMetadata(sceneData);
+
+      // Also update the scene helper if available
+      if (this.utilities.sceneHelper && typeof this.utilities.sceneHelper.updateSceneData === 'function') {
+        this.utilities.sceneHelper.updateSceneData(sceneData);
+      }
+    }
+
+    /**
+     * Get the stored imported scene data
+     * @returns {Object|null} The imported scene data or null if none is stored
+     */
+  }, {
+    key: "getImportedSceneData",
+    value: function getImportedSceneData() {
+      return this.importedSceneData;
+    }
+
+    /**
+     * Get connections from the imported scene data
+     * @returns {Array} The connections array or empty array if none
+     */
+  }, {
+    key: "getImportedConnections",
+    value: function getImportedConnections() {
+      var _this$importedSceneDa3;
+      return ((_this$importedSceneDa3 = this.importedSceneData) === null || _this$importedSceneDa3 === void 0 ? void 0 : _this$importedSceneDa3.connections) || [];
+    }
+
+    /**
+     * Get scene objects from the imported scene data
+     * @returns {Object|null} The scene object structure or null if none
+     */
+  }, {
+    key: "getImportedSceneObjects",
+    value: function getImportedSceneObjects() {
+      var _this$importedSceneDa4;
+      return ((_this$importedSceneDa4 = this.importedSceneData) === null || _this$importedSceneDa4 === void 0 || (_this$importedSceneDa4 = _this$importedSceneDa4.scene) === null || _this$importedSceneDa4 === void 0 ? void 0 : _this$importedSceneDa4.object) || null;
+    }
+
+    /**
+     * Clear the stored imported scene data
+     */
+  }, {
+    key: "clearImportedSceneData",
+    value: function clearImportedSceneData() {
+      this.importedSceneData = null;
+      console.log('🗑️ Imported scene data cleared from CentralPlant');
+    }
+
+    /**
+     * Set a metadata attribute
+     * @param {string} key - The metadata key
+     * @param {any} value - The metadata value
+     */
+  }, {
+    key: "setMetadata",
+    value: function setMetadata(key, value) {
+      this.metadata[key] = value;
+      console.log("\uD83D\uDCDD Metadata set: ".concat(key, " ="), value);
+    }
+
+    /**
+     * Get a metadata attribute
+     * @param {string} key - The metadata key
+     * @returns {any} The metadata value or undefined if not found
+     */
+  }, {
+    key: "getMetadata",
+    value: function getMetadata(key) {
+      return this.metadata[key];
+    }
+
+    /**
+     * Get all metadata
+     * @returns {Object} All metadata attributes
+     */
+  }, {
+    key: "getAllMetadata",
+    value: function getAllMetadata() {
+      return _rollupPluginBabelHelpers.objectSpread2({}, this.metadata);
+    }
+
+    /**
+     * Remove a metadata attribute
+     * @param {string} key - The metadata key to remove
+     */
+  }, {
+    key: "removeMetadata",
+    value: function removeMetadata(key) {
+      delete this.metadata[key];
+      console.log("\uD83D\uDDD1\uFE0F Metadata removed: ".concat(key));
+    }
+
+    /**
+     * Clear all metadata
+     */
+  }, {
+    key: "clearAllMetadata",
+    value: function clearAllMetadata() {
+      this.metadata = {};
+      console.log('🗑️ All metadata cleared from CentralPlant');
+    }
+
+    /**
+     * Clear all data including metadata and transform history
+     */
+  }, {
+    key: "clearAllData",
+    value: function clearAllData() {
+      this.metadata = {};
+      this.transformHistory.lastTransform = null;
+      console.log('🗑️ All data cleared from CentralPlant (metadata + transform history)');
+    }
+
+    /**
+     * Record a transform operation in the history
+     * @param {Object} transformData - The transform data to record
+     * @param {string} transformData.type - The type of transform (e.g., 'translate', 'rotate', 'scale')
+     * @param {Object} transformData.object - The object that was transformed
+     * @param {Object} transformData.values - The transform values applied
+     * @param {Object} transformData.previousValues - The previous transform values (for undo)
+     */
+  }, {
+    key: "recordTransform",
+    value: function recordTransform(transformData) {
+      var _transformData$object, _transformData$object2, _transformRecord$prev;
+      console.log("recordTransform started");
+
+      // Validate the transform data
+      if (!transformData || !transformData.object) {
+        console.error('❌ Invalid transform data provided to recordTransform:', transformData);
+        return;
+      }
+      if (!transformData.previousValues) {
+        console.warn('⚠️ No previous values provided for transform recording - undo may not work properly');
+      }
+      var transformRecord = {
+        type: transformData.type,
+        object: transformData.object,
+        values: transformData.values,
+        previousValues: transformData.previousValues,
+        timestamp: new Date().toISOString(),
+        objectId: ((_transformData$object = transformData.object) === null || _transformData$object === void 0 ? void 0 : _transformData$object.uuid) || ((_transformData$object2 = transformData.object) === null || _transformData$object2 === void 0 ? void 0 : _transformData$object2.id) || 'unknown'
+      };
+      this.transformHistory.lastTransform = transformRecord;
+      console.log('🔄 Transform recorded:', {
+        type: transformRecord.type,
+        objectId: transformRecord.objectId,
+        currentValues: transformRecord.values,
+        previousValues: transformRecord.previousValues,
+        previousValuesStructure: {
+          type: _rollupPluginBabelHelpers["typeof"](transformRecord.previousValues),
+          keys: Object.keys(transformRecord.previousValues || {}),
+          hasPosition: !!(transformRecord.previousValues && transformRecord.previousValues.position),
+          hasRotation: !!(transformRecord.previousValues && transformRecord.previousValues.rotation),
+          hasScale: !!(transformRecord.previousValues && transformRecord.previousValues.scale),
+          positionValues: (_transformRecord$prev = transformRecord.previousValues) !== null && _transformRecord$prev !== void 0 && _transformRecord$prev.position ? {
+            x: transformRecord.previousValues.position.x,
+            y: transformRecord.previousValues.position.y,
+            z: transformRecord.previousValues.position.z
+          } : null
+        },
+        timestamp: transformRecord.timestamp
+      });
+      console.log("recordTransform this.transformHistory:", this.transformHistory);
+    }
+
+    /**
+     * Get the last transform operation
+     * @returns {Object|null} The last transform record or null if none exists
+     */
+  }, {
+    key: "getLastTransform",
+    value: function getLastTransform() {
+      return this.transformHistory.lastTransform;
+    }
+
+    /**
+     * Get the complete transform history
+     * @returns {Object} The transform history object
+     */
+  }, {
+    key: "getTransformHistory",
+    value: function getTransformHistory() {
+      return _rollupPluginBabelHelpers.objectSpread2({}, this.transformHistory);
+    }
+
+    /**
+     * Clear the transform history
+     */
+  }, {
+    key: "clearTransformHistory",
+    value: function clearTransformHistory() {
+      this.transformHistory.lastTransform = null;
+      console.log('🗑️ Transform history cleared');
+    }
+
+    /**
+     * Check if a metadata key exists
+     * @param {string} key - The metadata key to check
+     * @returns {boolean} True if the key exists
+     */
+  }, {
+    key: "hasMetadata",
+    value: function hasMetadata(key) {
+      return key in this.metadata;
+    }
+
+    /**
+     * Set default metadata for the CentralPlant scene
+     */
+  }, {
+    key: "setDefaultSceneMetadata",
+    value: function setDefaultSceneMetadata() {
+      var _this2 = this;
+      var defaultMetadata = {
+        // Scene Information
+        sceneInfo: {
+          name: 'Untitled Central Plant Scene',
+          description: 'A central plant facility scene',
+          version: '1.0.0',
+          created: new Date().toISOString(),
+          lastModified: new Date().toISOString(),
+          author: 'Engineering Team'
+        },
+        // Project Settings
+        projectSettings: {
+          units: 'metric',
+          // or 'imperial'
+          scale: 1.0,
+          gridSize: 1.0,
+          snapToGrid: true,
+          showGrid: true,
+          showAxes: true
+        },
+        // Viewport Settings
+        viewportSettings: {
+          defaultViewMode: 'perspective',
+          backgroundType: 'skybox',
+          showEnvironment: true,
+          autoRotate: false,
+          cameraPosition: {
+            x: 10,
+            y: 10,
+            z: 10
+          },
+          cameraTarget: {
+            x: 0,
+            y: 0,
+            z: 0
+          }
+        },
+        // Component Settings
+        componentSettings: {
+          defaultComponentScale: 1.0,
+          showBoundingBoxes: false,
+          showConnectionPaths: true,
+          highlightOnHover: true,
+          selectionOutlineColor: '#00ff00'
+        },
+        // Spatial Boundaries
+        spatialBoundaries: {
+          min: {
+            x: -60,
+            y: -16,
+            z: -60
+          },
+          max: {
+            x: 60,
+            y: 16,
+            z: 60
+          },
+          center: {
+            x: 0,
+            y: 4,
+            z: 0
+          }
+        },
+        // System Information
+        systemInfo: {
+          centralPlantVersion: '2.0.0',
+          buildDate: new Date().toISOString(),
+          platform: typeof window !== 'undefined' ? window.navigator.platform : 'Unknown',
+          userAgent: typeof window !== 'undefined' ? window.navigator.userAgent : 'Unknown'
+        }
+      };
+
+      // Set each default metadata category
+      Object.keys(defaultMetadata).forEach(function (category) {
+        if (!_this2.hasMetadata(category)) {
+          _this2.setMetadata(category, defaultMetadata[category]);
+        }
+      });
+      console.log('🎯 Default scene metadata initialized:', Object.keys(defaultMetadata));
+    }
+
+    /**
+     * Set default metadata for imported scene data
+     * @param {Object} sceneData - The imported scene data
+     */
+  }, {
+    key: "setDefaultImportedSceneMetadata",
+    value: function setDefaultImportedSceneMetadata(sceneData) {
+      var _sceneData$connection, _sceneData$scene, _sceneData$scene2;
+      var importTimestamp = new Date().toISOString();
+
+      // Extract information from the imported scene data
+      var connectionsCount = ((_sceneData$connection = sceneData.connections) === null || _sceneData$connection === void 0 ? void 0 : _sceneData$connection.length) || 0;
+      var componentsCount = ((_sceneData$scene = sceneData.scene) === null || _sceneData$scene === void 0 || (_sceneData$scene = _sceneData$scene.object) === null || _sceneData$scene === void 0 || (_sceneData$scene = _sceneData$scene.children) === null || _sceneData$scene === void 0 ? void 0 : _sceneData$scene.length) || 0;
+
+      // Count different types of components
+      var componentTypes = {};
+      if ((_sceneData$scene2 = sceneData.scene) !== null && _sceneData$scene2 !== void 0 && (_sceneData$scene2 = _sceneData$scene2.object) !== null && _sceneData$scene2 !== void 0 && _sceneData$scene2.children) {
+        sceneData.scene.object.children.forEach(function (child) {
+          var _child$userData;
+          var componentType = ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.componentType) || 'unknown';
+          componentTypes[componentType] = (componentTypes[componentType] || 0) + 1;
+        });
+      }
+      var importMetadata = {
+        // Import Information
+        importInfo: {
+          importTimestamp: importTimestamp,
+          originalFileName: null,
+          // Will be set from the calling context
+          fileSize: null,
+          // Will be set from the calling context
+          importMethod: 'file-upload',
+          importVersion: '1.0.0'
+        },
+        // Scene Analysis
+        sceneAnalysis: {
+          totalComponents: componentsCount,
+          totalConnections: connectionsCount,
+          componentTypes: componentTypes,
+          sceneComplexity: this.calculateSceneComplexity(connectionsCount, componentsCount),
+          hasValidStructure: this.validateImportedSceneStructure(sceneData)
+        },
+        // Data Quality
+        dataQuality: {
+          hasConnections: connectionsCount > 0,
+          hasComponents: componentsCount > 0,
+          hasValidScene: !!sceneData.scene,
+          missingData: this.identifyMissingData(sceneData),
+          warnings: this.generateImportWarnings(sceneData)
+        },
+        // Processing Stats
+        processingStats: {
+          processedAt: importTimestamp,
+          processingDuration: null,
+          // Can be updated after processing
+          memoryUsage: this.estimateMemoryUsage(sceneData),
+          cacheStatus: 'pending'
+        }
+      };
+
+      // Store import-specific metadata
+      this.setMetadata('lastImport', importMetadata);
+
+      // Update scene info if it exists
+      if (this.hasMetadata('sceneInfo')) {
+        var existingSceneInfo = this.getMetadata('sceneInfo');
+        this.setMetadata('sceneInfo', _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, existingSceneInfo), {}, {
+          lastModified: importTimestamp,
+          importSource: 'file-import',
+          dataSourceType: 'json'
+        }));
+      }
+      console.log('📥 Default imported scene metadata set:', {
+        components: componentsCount,
+        connections: connectionsCount,
+        complexity: importMetadata.sceneAnalysis.sceneComplexity,
+        types: componentTypes
+      });
+    }
+
+    /**
+     * Calculate scene complexity based on components and connections
+     * @param {number} connectionsCount - Number of connections
+     * @param {number} componentsCount - Number of components
+     * @returns {string} Complexity level (simple, moderate, complex, very-complex)
+     */
+  }, {
+    key: "calculateSceneComplexity",
+    value: function calculateSceneComplexity(connectionsCount, componentsCount) {
+      var totalElements = connectionsCount + componentsCount;
+      if (totalElements <= 10) return 'simple';
+      if (totalElements <= 50) return 'moderate';
+      if (totalElements <= 200) return 'complex';
+      return 'very-complex';
+    }
+
+    /**
+     * Validate the structure of imported scene data
+     * @param {Object} sceneData - The imported scene data
+     * @returns {boolean} True if structure is valid
+     */
+  }, {
+    key: "validateImportedSceneStructure",
+    value: function validateImportedSceneStructure(sceneData) {
+      return !!(sceneData && sceneData.scene && sceneData.scene.object && Array.isArray(sceneData.connections));
+    }
+
+    /**
+     * Identify missing or incomplete data in imported scene
+     * @param {Object} sceneData - The imported scene data
+     * @returns {Array} Array of missing data warnings
+     */
+  }, {
+    key: "identifyMissingData",
+    value: function identifyMissingData(sceneData) {
+      var _sceneData$scene3;
+      var missing = [];
+      if (!sceneData.connections || sceneData.connections.length === 0) {
+        missing.push('No connection data found');
+      }
+      if (!((_sceneData$scene3 = sceneData.scene) !== null && _sceneData$scene3 !== void 0 && (_sceneData$scene3 = _sceneData$scene3.object) !== null && _sceneData$scene3 !== void 0 && _sceneData$scene3.children) || sceneData.scene.object.children.length === 0) {
+        missing.push('No component data found');
+      }
+      if (!sceneData.metadata) {
+        missing.push('No metadata found');
+      }
+      if (!sceneData.version) {
+        missing.push('No version information');
+      }
+      return missing;
+    }
+
+    /**
+     * Generate import warnings for potential issues
+     * @param {Object} sceneData - The imported scene data
+     * @returns {Array} Array of warning messages
+     */
+  }, {
+    key: "generateImportWarnings",
+    value: function generateImportWarnings(sceneData) {
+      var _sceneData$scene4, _sceneData$connection2;
+      var warnings = [];
+
+      // Check for large scene data
+      var componentsCount = ((_sceneData$scene4 = sceneData.scene) === null || _sceneData$scene4 === void 0 || (_sceneData$scene4 = _sceneData$scene4.object) === null || _sceneData$scene4 === void 0 || (_sceneData$scene4 = _sceneData$scene4.children) === null || _sceneData$scene4 === void 0 ? void 0 : _sceneData$scene4.length) || 0;
+      if (componentsCount > 100) {
+        warnings.push("Large scene detected (".concat(componentsCount, " components) - may impact performance"));
+      }
+
+      // Check for orphaned components (components without connections)
+      var connectionsCount = ((_sceneData$connection2 = sceneData.connections) === null || _sceneData$connection2 === void 0 ? void 0 : _sceneData$connection2.length) || 0;
+      if (componentsCount > 0 && connectionsCount === 0) {
+        warnings.push('Components found but no connections - scene may be incomplete');
+      }
+
+      // Check for version compatibility
+      if (sceneData.version && parseFloat(sceneData.version) < 1.0) {
+        warnings.push('Scene data version is older than current - some features may not work correctly');
+      }
+      return warnings;
+    }
+
+    /**
+     * Estimate memory usage of imported scene data
+     * @param {Object} sceneData - The imported scene data
+     * @returns {Object} Memory usage estimate
+     */
+  }, {
+    key: "estimateMemoryUsage",
+    value: function estimateMemoryUsage(sceneData) {
+      var jsonSize = JSON.stringify(sceneData).length;
+      var estimatedMB = (jsonSize / 1024 / 1024).toFixed(2);
+      return {
+        jsonSizeBytes: jsonSize,
+        estimatedMB: parseFloat(estimatedMB),
+        category: estimatedMB < 1 ? 'small' : estimatedMB < 10 ? 'medium' : 'large'
+      };
+    }
+
+    /**
+     * Update specific metadata category
+     * @param {string} category - The metadata category (e.g., 'sceneInfo', 'projectSettings')
+     * @param {Object} updates - The updates to apply to the category
+     */
+  }, {
+    key: "updateMetadataCategory",
+    value: function updateMetadataCategory(category, updates) {
+      if (this.hasMetadata(category)) {
+        var existing = this.getMetadata(category);
+        this.setMetadata(category, _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, existing), updates));
+      } else {
+        this.setMetadata(category, updates);
+      }
+      console.log("\uD83D\uDCDD Metadata category '".concat(category, "' updated:"), updates);
+    }
+
+    /**
+     * Undo the last transform operation
+     * @returns {boolean} True if undo was successful, false otherwise
+     */
+  }, {
+    key: "undoTransform",
+    value: function undoTransform() {
+      var lastTransform = this.getLastTransform();
+      if (!lastTransform) {
+        console.warn('⚠️ No transform to undo');
+        return false;
+      }
+      console.log('🔄 Undoing transform:', lastTransform);
+      try {
+        var _this$sceneViewer;
+        var object = lastTransform.object,
+          type = lastTransform.type,
+          previousValues = lastTransform.previousValues;
+        if (!object || !previousValues) {
+          console.error('❌ Invalid transform data for undo');
+          return false;
+        }
+
+        // Debug current state before undo
+        this.debugTransformState(object, 'Before Undo');
+
+        // Debug the structure of previousValues
+        console.log('🔍 previousValues structure:', {
+          type: _rollupPluginBabelHelpers["typeof"](previousValues),
+          keys: Object.keys(previousValues || {}),
+          values: previousValues,
+          hasPosition: !!(previousValues && previousValues.position),
+          hasRotation: !!(previousValues && previousValues.rotation),
+          hasScale: !!(previousValues && previousValues.scale),
+          hasDirectXYZ: !!(previousValues && (previousValues.x !== undefined || previousValues.y !== undefined || previousValues.z !== undefined))
+        });
+
+        // Verify the object still exists in the scene
+        if (this.sceneViewer && this.sceneViewer.scene) {
+          var objectFound = false;
+          this.sceneViewer.scene.traverse(function (child) {
+            if (child === object) {
+              objectFound = true;
+              console.log("undoTransform object:", object);
+            }
+          });
+          if (!objectFound) {
+            console.error('❌ Object no longer exists in scene, cannot undo');
+            return false;
+          }
+        }
+
+        // Apply the previous values based on transform type
+        switch (type) {
+          case 'translate':
+          case 'position':
+            console.log('🔄 undoTransform - Undoing position transform:', {
+              current: {
+                x: object.position.x,
+                y: object.position.y,
+                z: object.position.z
+              },
+              restoring: previousValues,
+              restoringPosition: previousValues.position
+            });
+
+            // Check if previousValues has position property (Vector3) or direct x,y,z properties
+            if (previousValues.position) {
+              // Handle Vector3 object
+              if (previousValues.position.x !== undefined) object.position.x = previousValues.position.x;
+              if (previousValues.position.y !== undefined) object.position.y = previousValues.position.y;
+              if (previousValues.position.z !== undefined) object.position.z = previousValues.position.z;
+            } else {
+              // Handle direct x,y,z properties
+              if (previousValues.x !== undefined) object.position.x = previousValues.x;
+              if (previousValues.y !== undefined) object.position.y = previousValues.y;
+              if (previousValues.z !== undefined) object.position.z = previousValues.z;
+            }
+            console.log('✅ undoTransform - Position restored to:', {
+              x: object.position.x,
+              y: object.position.y,
+              z: object.position.z
+            });
+            break;
+          case 'rotate':
+          case 'rotation':
+            console.log('🔄 Undoing rotation transform:', {
+              current: {
+                x: object.rotation.x,
+                y: object.rotation.y,
+                z: object.rotation.z
+              },
+              restoring: previousValues,
+              restoringRotation: previousValues.rotation
+            });
+
+            // Check if previousValues has rotation property (Euler) or direct x,y,z properties
+            if (previousValues.rotation) {
+              // Handle Euler object
+              if (previousValues.rotation.x !== undefined) object.rotation.x = previousValues.rotation.x;
+              if (previousValues.rotation.y !== undefined) object.rotation.y = previousValues.rotation.y;
+              if (previousValues.rotation.z !== undefined) object.rotation.z = previousValues.rotation.z;
+            } else {
+              // Handle direct x,y,z properties
+              if (previousValues.x !== undefined) object.rotation.x = previousValues.x;
+              if (previousValues.y !== undefined) object.rotation.y = previousValues.y;
+              if (previousValues.z !== undefined) object.rotation.z = previousValues.z;
+            }
+            console.log('✅ Rotation restored to:', {
+              x: object.rotation.x,
+              y: object.rotation.y,
+              z: object.rotation.z
+            });
+            break;
+          case 'scale':
+            console.log('🔄 Undoing scale transform:', {
+              current: {
+                x: object.scale.x,
+                y: object.scale.y,
+                z: object.scale.z
+              },
+              restoring: previousValues,
+              restoringScale: previousValues.scale
+            });
+
+            // Check if previousValues has scale property (Vector3) or direct x,y,z properties
+            if (previousValues.scale) {
+              // Handle Vector3 object
+              if (previousValues.scale.x !== undefined) object.scale.x = previousValues.scale.x;
+              if (previousValues.scale.y !== undefined) object.scale.y = previousValues.scale.y;
+              if (previousValues.scale.z !== undefined) object.scale.z = previousValues.scale.z;
+            } else {
+              // Handle direct x,y,z properties
+              if (previousValues.x !== undefined) object.scale.x = previousValues.x;
+              if (previousValues.y !== undefined) object.scale.y = previousValues.y;
+              if (previousValues.z !== undefined) object.scale.z = previousValues.z;
+            }
+            console.log('✅ Scale restored to:', {
+              x: object.scale.x,
+              y: object.scale.y,
+              z: object.scale.z
+            });
+            break;
+          default:
+            console.warn("\u26A0\uFE0F Unknown transform type for undo: ".concat(type));
+            return false;
+        }
+
+        // Force update the object's matrix to ensure transforms are properly applied
+        object.updateMatrix();
+        object.updateMatrixWorld(true);
+
+        // Get the transform controls manager reference
+        var transformManager = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.transformManager;
+
+        // Update transform controls if they exist and are attached to this object
+        if (transformManager && transformManager.transformControls) {
+          var transformControls = transformManager.transformControls;
+
+          // Check if the object is currently selected
+          var isCurrentlySelected = transformControls.object === object;
+          if (isCurrentlySelected) {
+            console.log('🔧 Updating transform controls after undo');
+
+            // Temporarily detach to force a clean reattachment
+            transformControls.detach();
+
+            // Ensure the transform controls are properly attached to the scene
+            if (transformManager.ensureSceneAttachment) {
+              transformManager.ensureSceneAttachment(true);
+            }
+
+            // Reattach to the object
+            transformControls.attach(object);
+
+            // Update the transform manager's selected object state
+            transformManager.selectedObject = object;
+
+            // Refresh the bounding box if it exists
+            if (transformManager.updateBoundingBox) {
+              transformManager.updateBoundingBox();
+            }
+
+            // Clear any cached bounding box data for this object
+            if (transformManager.boundingBoxCache && transformManager.boundingBoxCache.has(object)) {
+              transformManager.boundingBoxCache.delete(object);
+            }
+            console.log('✅ Transform controls successfully updated after undo');
+          } else {
+            console.log('🔍 Object not currently selected by transform controls');
+          }
+        }
+
+        // Notify SceneOperationsManager about the transform change
+        if (this.sceneViewer && this.sceneViewer.sceneOperationsManager && this.sceneViewer.currentSceneData) {
+          try {
+            console.log('🔄 Updating scene data after undo');
+            this.sceneViewer.onTransformEnd(object);
+            // this.sceneViewer.sceneOperationsManager.updateSceneDataAfterTransform(object, this.sceneViewer.currentSceneData)
+          } catch (sceneOpsError) {
+            console.warn('⚠️ Error updating scene operations after undo:', sceneOpsError);
+            // Continue with undo operation even if scene operations update fails
+          }
+        }
+
+        // Dispatch scene update events if available
+        if (typeof window !== 'undefined') {
+          var sceneUpdateEvent = new CustomEvent('sceneUpdateComplete', {
+            detail: {
+              timestamp: Date.now(),
+              action: 'undo-transform',
+              objectId: object.uuid || object.id || 'unknown'
+            }
+          });
+          window.dispatchEvent(sceneUpdateEvent);
+          console.log('📡 Scene update event dispatched after undo');
+        }
+
+        // Clear the transform history since we've undone it
+        this.clearTransformHistory();
+
+        // Ensure object is selectable after undo
+        this.ensureObjectSelectable(object);
+
+        // Debug final state after undo
+        this.debugTransformState(object, 'After Undo');
+
+        // Log success
+        console.log('✅ Transform undone successfully', {
+          type: type,
+          objectId: object.uuid || object.id || 'unknown',
+          restoredValues: previousValues,
+          matrixUpdated: true,
+          transformControlsUpdated: !!(this.sceneViewer && this.sceneViewer.transformManager),
+          sceneRerendered: !!(this.sceneViewer && this.sceneViewer.renderer)
+        });
+        return true;
+      } catch (error) {
+        console.error('❌ Error undoing transform:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Ensure object is properly selectable after undo operation
+     * This method addresses issues where transform controls become unresponsive
+     * @param {Object} object - The Three.js object to ensure is selectable
+     * @returns {boolean} True if object selection was refreshed successfully
+     */
+  }, {
+    key: "ensureObjectSelectable",
+    value: function ensureObjectSelectable(object) {
+      if (!object || !this.sceneViewer) {
+        console.warn('⚠️ Cannot ensure object selectable: missing object or scene viewer');
+        return false;
+      }
+      try {
+        var transformManager = this.sceneViewer.transformManager;
+        if (!transformManager) {
+          console.warn('⚠️ Transform manager not available');
+          return false;
+        }
+
+        // Use the recovery method in transform controls manager
+        if (transformManager.recoverTransformControls) {
+          console.log('🔄 Using transform controls recovery method');
+          return transformManager.recoverTransformControls(object);
+        }
+
+        // Fallback to original method if recovery method not available
+        console.log('⚠️ Recovery method not available, using fallback');
+
+        // Force update the object's world matrix
+        object.updateMatrixWorld(true);
+
+        // Clear any cached bounding box data for this object
+        if (transformManager.boundingBoxCache && transformManager.boundingBoxCache.has(object)) {
+          transformManager.boundingBoxCache.delete(object);
+          console.log('🧹 Cleared bounding box cache for object');
+        }
+
+        // Ensure transform controls are properly attached to the scene
+        if (transformManager.ensureSceneAttachment) {
+          transformManager.ensureSceneAttachment(true);
+        }
+
+        // If this object is currently selected, refresh the selection
+        if (transformManager.selectedObject === object) {
+          console.log('🔄 Refreshing object selection after undo');
+
+          // Temporarily deselect
+          transformManager.deselectObject();
+
+          // Wait a frame to ensure state is clean
+          requestAnimationFrame(function () {
+            // Reselect the object
+            transformManager.selectObjectForTransformOnly(object);
+            console.log('✅ Object selection refreshed successfully');
+          });
+        }
+        return true;
+      } catch (error) {
+        console.error('❌ Error ensuring object selectable:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Debug method to log current transform state of an object
+     * @param {Object} object - The Three.js object to debug
+     * @param {string} context - Context string for logging
+     */
+  }, {
+    key: "debugTransformState",
+    value: function debugTransformState(object) {
+      var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Debug';
+      if (!object) {
+        console.log("\uD83D\uDD0D ".concat(context, ": No object provided"));
+        return;
+      }
+      console.log("\uD83D\uDD0D ".concat(context, " - Object Transform State:"), {
+        objectId: object.uuid || object.id || 'unknown',
+        position: {
+          x: object.position.x,
+          y: object.position.y,
+          z: object.position.z
+        },
+        rotation: {
+          x: object.rotation.x,
+          y: object.rotation.y,
+          z: object.rotation.z
+        },
+        scale: {
+          x: object.scale.x,
+          y: object.scale.y,
+          z: object.scale.z
+        },
+        matrixWorldNeedsUpdate: object.matrixWorldNeedsUpdate,
+        visible: object.visible,
+        parent: object.parent ? object.parent.uuid || object.parent.id || 'unknown' : 'none',
+        inScene: this.sceneViewer && this.sceneViewer.scene ? this.isObjectInScene(object) : 'unknown'
+      });
+    }
+
+    /**
+    * Manual fix for when transform controls become unresponsive
+    * Call this method if you can't select objects after undo
+    * @returns {boolean} True if fix was attempted
+    */
+  }, {
+    key: "fixTransformControlsSelection",
+    value: function fixTransformControlsSelection() {
+      if (!this.sceneViewer || !this.sceneViewer.transformManager) {
+        console.warn('⚠️ Cannot fix transform controls: missing scene viewer or transform manager');
+        return false;
+      }
+      var transformManager = this.sceneViewer.transformManager;
+      console.log('🔧 Manually fixing transform controls selection...');
+
+      // Try to recover the transform controls
+      if (transformManager.recoverTransformControls) {
+        var result = transformManager.recoverTransformControls();
+        if (result) {
+          console.log('✅ Transform controls manually fixed');
+          return true;
+        }
+      }
+
+      // Fallback: Force recreate the entire transform controls system
+      try {
+        console.log('🔄 Attempting to recreate transform controls system...');
+
+        // Store current settings
+        var currentMode = transformManager.currentMode;
+        var currentSpace = transformManager.currentSpace;
+
+        // Dispose existing controls
+        if (transformManager.transformControls) {
+          transformManager.transformControls.detach();
+          transformManager.scene.remove(transformManager.transformControls);
+          transformManager.transformControls.dispose();
+          transformManager.transformControls = null;
+        }
+
+        // Recreate controls
+        transformManager.createTransformControls();
+        transformManager.setupEventListeners();
+
+        // Restore settings
+        transformManager.setMode(currentMode);
+        transformManager.setSpace(currentSpace);
+        console.log('✅ Transform controls system recreated successfully');
+        return true;
+      } catch (error) {
+        console.error('❌ Error recreating transform controls:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Check if an object is in the scene
+     * @param {Object} object - The Three.js object to check
+     * @returns {boolean} True if object is in scene
+     */
+  }, {
+    key: "isObjectInScene",
+    value: function isObjectInScene(object) {
+      if (!this.sceneViewer || !this.sceneViewer.scene) return false;
+      var found = false;
+      this.sceneViewer.scene.traverse(function (child) {
+        if (child === object) {
+          found = true;
+        }
+      });
+      return found;
+    }
+  }]);
+}();
+
+exports.CentralPlant = CentralPlant;
+exports["default"] = CentralPlant;