@2112-lab/central-plant 0.1.6 → 0.1.7

package/dist/bundle/index.js

@@ -21807,6 +21807,801 @@ var SceneHelper = /*#__PURE__*/function () {
   }]);
 }();
 
+var SceneViewer = /*#__PURE__*/function () {
+  /**
+   * Initialize the SceneViewer
+   * @param {HTMLElement} container - DOM element to render the scene
+   * @param {Object} options - Configuration options
+   * @param {Object} centralPlant - CentralPlant instance for managers
+   */
+  function SceneViewer(container) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var centralPlant = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    _classCallCheck(this, SceneViewer);
+    // Core properties
+    this.container = container;
+    this.centralPlant = centralPlant;
+    this.options = _objectSpread2({
+      enableAutoRotation: false,
+      enableShadows: true,
+      enableBloom: true,
+      enableSSAO: false,
+      antialias: true,
+      pixelRatio: Math.min(window.devicePixelRatio, 2)
+    }, options);
+
+    // Instance tracking for hot-reload handling
+    this.instanceId = Date.now() + Math.random();
+
+    // Core Three.js objects
+    this.scene = null;
+    this.camera = null;
+    this.renderer = null;
+    this.controls = null;
+    this.composer = null;
+    this.bloomPass = null;
+    this.ssaoPass = null;
+
+    // Utilities
+    this.textureLoader = null;
+    this.gltfLoader = null;
+    this.envMap = null;
+    this.performanceMonitor = null;
+    this.resizeObserver = null;
+
+    // Scene data
+    this.currentSceneData = null;
+
+    // State flags
+    this.isDestroyed = false;
+    this.isInitialized = false;
+
+    // Transform controls
+    this.transformManager = null;
+    this.selectedObjectForTransform = null;
+    this.transformMode = 'translate';
+    this.transformSpace = 'world';
+    this.transformHistory = [];
+    this.previousTransformValues = null;
+
+    // Manager instances (will be attached from centralPlant)
+    this.managers = {};
+
+    // Event system for communication with external systems
+    this.eventCallbacks = new Map();
+
+    // Drag and drop state
+    this.isDragOver = false;
+    this.dragDropManager = null;
+
+    // Scene helper utility
+    this.sceneHelper = null;
+
+    // Pathfinder version cache
+    this.pathfinderVersionInfo = null;
+
+    // Transform settings
+    this.shouldUpdatePaths = true;
+
+    // Initialize the scene viewer
+    this.init();
+  }
+
+  /**
+   * Initialize the Three.js scene and all components
+   */
+  return _createClass(SceneViewer, [{
+    key: "init",
+    value: (function () {
+      var _init = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var _t;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              _context.p = 0;
+              console.log('🚀 Initializing SceneViewer...', {
+                instanceId: this.instanceId,
+                containerSize: {
+                  width: this.container.clientWidth,
+                  height: this.container.clientHeight
+                }
+              });
+
+              // Attach managers from centralPlant if available
+              if (this.centralPlant) {
+                this.attachManagers();
+              }
+
+              // Initialize Three.js components
+              this.initScene();
+              this.initCamera();
+              this.initRenderer();
+              this.initLights();
+              this.initControls();
+              this.initPostProcessing();
+              this.initEventListeners();
+
+              // Initialize managers that require scene to be ready
+              _context.n = 1;
+              return this.initializeSceneManagers();
+            case 1:
+              // Start the animation loop
+              this.animate();
+              this.isInitialized = true;
+              this.emit('initialized', {
+                sceneViewer: this
+              });
+              console.log('✅ SceneViewer initialization completed');
+              _context.n = 3;
+              break;
+            case 2:
+              _context.p = 2;
+              _t = _context.v;
+              console.error('❌ Error initializing SceneViewer:', _t);
+              this.emit('error', {
+                error: _t,
+                phase: 'initialization'
+              });
+            case 3:
+              return _context.a(2);
+          }
+        }, _callee, this, [[0, 2]]);
+      }));
+      function init() {
+        return _init.apply(this, arguments);
+      }
+      return init;
+    }()
+    /**
+     * Attach managers from centralPlant
+     */
+    )
+  }, {
+    key: "attachManagers",
+    value: function attachManagers() {
+      var _this = this;
+      if (!this.centralPlant) return;
+
+      // Get all managers from centralPlant
+      var managers = this.centralPlant.getAllManagers();
+
+      // Attach each manager to this instance
+      Object.entries(managers).forEach(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+          key = _ref2[0],
+          manager = _ref2[1];
+        _this[key] = manager;
+        _this.managers[key] = manager;
+      });
+
+      // Also attach utilities
+      var utilities = this.centralPlant.getAllUtilities();
+      Object.entries(utilities).forEach(function (_ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+          key = _ref4[0],
+          utility = _ref4[1];
+        _this[key] = utility;
+      });
+      console.log('📦 Managers attached to SceneViewer:', Object.keys(managers));
+    }
+
+    /**
+     * Initialize Three.js scene
+     */
+  }, {
+    key: "initScene",
+    value: function initScene() {
+      this.scene = new THREE__namespace.Scene();
+      this.scene.name = 'MainScene';
+
+      // Set background
+      this.scene.background = new THREE__namespace.Color(0x87CEEB); // Sky blue
+
+      console.log('🌍 Scene initialized');
+    }
+
+    /**
+     * Initialize camera
+     */
+  }, {
+    key: "initCamera",
+    value: function initCamera() {
+      var aspect = this.container.clientWidth / this.container.clientHeight;
+      this.camera = new THREE__namespace.PerspectiveCamera(75, aspect, 0.1, 1000);
+      this.camera.position.set(5, 5, 5);
+      this.camera.lookAt(0, 0, 0);
+      console.log('📷 Camera initialized');
+    }
+
+    /**
+     * Initialize renderer
+     */
+  }, {
+    key: "initRenderer",
+    value: function initRenderer() {
+      this.renderer = new THREE__namespace.WebGLRenderer({
+        antialias: this.options.antialias,
+        powerPreference: 'high-performance'
+      });
+      this.renderer.setSize(this.container.clientWidth, this.container.clientHeight);
+      this.renderer.setPixelRatio(this.options.pixelRatio);
+      this.renderer.shadowMap.enabled = this.options.enableShadows;
+      this.renderer.shadowMap.type = THREE__namespace.PCFSoftShadowMap;
+      this.renderer.outputColorSpace = THREE__namespace.SRGBColorSpace;
+      this.renderer.toneMapping = THREE__namespace.ACESFilmicToneMapping;
+      this.renderer.toneMappingExposure = 1;
+
+      // Append renderer to container
+      this.container.appendChild(this.renderer.domElement);
+      console.log('🎨 Renderer initialized');
+    }
+
+    /**
+     * Initialize lighting
+     */
+  }, {
+    key: "initLights",
+    value: function initLights() {
+      // Ambient light
+      var ambientLight = new THREE__namespace.AmbientLight(0x404040, 0.4);
+      this.scene.add(ambientLight);
+
+      // Directional light
+      var directionalLight = new THREE__namespace.DirectionalLight(0xffffff, 1);
+      directionalLight.position.set(10, 10, 5);
+      directionalLight.castShadow = this.options.enableShadows;
+      if (this.options.enableShadows) {
+        directionalLight.shadow.mapSize.width = 2048;
+        directionalLight.shadow.mapSize.height = 2048;
+        directionalLight.shadow.camera.near = 0.5;
+        directionalLight.shadow.camera.far = 500;
+      }
+      this.scene.add(directionalLight);
+      console.log('💡 Lights initialized');
+    }
+
+    /**
+     * Initialize controls (if available)
+     */
+  }, {
+    key: "initControls",
+    value: function initControls() {
+      // Controls will be initialized by the camera controls manager
+      // This is just a placeholder for the base setup
+      console.log('🎮 Controls setup ready');
+    }
+
+    /**
+     * Initialize post-processing effects
+     */
+  }, {
+    key: "initPostProcessing",
+    value: function initPostProcessing() {
+      // Post-processing will be handled by managers
+      // This is just a placeholder
+      console.log('✨ Post-processing setup ready');
+    }
+
+    /**
+     * Initialize event listeners
+     */
+  }, {
+    key: "initEventListeners",
+    value: function initEventListeners() {
+      var _this2 = this;
+      // Resize observer
+      this.resizeObserver = new ResizeObserver(function (entries) {
+        var _iterator = _createForOfIteratorHelper(entries),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var entry = _step.value;
+            _this2.handleResize();
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      });
+      this.resizeObserver.observe(this.container);
+
+      // Mouse events for selection
+      this.container.addEventListener('click', this.handleClick.bind(this));
+      this.container.addEventListener('dblclick', this.handleDoubleClick.bind(this));
+
+      // Drag and drop events
+      this.container.addEventListener('dragover', this.handleDragOver.bind(this));
+      this.container.addEventListener('drop', this.handleDrop.bind(this));
+      this.container.addEventListener('dragenter', this.handleDragEnter.bind(this));
+      this.container.addEventListener('dragleave', this.handleDragLeave.bind(this));
+      console.log('👂 Event listeners initialized');
+    }
+
+    /**
+     * Initialize scene managers that require the scene to be ready
+     */
+  }, {
+    key: "initializeSceneManagers",
+    value: (function () {
+      var _initializeSceneManagers = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        var _t2;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              _context2.p = 0;
+              if (!this.sceneInitializationManager) {
+                _context2.n = 1;
+                break;
+              }
+              _context2.n = 1;
+              return this.sceneInitializationManager.initializeScene();
+            case 1:
+              if (!this.environmentManager) {
+                _context2.n = 2;
+                break;
+              }
+              _context2.n = 2;
+              return this.environmentManager.initializeEnvironment();
+            case 2:
+              // Initialize other managers as needed
+              console.log('🏗️ Scene managers initialized');
+              _context2.n = 4;
+              break;
+            case 3:
+              _context2.p = 3;
+              _t2 = _context2.v;
+              console.error('❌ Error initializing scene managers:', _t2);
+            case 4:
+              return _context2.a(2);
+          }
+        }, _callee2, this, [[0, 3]]);
+      }));
+      function initializeSceneManagers() {
+        return _initializeSceneManagers.apply(this, arguments);
+      }
+      return initializeSceneManagers;
+    }()
+    /**
+     * Main animation loop
+     */
+    )
+  }, {
+    key: "animate",
+    value: function animate() {
+      var _this3 = this;
+      if (this.isDestroyed) return;
+      requestAnimationFrame(function () {
+        return _this3.animate();
+      });
+      try {
+        // Update controls
+        if (this.controls && this.controls.update) {
+          this.controls.update();
+        }
+
+        // Update camera controls manager
+        if (this.cameraControlsManager) {
+          this.cameraControlsManager.update();
+        }
+
+        // Update animation manager
+        if (this.animationManager) {
+          this.animationManager.update();
+        }
+
+        // Update performance monitor
+        if (this.performanceMonitor) {
+          this.performanceMonitor.begin();
+        }
+
+        // Render the scene
+        if (this.composer) {
+          this.composer.render();
+        } else {
+          this.renderer.render(this.scene, this.camera);
+        }
+
+        // End performance monitoring
+        if (this.performanceMonitor) {
+          this.performanceMonitor.end();
+        }
+      } catch (error) {
+        console.error('❌ Error in animation loop:', error);
+      }
+    }
+
+    /**
+     * Handle window/container resize
+     */
+  }, {
+    key: "handleResize",
+    value: function handleResize() {
+      if (!this.camera || !this.renderer) return;
+      var width = this.container.clientWidth;
+      var height = this.container.clientHeight;
+
+      // Update camera
+      this.camera.aspect = width / height;
+      this.camera.updateProjectionMatrix();
+
+      // Update renderer
+      this.renderer.setSize(width, height);
+
+      // Update composer if available
+      if (this.composer) {
+        this.composer.setSize(width, height);
+      }
+      this.emit('resize', {
+        width: width,
+        height: height
+      });
+    }
+
+    /**
+     * Handle click events
+     */
+  }, {
+    key: "handleClick",
+    value: function handleClick(event) {
+      if (!this.camera || !this.scene) return;
+      var rect = this.container.getBoundingClientRect();
+      var mouse = new THREE__namespace.Vector2();
+      mouse.x = (event.clientX - rect.left) / rect.width * 2 - 1;
+      mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+      var raycaster = new THREE__namespace.Raycaster();
+      raycaster.setFromCamera(mouse, this.camera);
+      var intersects = raycaster.intersectObjects(this.scene.children, true);
+      if (intersects.length > 0) {
+        var object = intersects[0].object;
+        this.selectObject(object);
+      } else {
+        this.selectObject(null);
+      }
+    }
+
+    /**
+     * Handle double click events
+     */
+  }, {
+    key: "handleDoubleClick",
+    value: function handleDoubleClick(event) {
+      // Handle double click actions
+      this.emit('doubleClick', {
+        event: event
+      });
+    }
+
+    /**
+     * Handle drag over events
+     */
+  }, {
+    key: "handleDragOver",
+    value: function handleDragOver(event) {
+      event.preventDefault();
+      this.isDragOver = true;
+      this.emit('dragOver', {
+        event: event
+      });
+    }
+
+    /**
+     * Handle drop events
+     */
+  }, {
+    key: "handleDrop",
+    value: function handleDrop(event) {
+      event.preventDefault();
+      this.isDragOver = false;
+      try {
+        var dataTransfer = event.dataTransfer.getData('text/plain');
+        if (dataTransfer) {
+          var componentData = JSON.parse(dataTransfer);
+
+          // Calculate drop position
+          var rect = this.container.getBoundingClientRect();
+          var mouse = new THREE__namespace.Vector2();
+          mouse.x = (event.clientX - rect.left) / rect.width * 2 - 1;
+          mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+          var raycaster = new THREE__namespace.Raycaster();
+          raycaster.setFromCamera(mouse, this.camera);
+
+          // Cast ray to ground plane (y = 0)
+          var groundPlane = new THREE__namespace.Plane(new THREE__namespace.Vector3(0, 1, 0), 0);
+          var dropPosition = new THREE__namespace.Vector3();
+          raycaster.ray.intersectPlane(groundPlane, dropPosition);
+          this.emit('componentDropped', {
+            componentData: componentData,
+            position: dropPosition,
+            event: event
+          });
+        }
+      } catch (error) {
+        console.error('❌ Error handling drop:', error);
+        this.emit('dropError', {
+          error: error,
+          event: event
+        });
+      }
+    }
+
+    /**
+     * Handle drag enter events
+     */
+  }, {
+    key: "handleDragEnter",
+    value: function handleDragEnter(event) {
+      event.preventDefault();
+      this.emit('dragEnter', {
+        event: event
+      });
+    }
+
+    /**
+     * Handle drag leave events
+     */
+  }, {
+    key: "handleDragLeave",
+    value: function handleDragLeave(event) {
+      this.isDragOver = false;
+      this.emit('dragLeave', {
+        event: event
+      });
+    }
+
+    /**
+     * Select an object in the scene
+     */
+  }, {
+    key: "selectObject",
+    value: function selectObject(object) {
+      // Clear previous selection
+      if (this.selectedObjectForTransform) {
+        // Remove selection indicators
+        this.clearObjectSelection(this.selectedObjectForTransform);
+      }
+      this.selectedObjectForTransform = object;
+      if (object) {
+        // Add selection indicators
+        this.highlightSelectedObject(object);
+
+        // Initialize transform controls if available
+        if (this.transformManager) {
+          this.transformManager.attachToObject(object);
+        }
+      } else {
+        // Clear transform controls
+        if (this.transformManager) {
+          this.transformManager.detach();
+        }
+      }
+      this.emit('objectSelected', {
+        object: object
+      });
+    }
+
+    /**
+     * Clear object selection visual indicators
+     */
+  }, {
+    key: "clearObjectSelection",
+    value: function clearObjectSelection(object) {
+      // Remove selection outline or other indicators
+      // This would depend on your specific selection visualization
+    }
+
+    /**
+     * Highlight selected object
+     */
+  }, {
+    key: "highlightSelectedObject",
+    value: function highlightSelectedObject(object) {
+      // Add selection outline or other indicators
+      // This would depend on your specific selection visualization
+    }
+
+    /**
+     * Load a scene from data
+     */
+  }, {
+    key: "loadScene",
+    value: (function () {
+      var _loadScene = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(sceneData) {
+        var _t3;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              _context3.p = 0;
+              this.currentSceneData = sceneData;
+              if (!this.componentManager) {
+                _context3.n = 1;
+                break;
+              }
+              _context3.n = 1;
+              return this.componentManager.loadSceneFromData(sceneData);
+            case 1:
+              this.emit('sceneLoaded', {
+                sceneData: sceneData
+              });
+              _context3.n = 3;
+              break;
+            case 2:
+              _context3.p = 2;
+              _t3 = _context3.v;
+              console.error('❌ Error loading scene:', _t3);
+              this.emit('sceneLoadError', {
+                error: _t3,
+                sceneData: sceneData
+              });
+            case 3:
+              return _context3.a(2);
+          }
+        }, _callee3, this, [[0, 2]]);
+      }));
+      function loadScene(_x) {
+        return _loadScene.apply(this, arguments);
+      }
+      return loadScene;
+    }()
+    /**
+     * Add a component to the scene
+     */
+    )
+  }, {
+    key: "addComponentToScene",
+    value: function addComponentToScene(componentData) {
+      var position = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE__namespace.Vector3();
+      try {
+        if (this.componentManager) {
+          return this.componentManager.addComponent(componentData, position);
+        }
+        return false;
+      } catch (error) {
+        console.error('❌ Error adding component:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Export scene data
+     */
+  }, {
+    key: "exportScene",
+    value: function exportScene() {
+      try {
+        if (this.sceneExportManager) {
+          return this.sceneExportManager.exportScene();
+        }
+        return null;
+      } catch (error) {
+        console.error('❌ Error exporting scene:', error);
+        return null;
+      }
+    }
+
+    /**
+     * Toggle camera auto rotation
+     */
+  }, {
+    key: "toggleCameraRotation",
+    value: function toggleCameraRotation() {
+      if (this.cameraControlsManager) {
+        return this.cameraControlsManager.toggleCameraRotation();
+      }
+      return false;
+    }
+
+    /**
+     * Get selected transform data
+     */
+  }, {
+    key: "getSelectedTransform",
+    value: function getSelectedTransform() {
+      if (this.transformManager && this.selectedObjectForTransform) {
+        return this.transformManager.getTransformData(this.selectedObjectForTransform);
+      }
+      return null;
+    }
+
+    /**
+     * Event system methods
+     */
+  }, {
+    key: "on",
+    value: function on(eventName, callback) {
+      if (!this.eventCallbacks.has(eventName)) {
+        this.eventCallbacks.set(eventName, []);
+      }
+      this.eventCallbacks.get(eventName).push(callback);
+    }
+  }, {
+    key: "off",
+    value: function off(eventName, callback) {
+      if (this.eventCallbacks.has(eventName)) {
+        var callbacks = this.eventCallbacks.get(eventName);
+        var index = callbacks.indexOf(callback);
+        if (index > -1) {
+          callbacks.splice(index, 1);
+        }
+      }
+    }
+  }, {
+    key: "emit",
+    value: function emit(eventName) {
+      var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (this.eventCallbacks.has(eventName)) {
+        this.eventCallbacks.get(eventName).forEach(function (callback) {
+          try {
+            callback(data);
+          } catch (error) {
+            console.error("\u274C Error in event callback for ".concat(eventName, ":"), error);
+          }
+        });
+      }
+    }
+
+    /**
+     * Dispose of the scene viewer and clean up resources
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      console.log('🧹 Disposing SceneViewer...');
+      this.isDestroyed = true;
+      try {
+        // Clean up event listeners
+        this.eventCallbacks.clear();
+
+        // Clean up resize observer
+        if (this.resizeObserver) {
+          this.resizeObserver.disconnect();
+          this.resizeObserver = null;
+        }
+
+        // Clean up DOM event listeners
+        if (this.container) {
+          this.container.removeEventListener('click', this.handleClick);
+          this.container.removeEventListener('dblclick', this.handleDoubleClick);
+          this.container.removeEventListener('dragover', this.handleDragOver);
+          this.container.removeEventListener('drop', this.handleDrop);
+          this.container.removeEventListener('dragenter', this.handleDragEnter);
+          this.container.removeEventListener('dragleave', this.handleDragLeave);
+        }
+
+        // Dispose of managers using disposal manager
+        if (this.disposalManager) {
+          this.disposalManager.cleanupEventListeners();
+          this.disposalManager.cleanupPerformanceMonitoring();
+          this.disposalManager.cleanupControls();
+          this.disposalManager.cleanupScene();
+          this.disposalManager.cleanupRenderer();
+        }
+
+        // Remove renderer from DOM
+        if (this.renderer && this.renderer.domElement && this.container) {
+          this.container.removeChild(this.renderer.domElement);
+        }
+
+        // Dispose of renderer
+        if (this.renderer) {
+          this.renderer.dispose();
+          this.renderer = null;
+        }
+
+        // Clear references
+        this.scene = null;
+        this.camera = null;
+        this.controls = null;
+        this.currentSceneData = null;
+        this.selectedObjectForTransform = null;
+        console.log('✅ SceneViewer disposed successfully');
+      } catch (error) {
+        console.error('❌ Error during SceneViewer disposal:', error);
+      }
+    }
+  }]);
+}();
+
 /**
  * CentralPlant class that manages all scene utility instances
  */
@@ -22927,6 +23722,36 @@ var CentralPlant = /*#__PURE__*/function () {
       });
       return found;
     }
+
+    /**
+     * Get the SceneViewer class for creating new instances
+     * @returns {Function} The SceneViewer class constructor
+     */
+  }, {
+    key: "getSceneViewerClass",
+    value: function getSceneViewerClass() {
+      return SceneViewer;
+    }
+
+    /**
+     * Get all managers for external access
+     * @returns {Object} All manager instances
+     */
+  }, {
+    key: "getAllManagers",
+    value: function getAllManagers() {
+      return _objectSpread2({}, this.managers);
+    }
+
+    /**
+     * Get all utilities for external access
+     * @returns {Object} All utility instances
+     */
+  }, {
+    key: "getAllUtilities",
+    value: function getAllUtilities() {
+      return _objectSpread2({}, this.utilities);
+    }
   }]);
 }();
 
