@2112-lab/central-plant 0.1.0 → 0.1.2

package/dist/esm/src/Pathfinder.js

@@ -1,84 +0,0 @@
-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/modelPreloader.js

@@ -1,337 +0,0 @@
-import { createClass as _createClass, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, regeneratorValues as _regeneratorValues, createForOfIteratorHelper as _createForOfIteratorHelper } from '../_virtual/_rollupPluginBabelHelpers.js';
-import 'three';
-
-var ModelPreloader = /*#__PURE__*/function () {
-  function ModelPreloader() {
-    _classCallCheck(this, ModelPreloader);
-    this.modelCache = new Map(); // Cache for loaded GLB models
-    this.loadingPromises = new Map(); // Track ongoing loads to prevent duplicates
-    this.isPreloading = false;
-    this.preloadingPromise = null;
-    this.componentDictionary = null;
-
-    // Load GLTFLoader dynamically if available
-    this.gltfLoader = null;
-    this.initLoader();
-  }
-  return _createClass(ModelPreloader, [{
-    key: "initLoader",
-    value: function () {
-      var _initLoader = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
-        var GLTFLoaderModule, _t;
-        return _regenerator().w(function (_context) {
-          while (1) switch (_context.n) {
-            case 0:
-              _context.p = 0;
-              if (!(typeof window !== 'undefined')) {
-                _context.n = 3;
-                break;
-              }
-              _context.n = 1;
-              return import('three');
-            case 1:
-              _context.v;
-              _context.n = 2;
-              return import('../node_modules/three/examples/jsm/loaders/GLTFLoader.js');
-            case 2:
-              GLTFLoaderModule = _context.v;
-              this.gltfLoader = new GLTFLoaderModule.GLTFLoader();
-            case 3:
-              _context.n = 5;
-              break;
-            case 4:
-              _context.p = 4;
-              _t = _context.v;
-              console.warn('Failed to initialize GLTFLoader:', _t);
-            case 5:
-              return _context.a(2);
-          }
-        }, _callee, this, [[0, 4]]);
-      }));
-      function initLoader() {
-        return _initLoader.apply(this, arguments);
-      }
-      return initLoader;
-    }()
-    /**
-     * Preload all models from the component dictionary
-     * @param {Object} componentDictionary - The component dictionary object
-     * @returns {Promise} Promise that resolves when all models are loaded
-     */
-  }, {
-    key: "preloadAllModels",
-    value: (function () {
-      var _preloadAllModels = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(componentDictionary) {
-        var _this = this;
-        return _regenerator().w(function (_context4) {
-          while (1) switch (_context4.n) {
-            case 0:
-              if (!this.isPreloading) {
-                _context4.n = 1;
-                break;
-              }
-              console.log('⏳ Preloading already in progress, returning existing promise');
-              return _context4.a(2, this.preloadingPromise);
-            case 1:
-              if (componentDictionary) {
-                _context4.n = 2;
-                break;
-              }
-              throw new Error('Component dictionary is required to preload models');
-            case 2:
-              this.isPreloading = true;
-              this.componentDictionary = componentDictionary;
-
-              // Create a promise to track overall preloading
-              this.preloadingPromise = new Promise(/*#__PURE__*/function () {
-                var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(resolve) {
-                  var results, modelKeysSet, loadPromises, _iterator, _step, _loop, _t2, _t3;
-                  return _regenerator().w(function (_context3) {
-                    while (1) switch (_context3.n) {
-                      case 0:
-                        _context3.p = 0;
-                        console.log("\uD83D\uDE80 Starting preload of models from dictionary with ".concat(Object.keys(componentDictionary).length, " components"));
-                        results = {
-                          total: 0,
-                          success: 0,
-                          failed: 0,
-                          skipped: 0,
-                          modelKeys: []
-                        }; // Extract all unique model keys from the dictionary
-                        modelKeysSet = new Set();
-                        Object.values(componentDictionary).forEach(function (component) {
-                          if (component.modelKey) {
-                            modelKeysSet.add(component.modelKey);
-                          }
-                        });
-                        results.total = modelKeysSet.size;
-                        results.modelKeys = Array.from(modelKeysSet);
-
-                        // Load basic models first
-                        console.log("\uD83D\uDCE6 Found ".concat(results.total, " unique model keys to preload"));
-
-                        // Return early if no models to load
-                        if (!(results.total === 0)) {
-                          _context3.n = 1;
-                          break;
-                        }
-                        _this.isPreloading = false;
-                        resolve(results);
-                        return _context3.a(2);
-                      case 1:
-                        // Process each model key
-                        loadPromises = [];
-                        _iterator = _createForOfIteratorHelper(results.modelKeys);
-                        _context3.p = 2;
-                        _loop = /*#__PURE__*/_regenerator().m(function _loop() {
-                          var modelKey, modelUrl;
-                          return _regenerator().w(function (_context2) {
-                            while (1) switch (_context2.n) {
-                              case 0:
-                                modelKey = _step.value;
-                                modelUrl = _this.getModelUrlFromKey(modelKey);
-                                if (modelUrl) {
-                                  loadPromises.push(_this.preloadModel(modelKey, modelUrl).then(function () {
-                                    results.success++;
-                                  }).catch(function (error) {
-                                    console.error("\u274C Failed to preload model ".concat(modelKey, ":"), error);
-                                    results.failed++;
-                                  }));
-                                } else {
-                                  console.warn("\u26A0\uFE0F No URL found for model key: ".concat(modelKey));
-                                  results.skipped++;
-                                }
-                              case 1:
-                                return _context2.a(2);
-                            }
-                          }, _loop);
-                        });
-                        _iterator.s();
-                      case 3:
-                        if ((_step = _iterator.n()).done) {
-                          _context3.n = 5;
-                          break;
-                        }
-                        return _context3.d(_regeneratorValues(_loop()), 4);
-                      case 4:
-                        _context3.n = 3;
-                        break;
-                      case 5:
-                        _context3.n = 7;
-                        break;
-                      case 6:
-                        _context3.p = 6;
-                        _t2 = _context3.v;
-                        _iterator.e(_t2);
-                      case 7:
-                        _context3.p = 7;
-                        _iterator.f();
-                        return _context3.f(7);
-                      case 8:
-                        _context3.n = 9;
-                        return Promise.allSettled(loadPromises);
-                      case 9:
-                        console.log('✅ Model preloading completed with results:', results);
-                        _this.isPreloading = false;
-                        resolve(results);
-                        _context3.n = 11;
-                        break;
-                      case 10:
-                        _context3.p = 10;
-                        _t3 = _context3.v;
-                        console.error('❌ Error during model preloading:', _t3);
-                        _this.isPreloading = false;
-                        resolve({
-                          total: 0,
-                          success: 0,
-                          failed: 1,
-                          skipped: 0,
-                          error: _t3.message
-                        });
-                      case 11:
-                        return _context3.a(2);
-                    }
-                  }, _callee2, null, [[2, 6, 7, 8], [0, 10]]);
-                }));
-                return function (_x2) {
-                  return _ref.apply(this, arguments);
-                };
-              }());
-              return _context4.a(2, this.preloadingPromise);
-          }
-        }, _callee3, this);
-      }));
-      function preloadAllModels(_x) {
-        return _preloadAllModels.apply(this, arguments);
-      }
-      return preloadAllModels;
-    }()
-    /**
-     * Convert a model key to a URL
-     * @param {string} modelKey - The model key from the dictionary
-     * @returns {string} The URL for the model
-     */
-    )
-  }, {
-    key: "getModelUrlFromKey",
-    value: function getModelUrlFromKey(modelKey) {
-      // The modelKey already includes the .glb extension from the component dictionary
-      return modelKey;
-    }
-
-    /**
-     * Preload a specific model
-     * @param {string} modelKey - The model key
-     * @param {string} modelUrl - The URL to the model
-     * @returns {Promise} Promise that resolves with the loaded model
-     */
-  }, {
-    key: "preloadModel",
-    value: (function () {
-      var _preloadModel = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(modelKey, modelUrl) {
-        var _this2 = this;
-        var loadPromise;
-        return _regenerator().w(function (_context5) {
-          while (1) switch (_context5.n) {
-            case 0:
-              if (this.gltfLoader) {
-                _context5.n = 2;
-                break;
-              }
-              _context5.n = 1;
-              return this.initLoader();
-            case 1:
-              if (this.gltfLoader) {
-                _context5.n = 2;
-                break;
-              }
-              throw new Error('GLTFLoader is not available');
-            case 2:
-              if (!this.modelCache.has(modelKey)) {
-                _context5.n = 3;
-                break;
-              }
-              return _context5.a(2, this.modelCache.get(modelKey));
-            case 3:
-              if (!this.loadingPromises.has(modelKey)) {
-                _context5.n = 4;
-                break;
-              }
-              return _context5.a(2, this.loadingPromises.get(modelKey));
-            case 4:
-              // Start loading the model
-              loadPromise = new Promise(function (resolve, reject) {
-                _this2.gltfLoader.load(modelUrl, function (gltf) {
-                  console.log("\u2705 Successfully loaded model: ".concat(modelKey, " from ").concat(modelUrl));
-                  _this2.modelCache.set(modelKey, gltf);
-                  _this2.loadingPromises.delete(modelKey);
-                  resolve(gltf);
-                }, function (progress) {
-                  // Optional progress callback
-                  if (progress.lengthComputable) {
-                    progress.loaded / progress.total * 100;
-                    // console.log(`📥 Loading ${modelKey}: ${percentComplete.toFixed(1)}%`);
-                  }
-                }, function (error) {
-                  console.error("\u274C Failed to load model ".concat(modelKey, " from ").concat(modelUrl, ":"), error);
-
-                  // Add more detailed error information
-                  if (error.message && error.message.includes('404')) {
-                    console.error("   File not found. Check if the model exists at: ".concat(modelUrl));
-                  } else if (error.message && error.message.includes('JSON')) {
-                    console.error("   Invalid GLB file format. The file may be corrupted or is not a valid GLB/GLTF file.");
-                  }
-                  _this2.loadingPromises.delete(modelKey);
-                  reject(error);
-                });
-              }); // Store the loading promise
-              this.loadingPromises.set(modelKey, loadPromise);
-              return _context5.a(2, loadPromise);
-          }
-        }, _callee4, this);
-      }));
-      function preloadModel(_x3, _x4) {
-        return _preloadModel.apply(this, arguments);
-      }
-      return preloadModel;
-    }()
-    /**
-     * Get a model from the cache
-     * @param {string} modelKey - The model key
-     * @returns {Object|null} The loaded model or null if not found
-     */
-    )
-  }, {
-    key: "getModel",
-    value: function getModel(modelKey) {
-      return this.modelCache.get(modelKey) || null;
-    }
-
-    /**
-     * Clear the model cache
-     */
-  }, {
-    key: "clearCache",
-    value: function clearCache() {
-      this.modelCache.clear();
-    }
-
-    /**
-     * Get statistics about the model cache
-     * @returns {Object} Cache statistics
-     */
-  }, {
-    key: "getCacheStats",
-    value: function getCacheStats() {
-      return {
-        cacheSize: this.modelCache.size,
-        cachedModels: Array.from(this.modelCache.keys()),
-        loading: Array.from(this.loadingPromises.keys()),
-        isPreloading: this.isPreloading
-      };
-    }
-  }]);
-}(); // Create singleton instance
-var modelPreloader = new ModelPreloader();
-
-export { ModelPreloader, modelPreloader as default };