@2112-lab/central-plant 0.1.2 → 0.1.4

package/dist/esm/src/hotReloadManager.js

@@ -1,244 +0,0 @@
-import { createClass as _createClass, classCallCheck as _classCallCheck } from '../_virtual/_rollupPluginBabelHelpers.js';
-
-/**
- * Hot-Reload Manager Module
- * Handles development environment hot-reload detection and cleanup
- */
-
-// Check if we're in a browser environment
-var isBrowser = typeof window !== 'undefined';
-var isDev = isBrowser && process.env.NODE_ENV === 'development';
-var HotReloadManager = /*#__PURE__*/function () {
-  function HotReloadManager(componentInstance) {
-    _classCallCheck(this, HotReloadManager);
-    this.component = componentInstance;
-    this.isDev = isDev;
-    this.instanceId = Date.now() + Math.random();
-
-    // Event handlers
-    this.hotReloadCleanupHandler = null;
-    this.visibilityChangeHandler = null;
-    this.nuxtHotReloadHandler = null;
-    this.memoryCheckInterval = null;
-
-    // Async operation tracking
-    this.timeoutIds = new Set();
-    this.intervalIds = new Set();
-  }
-
-  /**
-   * Setup hot-reload handling for development environment
-   */
-  return _createClass(HotReloadManager, [{
-    key: "setupHotReloadHandling",
-    value: function setupHotReloadHandling() {
-      var _this = this;
-      if (!isBrowser || !this.isDev) {
-        console.log('Not in browser or development mode, skipping hot-reload setup');
-        return;
-      }
-      console.log('Setting up hot-reload handling...');
-
-      // Initialize global instance tracking
-      if (!window._sceneViewerInstances) {
-        window._sceneViewerInstances = new Set();
-        console.log('🔧 [Hot-Reload] Initialized global instance tracking');
-      }
-
-      // Add this instance to global tracking
-      window._sceneViewerInstances.add(this.component);
-      console.log('📍 [Hot-Reload] Instance registered:', {
-        instanceId: this.instanceId,
-        totalInstances: window._sceneViewerInstances.size
-      });
-
-      // Enhanced beforeunload handler for development
-      this.hotReloadCleanupHandler = function () {
-        console.log('🔄 [Hot-Reload] Page unload detected, performing enhanced cleanup');
-        if (_this.component && typeof _this.component.enhancedDisposal === 'function') {
-          _this.component.enhancedDisposal();
-        }
-        if (window._sceneViewerInstances) {
-          window._sceneViewerInstances.delete(_this.component);
-        }
-      };
-
-      // Add event listeners
-      window.addEventListener('beforeunload', this.hotReloadCleanupHandler);
-      window.addEventListener('pagehide', this.hotReloadCleanupHandler);
-      console.log('✅ [Hot-Reload] Hot-reload handling setup completed');
-    }
-
-    /**
-     * Cleanup hot-reload handlers (development only)
-     */
-  }, {
-    key: "cleanupHotReloadHandlers",
-    value: function cleanupHotReloadHandlers() {
-      if (!isBrowser || !this.isDev) return;
-
-      // Remove event listeners
-      if (this.hotReloadCleanupHandler) {
-        window.removeEventListener('beforeunload', this.hotReloadCleanupHandler);
-        window.removeEventListener('pagehide', this.hotReloadCleanupHandler);
-        this.hotReloadCleanupHandler = null;
-      }
-      if (this.visibilityChangeHandler) {
-        document.removeEventListener('visibilitychange', this.visibilityChangeHandler);
-        this.visibilityChangeHandler = null;
-      }
-
-      // Remove Nuxt hot-reload handlers
-      if (this.nuxtHotReloadHandler && window.$nuxt && window.$nuxt.$off) {
-        window.$nuxt.$off('routeChanged', this.nuxtHotReloadHandler);
-        window.$nuxt.$off('$nuxtReady', this.nuxtHotReloadHandler);
-        this.nuxtHotReloadHandler = null;
-      }
-
-      // Clear memory monitoring interval
-      if (this.memoryCheckInterval) {
-        clearInterval(this.memoryCheckInterval);
-        this.memoryCheckInterval = null;
-      }
-
-      // Remove from global instance tracking
-      if (window._sceneViewerInstances) {
-        window._sceneViewerInstances.delete(this.component);
-        console.log('📍 [Hot-Reload] Instance removed from tracking:', {
-          instanceId: this.instanceId,
-          remainingInstances: window._sceneViewerInstances.size
-        });
-      }
-    }
-
-    /**
-     * Track a timeout ID for cleanup on component destruction
-     */
-  }, {
-    key: "trackTimeout",
-    value: function trackTimeout(timeoutId) {
-      if (timeoutId) {
-        this.timeoutIds.add(timeoutId);
-      }
-      return timeoutId;
-    }
-
-    /**
-     * Track an interval ID for cleanup on component destruction
-     */
-  }, {
-    key: "trackInterval",
-    value: function trackInterval(intervalId) {
-      if (intervalId) {
-        this.intervalIds.add(intervalId);
-      }
-      return intervalId;
-    }
-
-    /**
-     * Clear a tracked timeout and remove from tracking
-     */
-  }, {
-    key: "clearTrackedTimeout",
-    value: function clearTrackedTimeout(timeoutId) {
-      if (this.timeoutIds.has(timeoutId)) {
-        clearTimeout(timeoutId);
-        this.timeoutIds.delete(timeoutId);
-        return true;
-      }
-      return false;
-    }
-
-    /**
-     * Clear a tracked interval and remove from tracking
-     */
-  }, {
-    key: "clearTrackedInterval",
-    value: function clearTrackedInterval(intervalId) {
-      if (this.intervalIds.has(intervalId)) {
-        clearInterval(intervalId);
-        this.intervalIds.delete(intervalId);
-        return true;
-      }
-      return false;
-    }
-
-    /**
-     * Clear all tracked timeouts and intervals
-     */
-  }, {
-    key: "clearAllTrackedTimers",
-    value: function clearAllTrackedTimers() {
-      // Clear all timeouts
-      this.timeoutIds.forEach(function (id) {
-        clearTimeout(id);
-      });
-      this.timeoutIds.clear();
-
-      // Clear all intervals
-      this.intervalIds.forEach(function (id) {
-        clearInterval(id);
-      });
-      this.intervalIds.clear();
-      console.log('🧹 [Hot-Reload] Cleared all tracked timers');
-    }
-  }]);
-}();
-
-/**
- * Simple utility to handle hot-reload for componentId
- * @param {string} instanceId - Unique instance identifier for the component
- * @param {Function} cleanupMethod - Method to call to clean up resources
- */
-function handleHotReload(instanceId, cleanupMethod) {
-  if (!isBrowser || !isDev) return;
-
-  // Initialize registry if needed
-  if (!window._hotReloadRegistry) {
-    window._hotReloadRegistry = new Map();
-  }
-
-  // If we're reloading and have a previous instance with the same ID, clean it up
-  var existingInstance = window._hotReloadRegistry.get(instanceId);
-  if (existingInstance) {
-    console.log("\uD83D\uDD25 [Hot-Reload] Detected hot reload for instance: ".concat(instanceId));
-    if (typeof existingInstance.cleanup === 'function') {
-      existingInstance.cleanup();
-    }
-  }
-
-  // Register new instance
-  window._hotReloadRegistry.set(instanceId, {
-    timestamp: Date.now(),
-    cleanup: cleanupMethod
-  });
-}
-
-/**
- * Check if we're currently hot-reloading
- */
-function isHotReloading() {
-  return isDev && isBrowser && window._hotReloadRegistry && window._hotReloadRegistry.size > 0;
-}
-
-/**
- * Clean up resources for a component before hot-reload
- * @param {string} instanceId - ID of the component instance to clean up
- */
-function cleanupForHotReload(instanceId) {
-  if (!isBrowser || !isDev || !window._hotReloadRegistry) return;
-  var instance = window._hotReloadRegistry.get(instanceId);
-  if (instance && typeof instance.cleanup === 'function') {
-    instance.cleanup();
-    window._hotReloadRegistry.delete(instanceId);
-    console.log("\uD83E\uDDF9 [Hot-Reload] Cleaned up instance: ".concat(instanceId));
-  }
-}
-var hotReloadManager = {
-  HotReloadManager: HotReloadManager,
-  handleHotReload: handleHotReload,
-  isHotReloading: isHotReloading,
-  cleanupForHotReload: cleanupForHotReload
-};
-
-export { HotReloadManager, cleanupForHotReload, hotReloadManager as default, handleHotReload, isHotReloading };