@@ -30444,29 +31269,41 @@ var Export = /*#__PURE__*/function () {
                 includeCustomExtensions: false
               }, options);
               _t = format.toLowerCase();
-              _context.n = _t === 'gltf' ? 2 : _t === 'glb' ? 2 : _t === 'obj' ? 4 : _t === 'stl' ? 6 : 8;
+              _context.n = _t === 'gltf' ? 2 : _t === 'glb' ? 2 : _t === 'obj' ? 4 : _t === 'stl' ? 6 : _t === 'ply' ? 8 : _t === 'dae' ? 10 : 12;
               break;
             case 2:
               _context.n = 3;
               return this.exportGLTF(object, exportOptions);
             case 3:
               result = _context.v;
-              return _context.a(3, 9);
+              return _context.a(3, 13);
             case 4:
               _context.n = 5;
               return this.exportOBJ(object, exportOptions);
             case 5:
               result = _context.v;
-              return _context.a(3, 9);
+              return _context.a(3, 13);
             case 6:
               _context.n = 7;
               return this.exportSTL(object, exportOptions);
             case 7:
               result = _context.v;
-              return _context.a(3, 9);
+              return _context.a(3, 13);
             case 8:
-              throw new Error("Unsupported format: ".concat(format));
+              _context.n = 9;
+              return this.exportPLY(object, exportOptions);
             case 9:
