@2112-lab/central-plant 0.1.0

package/dist/esm/src/Pathfinder.js

@@ -0,0 +1,84 @@
+import { createClass as _createClass, toConsumableArray as _toConsumableArray, classCallCheck as _classCallCheck } from '../_virtual/_rollupPluginBabelHelpers.js';
+import ConnectionManager from './ConnectionManager.js';
+
+/**
+ * Pathfinder class
+ * Enhanced version with better error handling for missing data
+ */
+var Pathfinder = /*#__PURE__*/function () {
+  function Pathfinder(sceneData) {
+    _classCallCheck(this, Pathfinder);
+    this.sceneData = sceneData || {};
+    this.connectionManager = new ConnectionManager();
+  }
+
+  /**
+   * Find paths in the scene
+   * @returns {Array} Array of paths
+   */
+  return _createClass(Pathfinder, [{
+    key: "findPaths",
+    value: function findPaths() {
+      var _this = this;
+      console.log('[DEBUG] Starting findPaths()');
+      try {
+        var connections = this.sceneData.connections;
+
+        // Safety check for connections
+        if (!connections || !Array.isArray(connections)) {
+          console.warn('Pathfinder: No valid connections provided in scene data');
+          return [];
+        }
+
+        // Create clusters from connections
+        var clusters = this.connectionManager.clusterConnections(connections);
+
+        // Return empty array if there are no valid clusters
+        if (!clusters || !clusters.length) {
+          console.log('Pathfinder: No valid connection clusters generated');
+          return [];
+        }
+
+        // Process the clusters and generate paths
+        // (Simplified implementation, the actual process would be more complex)
+        var paths = [];
+        clusters.forEach(function (cluster) {
+          if (cluster && cluster.objects && Array.isArray(cluster.objects)) {
+            // Generate path for this cluster
+            var clusterPaths = _this._generatePathsForCluster(cluster);
+            paths.push.apply(paths, _toConsumableArray(clusterPaths));
+          }
+        });
+        return paths;
+      } catch (error) {
+        console.error('Pathfinder: Error finding paths:', error);
+        return [];
+      }
+    }
+
+    /**
+     * Generate paths for a single cluster
+     * @param {Object} cluster - The cluster to generate paths for
+     * @returns {Array} Array of paths for this cluster
+     * @private
+     */
+  }, {
+    key: "_generatePathsForCluster",
+    value: function _generatePathsForCluster(cluster) {
+      // This is a placeholder implementation
+      // In your actual system, this would use your existing pathfinding logic
+      return cluster.objects.map(function (obj, index, arr) {
+        if (index < arr.length - 1) {
+          return {
+            from: obj,
+            to: arr[index + 1],
+            path: [] // This would normally contain 3D points for the path
+          };
+        }
+        return null;
+      }).filter(Boolean);
+    }
+  }]);
+}();
+
+export { Pathfinder as default };

package/dist/esm/src/animationManager.js

