@2112-lab/central-plant 0.1.0

package/dist/cjs/src/Pathfinder.js

@@ -0,0 +1,88 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
+var ConnectionManager = require('./ConnectionManager.js');
+
+/**
+ * Pathfinder class
+ * Enhanced version with better error handling for missing data
+ */
+var Pathfinder = /*#__PURE__*/function () {
+  function Pathfinder(sceneData) {
+    _rollupPluginBabelHelpers.classCallCheck(this, Pathfinder);
+    this.sceneData = sceneData || {};
+    this.connectionManager = new ConnectionManager["default"]();
+  }
+
+  /**
+   * Find paths in the scene
+   * @returns {Array} Array of paths
+   */
+  return _rollupPluginBabelHelpers.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, _rollupPluginBabelHelpers.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);
+    }
+  }]);
+}();
+
+exports["default"] = Pathfinder;

package/dist/cjs/src/animationManager.js

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var debugLogger = require('./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);
+  debugLogger.logger.info('Animation loop started');
+}
+
+/**
+ * Stop the animation loop
+ */
+function stopAnimation() {
+  if (!isAnimating) return;
+  if (animationFrameId !== null) {
+    cancelAnimationFrame(animationFrameId);
+    animationFrameId = null;
+  }
+  isAnimating = false;
+  debugLogger.logger.info('Animation loop stopped');
+}
+
+/**
+ * Register an animation callback
+ */
+function addAnimationCallback(callback) {
+  if (typeof callback !== 'function') {
+    debugLogger.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) {
+      debugLogger.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
+};
+
+exports.addAnimationCallback = addAnimationCallback;
+exports["default"] = animationManager;
+exports.isAnimationRunning = isAnimationRunning;
+exports.removeAnimationCallback = removeAnimationCallback;
+exports.startAnimation = startAnimation;
+exports.stopAnimation = stopAnimation;

package/dist/cjs/src/componentManager.js

@@ -0,0 +1,151 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
+var THREE = require('three');
+var debugLogger = require('./debugLogger.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
+
+/**
+ * Load a component from data
+ */
+function loadComponent(_x) {
+  return _loadComponent.apply(this, arguments);
+}
+
+/**
+ * Place a component in the scene
+ */
+function _loadComponent() {
+  _loadComponent = _rollupPluginBabelHelpers.asyncToGenerator(/*#__PURE__*/_rollupPluginBabelHelpers.regenerator().m(function _callee(componentData) {
+    var component;
+    return _rollupPluginBabelHelpers.regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          debugLogger.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__namespace.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) {
+    debugLogger.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) {
+    debugLogger.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);
+    debugLogger.logger.info("Component removed: ".concat(componentId));
+    return true;
+  } else {
+    debugLogger.logger.warn("Component not found: ".concat(componentId));
+    return false;
+  }
+}
+
+/**
+ * Get a component by ID
+ */
+function getComponentById(id, scene) {
+  if (!scene) {
+    debugLogger.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
+};
+
+exports["default"] = componentManager;
+exports.getComponentById = getComponentById;
+exports.loadComponent = loadComponent;
+exports.placeComponent = placeComponent;
+exports.removeComponent = removeComponent;

package/dist/cjs/src/debugLogger.js

@@ -0,0 +1,176 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_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';
+    _rollupPluginBabelHelpers.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 _rollupPluginBabelHelpers.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, _rollupPluginBabelHelpers.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, _rollupPluginBabelHelpers.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, _rollupPluginBabelHelpers.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, _rollupPluginBabelHelpers.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, _rollupPluginBabelHelpers.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');
+
+exports.DebugLogger = DebugLogger;
+exports.logger = logger;
+exports.materialLogger = materialLogger;
+exports.modelLogger = modelLogger;
+exports.pathfinderLogger = pathfinderLogger;
+exports.transformLogger = transformLogger;