@2112-lab/central-plant 0.1.0

package/dist/esm/src/modelPreloader.js

@@ -0,0 +1,337 @@
+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 };

package/dist/esm/src/nameUtils.js

@@ -0,0 +1,99 @@
+/**
+ * Name Utilities
+ * Common helper functions for name and UUID generation
+ */
+
+/**
+ * Generate UUID from name using consistent transformation rules
+ * @param {string} name - The name to convert to UUID
+ * @returns {string} The generated UUID
+ */
+function generateUuidFromName(name) {
+  if (!name) return null;
+
+  // Convert name to uppercase and replace spaces with hyphens
+  var uuid = name.toUpperCase().replace(/\s+COMPONENT$/i, '') // Remove "Component" suffix
+  .replace(/\s+/g, '-') // Replace spaces with hyphens
+  .replace(/[^A-Z0-9\-]/g, ''); // Remove special characters except hyphens
+
+  // Clean up any duplicate "COMPONENT" text that might have been left behind
+  uuid = uuid.replace(/-COMPONENT$/, '');
+  return uuid;
+}
+
+/**
+ * Check if two names would generate the same UUID
+ * @param {string} name1 - First name
+ * @param {string} name2 - Second name
+ * @returns {boolean} Whether the names generate the same UUID
+ */
+function namesGenerateSameUuid(name1, name2) {
+  var uuid1 = generateUuidFromName(name1);
+  var uuid2 = generateUuidFromName(name2);
+  return uuid1 && uuid2 && uuid1 === uuid2;
+}
+
+/**
+ * Find an object in a Three.js scene by hardcoded UUID with fallback strategies
+ * @param {THREE.Scene} scene - The Three.js scene to search
+ * @param {string} targetUuid - The UUID to search for
+ * @returns {THREE.Object3D|null} The found object or null
+ */
+function findObjectByHardcodedUuid(scene, targetUuid) {
+  if (!scene || !targetUuid) return null;
+  var foundObject = null;
+  scene.traverse(function (child) {
+    var _child$userData;
+    if (foundObject) return; // Stop if already found
+
+    // Strategy 1: Direct UUID match (HIGHEST PRIORITY)
+    if (child.uuid === targetUuid) {
+      foundObject = child;
+      return;
+    }
+
+    // Strategy 2: Original hardcoded UUID match
+    if (((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.originalUuid) === targetUuid) {
+      foundObject = child;
+      return;
+    }
+
+    // Strategy 3: Name-based UUID match (FALLBACK)
+    if (child.name) {
+      var generatedUuid = generateUuidFromName(child.name);
+      if (generatedUuid === targetUuid) {
+        foundObject = child;
+        return;
+      }
+    }
+  });
+  return foundObject;
+}
+
+/**
+ * Get the hardcoded UUID for an object, prioritizing original over current
+ * @param {THREE.Object3D} object - The Three.js object
+ * @returns {string|null} The hardcoded UUID or null
+ */
+function getHardcodedUuid(object) {
+  var _object$userData;
+  if (!object) return null;
+
+  // Priority 1: Original hardcoded UUID stored in userData
+  if ((_object$userData = object.userData) !== null && _object$userData !== void 0 && _object$userData.originalUuid) {
+    return object.userData.originalUuid;
+  }
+
+  // Priority 2: Current UUID (if it looks like a hardcoded one)
+  if (object.uuid && !object.uuid.includes('-') && object.uuid.length > 10) {
+    return object.uuid;
+  }
+
+  // Priority 3: Generate from name if available
+  if (object.name) {
+    return generateUuidFromName(object.name);
+  }
+  return null;
+}
+
+export { findObjectByHardcodedUuid, generateUuidFromName, getHardcodedUuid, namesGenerateSameUuid };