@@ -0,0 +1,112 @@
+import { logger } from './debugLogger.js';
+
+/**
+ * Animation Manager
+ * Handles animation loops and timing
+ */
+var animationFrameId = null;
+var isAnimating = false;
+var lastTime = 0;
+var callbacks = [];
+
+/**
+ * Start the animation loop
+ */
+function startAnimation(component) {
+  if (isAnimating) return;
+  isAnimating = true;
+  lastTime = performance.now();
+  var _animate = function animate(time) {
+    if (!isAnimating) return;
+
+    // Calculate delta time
+    var deltaTime = (time - lastTime) / 1000; // in seconds
+    lastTime = time;
+
+    // Execute animation callbacks
+    executeCallbacks(time, deltaTime);
+
+    // Render if component exists
+    if (component && component.renderer && component.scene && component.camera) {
+      component.renderer.render(component.scene, component.camera);
+    }
+
+    // Update orbit controls if they exist
+    if (component && component.controls && component.controls.update) {
+      component.controls.update();
+    }
+
+    // Continue animation loop
+    animationFrameId = requestAnimationFrame(_animate);
+  };
+
+  // Start animation loop
+  animationFrameId = requestAnimationFrame(_animate);
+  logger.info('Animation loop started');
+}
+
+/**
+ * Stop the animation loop
+ */
+function stopAnimation() {
+  if (!isAnimating) return;
+  if (animationFrameId !== null) {
+    cancelAnimationFrame(animationFrameId);
+    animationFrameId = null;
+  }
+  isAnimating = false;
+  logger.info('Animation loop stopped');
+}
+
+/**
+ * Register an animation callback
+ */
+function addAnimationCallback(callback) {
+  if (typeof callback !== 'function') {
+    logger.warn('Invalid animation callback');
+    return;
+  }
+  callbacks.push(callback);
+  return callback;
+}
+
+/**
+ * Remove an animation callback
+ */
+function removeAnimationCallback(callback) {
+  var index = callbacks.indexOf(callback);
+  if (index !== -1) {
+    callbacks.splice(index, 1);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Execute all registered animation callbacks
+ */
+function executeCallbacks(time, deltaTime) {
+  callbacks.forEach(function (callback) {
+    try {
+      callback(time, deltaTime);
+    } catch (error) {
+      logger.error('Error in animation callback:', error);
+    }
+  });
+}
+
+/**
+ * Check if animation is running
+ */
+function isAnimationRunning() {
+  return isAnimating;
+}
+var animationManager = {
+  startAnimation: startAnimation,
+  stopAnimation: stopAnimation,
+  addAnimationCallback: addAnimationCallback,
+  removeAnimationCallback: removeAnimationCallback,
+  isAnimationRunning: isAnimationRunning
+};
+
+export { addAnimationCallback, animationManager as default, isAnimationRunning, removeAnimationCallback, startAnimation, stopAnimation };

package/dist/esm/src/componentManager.js

@@ -0,0 +1,123 @@
+import { asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import { logger } from './debugLogger.js';
+
+/**
+ * Load a component from data
+ */
+function loadComponent(_x) {
+  return _loadComponent.apply(this, arguments);
+}
+
+/**
+ * Place a component in the scene
+ */
+function _loadComponent() {
+  _loadComponent = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(componentData) {
+    var component;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          logger.info("Loading component: ".concat(componentData.id || 'Unknown'));
+
+          // This is a stub implementation that will need to be expanded
+          component = {
+            id: componentData.id || 'unknown-component',
+            type: componentData.type || 'generic',
+            data: componentData,
+            object: new THREE.Group(),
+            position: componentData.position || {
+              x: 0,
+              y: 0,
+              z: 0
+            },
+            rotation: componentData.rotation || {
+              x: 0,
+              y: 0,
+              z: 0
+            },
+            scale: componentData.scale || {
+              x: 1,
+              y: 1,
+              z: 1
+            }
+          };
+          return _context.a(2, component);
+      }
+    }, _callee);
+  }));
+  return _loadComponent.apply(this, arguments);
+}
+function placeComponent(component, position, rotation, scene) {
+  if (!component || !component.object) {
+    logger.error('Cannot place component: invalid component object');
+    return null;
+  }
+
+  // Set position
+  if (position) {
+    component.object.position.set(position.x || 0, position.y || 0, position.z || 0);
+  }
+
+  // Set rotation
+  if (rotation) {
+    component.object.rotation.set(rotation.x || 0, rotation.y || 0, rotation.z || 0);
+  }
+
+  // Add to scene if provided
+  if (scene && scene.add) {
+    scene.add(component.object);
+  }
+  return component;
+}
+
+/**
+ * Remove a component from the scene
+ */
+function removeComponent(componentId, scene) {
+  if (!scene) {
+    logger.error('Cannot remove component: scene not provided');
+    return false;
+  }
+
+  // Find the component by ID
+  var componentObject = null;
+  scene.traverse(function (object) {
+    if (object.userData && object.userData.id === componentId) {
+      componentObject = object;
+    }
+  });
+  if (componentObject && componentObject.parent) {
+    componentObject.parent.remove(componentObject);
+    logger.info("Component removed: ".concat(componentId));
+    return true;
+  } else {
+    logger.warn("Component not found: ".concat(componentId));
+    return false;
+  }
+}
+
+/**
+ * Get a component by ID
+ */
+function getComponentById(id, scene) {
+  if (!scene) {
+    logger.error('Cannot get component: scene not provided');
+    return null;
+  }
+  var component = null;
+  scene.traverse(function (object) {
+    if (object.userData && object.userData.id === id) {
+      component = object;
+    }
+  });
+  return component;
+}
+var componentManager = {
+  loadComponent: loadComponent,
+  placeComponent: placeComponent,
+  removeComponent: removeComponent,
+  getComponentById: getComponentById
+};
+
+export { componentManager as default, getComponentById, loadComponent, placeComponent, removeComponent };