+              result = _context.v;
+              return _context.a(3, 13);
+            case 10:
+              _context.n = 11;
+              return this.exportCollada(object, exportOptions);
+            case 11:
+              result = _context.v;
+              return _context.a(3, 13);
+            case 12:
+              throw new Error("Unsupported format: ".concat(format));
+            case 13:
               exportTime = performance.now() - startTime;
               exportRecord = {
                 timestamp: new Date().toISOString(),
@@ -30484,8 +31321,8 @@ var Export = /*#__PURE__*/function () {
                 exportTime: exportTime,
                 filename: this.generateFilename(object.name || 'model', format)
               });
-            case 10:
-              _context.p = 10;
+            case 14:
+              _context.p = 14;
               _t2 = _context.v;
               _exportTime = performance.now() - startTime;
               _exportRecord = {
@@ -30500,10 +31337,10 @@ var Export = /*#__PURE__*/function () {
               this.exportHistory.push(_exportRecord);
               logger.error("\u274C Failed to export model to ".concat(format.toUpperCase(), ":"), _t2);
               throw _t2;
-            case 11:
+            case 15:
               return _context.a(2);
           }
-        }, _callee, this, [[1, 10]]);
+        }, _callee, this, [[1, 14]]);
       }));
       function exportModel(_x, _x2) {
         return _exportModel.apply(this, arguments);
@@ -30628,6 +31465,36 @@ var Export = /*#__PURE__*/function () {
       }
       return exportPLY;
     }()