package/dist/esm/src/keyboardControlsManager.js

@@ -1,196 +0,0 @@
-import { logger } from './debugLogger.js';
-
-/**
- * Keyboard Controls Manager
- * Manages keyboard shortcuts and controls
- */
-
-// Store registered key handlers
-var keyHandlers = new Map();
-var isListening = false;
-
-/**
- * Initialize keyboard controls
- */
-function initKeyboardControls() {
-  if (typeof window === 'undefined') {
-    logger.warn('Cannot initialize keyboard controls: window is not defined');
-    return;
-  }
-
-  // Only add event listener once
-  if (isListening) return;
-
-  // Handle keydown events
-  window.addEventListener('keydown', handleKeyDown);
-  window.addEventListener('keyup', handleKeyUp);
-  isListening = true;
-  logger.info('Keyboard controls initialized');
-}
-
-/**
- * Clean up keyboard controls
- */
-function cleanupKeyboardControls() {
-  if (typeof window === 'undefined' || !isListening) {
-    return;
-  }
-  window.removeEventListener('keydown', handleKeyDown);
-  window.removeEventListener('keyup', handleKeyUp);
-  keyHandlers.clear();
-  isListening = false;
-  logger.info('Keyboard controls cleaned up');
-}
-
-/**
- * Handler for keydown events
- */
-function handleKeyDown(event) {
-  // Get key or combination
-  var keyCombo = getKeyCombo(event);
-
-  // Get handler for this key
-  var handler = keyHandlers.get(keyCombo);
-  if (handler) {
-    event.preventDefault();
-    handler.callback(event);
-  }
-}
-
-/**
- * Handler for keyup events
- */
-function handleKeyUp(event) {
-  var keyCombo = getKeyCombo(event);
-
-  // Get handler for this key
-  var handler = keyHandlers.get(keyCombo);
-  if (handler && handler.onKeyUp) {
-    event.preventDefault();
-    handler.onKeyUp(event);
-  }
-}
-
-/**
- * Register a key handler
- */
-function registerKeyHandler(key, callback) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  // Normalize key format
-  var normalizedKey = normalizeKey(key);
-
-  // Register handler
-  keyHandlers.set(normalizedKey, {
-    callback: callback,
-    onKeyUp: options.onKeyUp || null,
-    description: options.description || ''
-  });
-
-  // Initialize controls if not already done
-  if (!isListening) {
-    initKeyboardControls();
-  }
-  return normalizedKey;
-}
-
-/**
- * Unregister a key handler
- */
-function unregisterKeyHandler(key) {
-  var normalizedKey = normalizeKey(key);
-  return keyHandlers.delete(normalizedKey);
-}
-
-/**
- * Get all registered key handlers
- */
-function getRegisteredKeyHandlers() {
-  var handlers = [];
-  keyHandlers.forEach(function (handler, key) {
-    handlers.push({
-      key: key,
-      description: handler.description
-    });
-  });
-  return handlers;
-}
-
-/**
- * Helper function to normalize key format
- */
-function normalizeKey(key) {
-  return key.toLowerCase();
-}
-
-/**
- * Helper function to get key combo string from event
- */
-function getKeyCombo(event) {
-  var combo = '';
-  if (event.ctrlKey) combo += 'ctrl+';
-  if (event.altKey) combo += 'alt+';
-  if (event.shiftKey) combo += 'shift+';
-  if (event.metaKey) combo += 'meta+';
-  combo += event.key.toLowerCase();
-  return combo;
-}
-
-/**
- * Setup common keyboard controls for a Three.js scene
- */
-function setupCommonControls(component) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  // Reset view
-  registerKeyHandler('r', function () {
-    if (component.camera && component.controls) {
-      component.camera.position.set(-10, 10, 10);
-      component.controls.target.set(0, 0, 0);
-      component.controls.update();
-      logger.info('Camera reset');
-    }
-  }, {
-    description: 'Reset camera view'
-  });
-
-  // Toggle wireframe mode
-  registerKeyHandler('w', function () {
-    if (component.scene) {
-      var wireframeEnabled = !options.wireframeEnabled;
-      options.wireframeEnabled = wireframeEnabled;
-      component.scene.traverse(function (object) {
-        if (object.isMesh && object.material) {
-          if (Array.isArray(object.material)) {
-            object.material.forEach(function (mat) {
-              mat.wireframe = wireframeEnabled;
-            });
-          } else {
-            object.material.wireframe = wireframeEnabled;
-          }
-        }
-      });
-      logger.info("Wireframe mode: ".concat(wireframeEnabled ? 'enabled' : 'disabled'));
-    }
-  }, {
-    description: 'Toggle wireframe mode'
-  });
-
-  // Toggle performance monitor
-  registerKeyHandler('p', function () {
-    if (component.performanceUI) {
-      component.performanceUI.toggle();
-    }
-  }, {
-    description: 'Toggle performance monitor'
-  });
-  logger.info('Common keyboard controls setup');
-}
-var keyboardControlsManager = {
-  initKeyboardControls: initKeyboardControls,
-  cleanupKeyboardControls: cleanupKeyboardControls,
-  registerKeyHandler: registerKeyHandler,
-  unregisterKeyHandler: unregisterKeyHandler,
-  getRegisteredKeyHandlers: getRegisteredKeyHandlers,
-  setupCommonControls: setupCommonControls
-};
-
-export { cleanupKeyboardControls, keyboardControlsManager as default, getRegisteredKeyHandlers, initKeyboardControls, registerKeyHandler, setupCommonControls, unregisterKeyHandler };

package/dist/esm/src/nameUtils.js

@@ -1,99 +0,0 @@
-/**
- * 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 };