package/dist/esm/src/debugLogger.js

@@ -0,0 +1,167 @@
+import { createClass as _createClass, toConsumableArray as _toConsumableArray, classCallCheck as _classCallCheck } from '../_virtual/_rollupPluginBabelHelpers.js';
+
+// Debug logging utility to reduce excessive console statements
+// Provides conditional logging based on environment and debug levels
+
+var DebugLogger = /*#__PURE__*/function () {
+  function DebugLogger() {
+    var namespace = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'SceneViewer';
+    var debugLevel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'info';
+    _classCallCheck(this, DebugLogger);
+    this.namespace = namespace;
+    this.debugLevel = debugLevel;
+    this.isProduction = typeof process !== 'undefined' && process.env.NODE_ENV === 'production';
+    this.enabled = !this.isProduction;
+
+    // Debug levels: 'error', 'warn', 'info', 'debug', 'verbose'
+    this.levels = {
+      error: 0,
+      warn: 1,
+      info: 2,
+      debug: 3,
+      verbose: 4
+    };
+    this.currentLevel = this.levels[debugLevel] || this.levels.info;
+  }
+  return _createClass(DebugLogger, [{
+    key: "setLevel",
+    value: function setLevel(level) {
+      this.currentLevel = this.levels[level] || this.levels.info;
+      return this;
+    }
+  }, {
+    key: "enable",
+    value: function enable() {
+      this.enabled = true;
+      return this;
+    }
+  }, {
+    key: "disable",
+    value: function disable() {
+      this.enabled = false;
+      return this;
+    }
+  }, {
+    key: "_shouldLog",
+    value: function _shouldLog(level) {
+      return this.enabled && this.levels[level] <= this.currentLevel;
+    }
+  }, {
+    key: "_formatMessage",
+    value: function _formatMessage(level, message) {
+      var prefix = "[".concat(this.namespace, ":").concat(level.toUpperCase(), "]");
+      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        args[_key - 2] = arguments[_key];
+      }
+      return [prefix, message].concat(args);
+    }
+  }, {
+    key: "error",
+    value: function error(message) {
+      if (this._shouldLog('error')) {
+        var _console;
+        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          args[_key2 - 1] = arguments[_key2];
+        }
+        (_console = console).error.apply(_console, _toConsumableArray(this._formatMessage.apply(this, ['error', message].concat(args))));
+      }
+    }
+  }, {
+    key: "warn",
+    value: function warn(message) {
+      if (this._shouldLog('warn')) {
+        var _console2;
+        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+          args[_key3 - 1] = arguments[_key3];
+        }
+        (_console2 = console).warn.apply(_console2, _toConsumableArray(this._formatMessage.apply(this, ['warn', message].concat(args))));
+      }
+    }
+  }, {
+    key: "info",
+    value: function info(message) {
+      if (this._shouldLog('info')) {
+        var _console3;
+        for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+          args[_key4 - 1] = arguments[_key4];
+        }
+        (_console3 = console).log.apply(_console3, _toConsumableArray(this._formatMessage.apply(this, ['info', message].concat(args))));
+      }
+    }
+  }, {
+    key: "debug",
+    value: function debug(message) {
+      if (this._shouldLog('debug')) {
+        var _console4;
+        for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+          args[_key5 - 1] = arguments[_key5];
+        }
+        (_console4 = console).debug.apply(_console4, _toConsumableArray(this._formatMessage.apply(this, ['debug', message].concat(args))));
+      }
+    }
+  }, {
+    key: "verbose",
+    value: function verbose(message) {
+      if (this._shouldLog('verbose')) {
+        var _console5;
+        for (var _len6 = arguments.length, args = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {
+          args[_key6 - 1] = arguments[_key6];
+        }
+        (_console5 = console).debug.apply(_console5, _toConsumableArray(this._formatMessage.apply(this, ['verbose', message].concat(args))));
+      }
+    }
+
+    // Special methods for common patterns
+  }, {
+    key: "phase",
+    value: function phase(phaseNumber, message) {
+      for (var _len7 = arguments.length, args = new Array(_len7 > 2 ? _len7 - 2 : 0), _key7 = 2; _key7 < _len7; _key7++) {
+        args[_key7 - 2] = arguments[_key7];
+      }
+      this.info.apply(this, ["\uD83D\uDD0D PHASE ".concat(phaseNumber, ": ").concat(message)].concat(args));
+    }
+  }, {
+    key: "success",
+    value: function success(message) {
+      for (var _len8 = arguments.length, args = new Array(_len8 > 1 ? _len8 - 1 : 0), _key8 = 1; _key8 < _len8; _key8++) {
+        args[_key8 - 1] = arguments[_key8];
+      }
+      this.info.apply(this, ["\u2705 ".concat(message)].concat(args));
+    }
+  }, {
+    key: "failure",
+    value: function failure(message) {
+      for (var _len9 = arguments.length, args = new Array(_len9 > 1 ? _len9 - 1 : 0), _key9 = 1; _key9 < _len9; _key9++) {
+        args[_key9 - 1] = arguments[_key9];
+      }
+      this.error.apply(this, ["\u274C ".concat(message)].concat(args));
+    }
+  }, {
+    key: "loading",
+    value: function loading(message) {
+      for (var _len0 = arguments.length, args = new Array(_len0 > 1 ? _len0 - 1 : 0), _key0 = 1; _key0 < _len0; _key0++) {
+        args[_key0 - 1] = arguments[_key0];
+      }
+      this.debug.apply(this, ["\uD83D\uDD04 ".concat(message)].concat(args));
+    }
+  }, {
+    key: "timing",
+    value: function timing(message) {
+      for (var _len1 = arguments.length, args = new Array(_len1 > 1 ? _len1 - 1 : 0), _key1 = 1; _key1 < _len1; _key1++) {
+        args[_key1 - 1] = arguments[_key1];
+      }
+      this.debug.apply(this, ["\u23F1\uFE0F ".concat(message)].concat(args));
+    }
+  }]);
+}();
+
+// Create default logger instance
+var logger = new DebugLogger('SceneViewer', 'info');
+
+// Create specialized loggers for different subsystems
+var transformLogger = new DebugLogger('Transform', 'warn');
+var pathfinderLogger = new DebugLogger('Pathfinder', 'info');
+var modelLogger = new DebugLogger('Models', 'info');
+var materialLogger = new DebugLogger('Materials', 'warn');
+
+export { DebugLogger, logger, materialLogger, modelLogger, pathfinderLogger, transformLogger };

