@2112-lab/central-plant 0.1.0

package/dist/esm/src/hotReloadManager.js

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

@@ -0,0 +1,117 @@
+import * as animationManager from './animationManager.js';
+export { animationManager };
+import * as componentManager from './componentManager.js';
+export { componentManager };
+import * as debugLogger from './debugLogger.js';
+export { debugLogger };
+export { logger, modelLogger, pathfinderLogger, transformLogger } from './debugLogger.js';
+import * as disposalManager from './disposalManager.js';
+export { disposalManager };
+import * as environmentManager from './environmentManager.js';
+export { environmentManager };
+import * as hotReloadManager from './hotReloadManager.js';
+export { hotReloadManager };
+import * as keyboardControlsManager from './keyboardControlsManager.js';
+export { keyboardControlsManager };
+import * as modelPreloader from './modelPreloader.js';
+export { modelPreloader };
+import * as nameUtils from './nameUtils.js';
+export { nameUtils };
+export { findObjectByHardcodedUuid, generateUuidFromName, getHardcodedUuid } from './nameUtils.js';
+import * as pathfindingManager from './pathfindingManager.js';
+export { pathfindingManager };
+import * as performanceMonitor from './performanceMonitor.js';
+export { performanceMonitor };
+import * as sceneExportManager from './sceneExportManager.js';
+export { sceneExportManager };
+export { getSceneExportManager } from './sceneExportManager.js';
+import * as sceneInitializationManager from './sceneInitializationManager.js';
+export { sceneInitializationManager };
+import * as sceneOperationsManager from './sceneOperationsManager.js';
+export { sceneOperationsManager };
+export { getSceneOperationsManager } from './sceneOperationsManager.js';
+import * as textureConfig from './textureConfig.js';
+export { textureConfig };
+import * as transformControlsManager from './transformControlsManager.js';
+export { transformControlsManager };
+export { getTransformControlsManager } from './transformControlsManager.js';
+import * as Pathfinder from './Pathfinder.js';
+export { Pathfinder };
+import * as ConnectionManager from './ConnectionManager.js';
+export { ConnectionManager };
+
+/**
+ * @module CentralPlant/Utils
+ * @description Central Plant Utilities Module
+ * 
+ * This is the main entry point for all utility functions and classes
+ * used in the Central Plant application. Import this module to access
+ * all utility functions through a single interface.
+ * 
+ * @example
+ * // Import the entire utilities module
+ * import CentralPlant from 'central-plant';
+ * 
+ * // Use a specific utility
+ * CentralPlant.modelPreloader.preloadAllModels(...);
+ * 
+ * @example
+ * // Import specific modules
+ * import { modelPreloader, nameUtils } from 'CentralPlant';
+ * 
+ * // Use them directly
+ * modelPreloader.preloadAllModels(...);
+ * 
+ * @example
+ * // Import common functions directly
+ * import { getHardcodedUuid, logger } from 'CentralPlant';
+ * 
+ * // Use functions directly
+ * const uuid = getHardcodedUuid(object);
+ * logger.info('Operation completed');
+ */
+
+/**
+ * Central API object that provides access to all utility modules
+ * @type {Object}
+ * @property {Object} animation - Animation management utilities
+ * @property {Object} component - Component management utilities
+ * @property {Object} debug - Debugging and logging utilities
+ * @property {Object} disposal - Resource disposal utilities
+ * @property {Object} environment - 3D environment management utilities
+ * @property {Object} hotReload - Hot reload handling utilities
+ * @property {Object} keyboardControls - Keyboard controls management
+ * @property {Object} modelPreloader - Model preloading utilities
+ * @property {Object} name - Name and UUID management utilities
+ * @property {Object} pathfinding - Pathfinding utilities
+ * @property {Object} performance - Performance monitoring utilities
+ * @property {Object} sceneExport - Scene export utilities
+ * @property {Object} sceneInitialization - Scene initialization utilities
+ * @property {Object} sceneOperations - Scene operations utilities
+ * @property {Object} texture - Texture management utilities
+ * @property {Object} transformControls - Transform controls utilities
+ * @property {Object} pathfinder - Pathfinder utilities
+ * @property {Object} connectionManager - Connection management utilities
+ */
+var CentralPlantUtils = {
+  animation: animationManager,
+  component: componentManager,
+  debug: debugLogger,
+  disposal: disposalManager,
+  environment: environmentManager,
+  hotReload: hotReloadManager,
+  keyboardControls: keyboardControlsManager,
+  modelPreloader: modelPreloader,
+  name: nameUtils,
+  pathfinding: pathfindingManager,
+  performance: performanceMonitor,
+  sceneExport: sceneExportManager,
+  sceneInitialization: sceneInitializationManager,
+  sceneOperations: sceneOperationsManager,
+  texture: textureConfig,
+  transformControls: transformControlsManager,
+  pathfinder: Pathfinder,
+  connectionManager: ConnectionManager
+};
+
+export { CentralPlantUtils as default };

package/dist/esm/src/keyboardControlsManager.js

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