+    /**
+     * Export to Collada (DAE) format
+     * @param {THREE.Object3D} object - Object to export
+     * @param {Object} options - Export options
+     * @returns {Promise<string>} Collada XML string
+     */
+    )
+  }, {
+    key: "exportCollada",
+    value: (function () {
+      var _exportCollada = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(object) {
+        var _this5 = this;
+        var options,
+          _args6 = arguments;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              options = _args6.length > 1 && _args6[1] !== undefined ? _args6[1] : {};
+              return _context6.a(2, new Promise(function (resolve) {
+                var result = _this5.exporters.collada.parse(object, options);
+                resolve(result.data);
+              }));
+          }
+        }, _callee6);
+      }));
+      function exportCollada(_x7) {
+        return _exportCollada.apply(this, arguments);
+      }
+      return exportCollada;
+    }()
     /**
      * Export scene configuration to JSON
      * @param {THREE.Scene} scene - Scene to export
@@ -30670,7 +31537,7 @@ var Export = /*#__PURE__*/function () {
   }, {
     key: "serializeObject",
     value: function serializeObject(object) {
-      var _this5 = this;
+      var _this6 = this;
       var serialized = {
         uuid: object.uuid,
         name: object.name,
@@ -30701,7 +31568,7 @@ var Export = /*#__PURE__*/function () {
 
       // Recursively serialize children
       object.children.forEach(function (child) {
-        serialized.children.push(_this5.serializeObject(child));
+        serialized.children.push(_this6.serializeObject(child));
       });
       return serialized;
     }
@@ -30874,7 +31741,7 @@ var Export = /*#__PURE__*/function () {
   }, {
     key: "exportToXML",
     value: function exportToXML(data) {
-      var _this6 = this;
+      var _this7 = this;
       var rootElement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'root';
       var xmlHeader = '<?xml version="1.0" encoding="UTF-8"?>\n';
       var _objectToXML = function objectToXML(obj) {
@@ -30893,12 +31760,12 @@ var Export = /*#__PURE__*/function () {
               if (_typeof(item) === 'object') {
                 xml += '\n' + _objectToXML(item, indent + 1) + spaces;
               } else {
-                xml += _this6.escapeXML(item);
+                xml += _this7.escapeXML(item);
               }
               xml += "</".concat(key, ">\n");
             });
           } else {
-            xml += "".concat(spaces, "<").concat(key, ">").concat(_this6.escapeXML(value), "</").concat(key, ">\n");
+            xml += "".concat(spaces, "<").concat(key, ">").concat(_this7.escapeXML(value), "</").concat(key, ">\n");
           }
         });
         return xml;
@@ -30950,63 +31817,63 @@ var Export = /*#__PURE__*/function () {
   }, {
     key: "exportBatch",
     value: (function () {
-      var _exportBatch = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(objects) {
+      var _exportBatch = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(objects) {
         var results, errors, _iterator, _step, item, result, _t3, _t4;
-        return _regenerator().w(function (_context6) {
-          while (1) switch (_context6.n) {
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
             case 0:
               logger.info("\uD83D\uDD04 Starting batch export of ".concat(objects.length, " objects..."));
               results = [];
               errors = [];
               _iterator = _createForOfIteratorHelper(objects);
-              _context6.p = 1;
+              _context7.p = 1;
               _iterator.s();
             case 2:
               if ((_step = _iterator.n()).done) {
-                _context6.n = 7;
+                _context7.n = 7;
                 break;
               }
               item = _step.value;
-              _context6.p = 3;
-              _context6.n = 4;
+              _context7.p = 3;
+              _context7.n = 4;
               return this.exportModel(item.object, item.format, item.options);
             case 4:
-              result = _context6.v;
+              result = _context7.v;
               results.push(result);
-              _context6.n = 6;
+              _context7.n = 6;
               break;
             case 5:
-              _context6.p = 5;
-              _t3 = _context6.v;
+              _context7.p = 5;
+              _t3 = _context7.v;
               errors.push({
                 object: item.object.name || 'Unnamed Object',
                 format: item.format,
                 error: _t3.message
               });
             case 6:
-              _context6.n = 2;
+              _context7.n = 2;
               break;
             case 7:
-              _context6.n = 9;
+              _context7.n = 9;
               break;
             case 8:
-              _context6.p = 8;
-              _t4 = _context6.v;
+              _context7.p = 8;
+              _t4 = _context7.v;
               _iterator.e(_t4);
             case 9:
-              _context6.p = 9;
+              _context7.p = 9;
               _iterator.f();
-              return _context6.f(9);
+              return _context7.f(9);
             case 10:
               logger.info("\u2705 Batch export complete: ".concat(results.length, " successful, ").concat(errors.length, " failed"));
-              return _context6.a(2, {
+              return _context7.a(2, {
                 results: results,
                 errors: errors
               });
           }
-        }, _callee6, this, [[3, 5], [1, 8, 9, 10]]);
+        }, _callee7, this, [[3, 5], [1, 8, 9, 10]]);
       }));
-      function exportBatch(_x7) {
+      function exportBatch(_x8) {
         return _exportBatch.apply(this, arguments);
       }
       return exportBatch;
@@ -33133,6 +34000,7 @@ exports.SceneExportManager = SceneExportManager;
 exports.SceneInitializationManager = SceneInitializationManager;
 exports.SceneOperationsManager = SceneOperationsManager;
 exports.SceneTooltipsManager = SceneTooltipsManager;
+exports.SceneViewer = SceneViewer;
 exports.Testing = testing;
 exports.createTransformControls = createTransformControls;
 exports.findObjectByHardcodedUuid = findObjectByHardcodedUuid;