package/dist/esm/src/disposalManager.js

@@ -0,0 +1,155 @@
+import { toConsumableArray as _toConsumableArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import { logger } from './debugLogger.js';
+
+/**
+ * Dispose a Three.js object including geometry, material, and textures
+ */
+function disposeObject(object) {
+  if (!object) return;
+
+  // Dispose geometry
+  if (object.geometry) {
+    object.geometry.dispose();
+  }
+
+  // Dispose material(s)
+  if (object.material) {
+    if (Array.isArray(object.material)) {
+      object.material.forEach(function (material) {
+        return disposeMaterial(material);
+      });
+    } else {
+      disposeMaterial(object.material);
+    }
+  }
+
+  // Dispose any children
+  if (object.children && object.children.length > 0) {
+    // Work with a copy of the children array to avoid issues during iteration
+    var children = _toConsumableArray(object.children);
+    children.forEach(function (child) {
+      return disposeObject(child);
+    });
+  }
+}
+
+/**
+ * Dispose a Three.js material and its textures
+ */
+function disposeMaterial(material) {
+  if (!material) return;
+
+  // Dispose textures
+  Object.keys(material).forEach(function (key) {
+    var value = material[key];
+    if (value && value instanceof THREE.Texture) {
+      value.dispose();
+    }
+  });
+
+  // Dispose the material itself
+  material.dispose();
+}
+
+/**
+ * Clean up a Three.js scene
+ */
+function cleanupScene(scene) {
+  if (!scene) {
+    logger.warn('Cannot cleanup: scene not provided');
+    return;
+  }
+
+  // Dispose all objects in the scene
+  while (scene.children.length > 0) {
+    var object = scene.children[0];
+    scene.remove(object);
+    disposeObject(object);
+  }
+  logger.info('Scene cleared and disposed');
+}
+
+/**
+ * Clean up a Three.js renderer
+ */
+function cleanupRenderer(renderer) {
+  if (!renderer) {
+    logger.warn('Cannot cleanup: renderer not provided');
+    return;
+  }
+  renderer.dispose();
+
+  // Remove from DOM if possible
+  var canvas = renderer.domElement;
+  if (canvas && canvas.parentNode) {
+    canvas.parentNode.removeChild(canvas);
+  }
+  logger.info('Renderer disposed');
+}
+
+/**
+ * Clean up Nuxt-specific event listeners
+ */
+function cleanupNuxtEventListeners() {
+  if (typeof window === 'undefined' || !window.$nuxt) {
+    return;
+  }
+
+  // Clean up any registered event listeners
+  if (window.$nuxt.$off) {
+    // This is a simple placeholder - actual implementation would need to track
+    // specific listeners that were registered
+    logger.info('Nuxt event listeners cleaned up');
+  }
+}
+
+/**
+ * Comprehensive cleanup of Three.js resources
+ */
+function cleanupThreeJsResources(component) {
+  if (!component) return;
+
+  // Stop animation if it's running
+  if (component.stopAnimation) {
+    component.stopAnimation();
+  }
+
+  // Clean up controls
+  if (component.controls) {
+    if (component.controls.dispose) {
+      component.controls.dispose();
+    }
+    component.controls = null;
+  }
+
+  // Clean up scene
+  if (component.scene) {
+    cleanupScene(component.scene);
+    component.scene = null;
+  }
+
+  // Clean up renderer
+  if (component.renderer) {
+    cleanupRenderer(component.renderer);
+    component.renderer = null;
+  }
+
+  // Clean up camera
+  component.camera = null;
+
+  // Cleanup other resources
+  component.textureLoader = null;
+  component.gltfLoader = null;
+  logger.info('All Three.js resources cleaned up');
+}
+var disposalManager = {
+  disposeObject: disposeObject,
+  disposeMaterial: disposeMaterial,
+  cleanupScene: cleanupScene,
+  cleanupRenderer: cleanupRenderer,
+  cleanupNuxtEventListeners: cleanupNuxtEventListeners,
+  cleanupThreeJsResources: cleanupThreeJsResources
+};
+
+export { cleanupNuxtEventListeners, cleanupRenderer, cleanupScene, cleanupThreeJsResources, disposalManager as default, disposeMaterial, disposeObject };