@2112-lab/central-plant 0.1.39 → 0.1.41

package/dist/esm/src/managers/system/operationHistoryManager.js

@@ -0,0 +1,409 @@
+import { inherits as _inherits, createClass as _createClass, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { BaseDisposable } from '../../core/baseDisposable.js';
+
+/**
+ * OperationHistoryManager handles operation history with sessionStorage persistence
+ */
+var OperationHistoryManager = /*#__PURE__*/function (_BaseDisposable) {
+  function OperationHistoryManager(sceneViewer) {
+    var _this;
+    _classCallCheck(this, OperationHistoryManager);
+    _this = _callSuper(this, OperationHistoryManager);
+    _this.sceneViewer = sceneViewer;
+    _this.storageKey = 'centralPlant_history';
+    _this.maxHistorySize = 10; // Limit history to prevent storage overflow
+
+    // Register this manager with the sceneViewer (using 'operationHistory' for consistency)
+    if (_this.sceneViewer && _this.sceneViewer.managers) {
+      _this.sceneViewer.managers.operationHistory = _this;
+    }
+    console.log('📜 OperationHistoryManager initialized');
+    return _this;
+  }
+
+  /**
+   * Check if sessionStorage is available
+   * @returns {boolean} True if sessionStorage is available
+   * @private
+   */
+  _inherits(OperationHistoryManager, _BaseDisposable);
+  return _createClass(OperationHistoryManager, [{
+    key: "_isSessionStorageAvailable",
+    value: function _isSessionStorageAvailable() {
+      try {
+        return typeof sessionStorage !== 'undefined';
+      } catch (error) {
+        return false;
+      }
+    }
+
+    /**
+     * Add an operation to the history
+     * @param {string} operationName - Name of operation ('translateComponent', 'translateSegment', 'translateGateway', etc.)
+     * @param {Object} params - Operation parameters (segmentId/componentId/gatewayId, axis, value, etc.)
+     * @returns {boolean} True if operation was stored successfully, false otherwise
+     */
+  }, {
+    key: "addToOperationHistory",
+    value: function addToOperationHistory(operationName, params) {
+      try {
+        if (!this._isSessionStorageAvailable()) {
+          console.warn('⚠️ sessionStorage not available, cannot store operation history');
+          return false;
+        }
+
+        // Get existing history
+        var history = [];
+        var stored = sessionStorage.getItem(this.storageKey);
+        if (stored) {
+          history = JSON.parse(stored);
+        }
+
+        // Create new operation entry
+        var operationEntry = {
+          operationName: operationName,
+          timestamp: new Date().toISOString(),
+          params: params
+        };
+
+        // Add to history (newest first)
+        history.unshift(operationEntry);
+
+        // Trim history if too large
+        if (history.length > this.maxHistorySize) {
+          history = history.slice(0, this.maxHistorySize);
+        }
+
+        // Save back to sessionStorage
+        sessionStorage.setItem(this.storageKey, JSON.stringify(history));
+        console.log("\uD83D\uDCBE Operation stored to sessionStorage:", operationEntry);
+        return true;
+      } catch (error) {
+        console.error('❌ Error storing operation to sessionStorage:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Get operation history from sessionStorage
+     * @param {Object} options - Filter options
+     * @param {string} [options.operationName] - Filter by operation name
+     * @param {number} [options.limit] - Limit number of results
+     * @returns {Array} Array of operation entries
+     */
+  }, {
+    key: "getOperationHistory",
+    value: function getOperationHistory() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      try {
+        if (!this._isSessionStorageAvailable()) {
+          console.warn('⚠️ sessionStorage not available');
+          return [];
+        }
+        var stored = sessionStorage.getItem(this.storageKey);
+        if (!stored) {
+          return [];
+        }
+        var history = JSON.parse(stored);
+
+        // Filter by operation name if specified
+        if (options.operationName) {
+          history = history.filter(function (entry) {
+            return entry.operationName === options.operationName;
+          });
+        }
+
+        // Limit results if specified
+        if (options.limit && options.limit > 0) {
+          history = history.slice(0, options.limit);
+        }
+        return history;
+      } catch (error) {
+        console.error('❌ Error reading operation history:', error);
+        return [];
+      }
+    }
+
+    /**
+     * Clear operation history from sessionStorage
+     * @returns {boolean} True if history was cleared successfully, false otherwise
+     */
+  }, {
+    key: "clearOperationHistory",
+    value: function clearOperationHistory() {
+      try {
+        if (!this._isSessionStorageAvailable()) {
+          console.warn('⚠️ sessionStorage not available');
+          return false;
+        }
+        sessionStorage.removeItem(this.storageKey);
+        console.log('🗑️ Operation history cleared from sessionStorage');
+        return true;
+      } catch (error) {
+        console.error('❌ Error clearing operation history:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Get the most recent operation
+     * @returns {Object|null} The most recent operation entry or null if none exists
+     */
+  }, {
+    key: "getLastOperation",
+    value: function getLastOperation() {
+      var history = this.getOperationHistory({
+        limit: 1
+      });
+      return history.length > 0 ? history[0] : null;
+    }
+
+    /**
+     * Undo the most recent operation and remove it from history
+     * @returns {boolean} True if undo was successful, false otherwise
+     */
+  }, {
+    key: "undoLastOperation",
+    value: function undoLastOperation() {
+      try {
+        // Get the last operation
+        var lastOp = this.getLastOperation();
+        if (!lastOp) {
+          console.warn('⚠️ No operation to undo');
+          return false;
+        }
+        console.log('⏪ Undoing last operation:', lastOp);
+
+        // Execute the reverse operation based on operation type
+        var undoSuccess = false;
+        switch (lastOp.operationName) {
+          case 'translateSegment':
+            undoSuccess = this._undoTranslateSegment(lastOp.params);
+            break;
+          case 'translateComponent':
+            undoSuccess = this._undoTranslateComponent(lastOp.params);
+            break;
+          case 'translateGateway':
+            undoSuccess = this._undoTranslateGateway(lastOp.params);
+            break;
+          default:
+            console.warn("\u26A0\uFE0F Unknown operation type: ".concat(lastOp.operationName));
+            return false;
+        }
+        if (undoSuccess) {
+          // Remove the operation from history
+          this._removeLastOperationFromHistory();
+          console.log('✅ Undo successful');
+          return true;
+        } else {
+          console.error('❌ Undo failed');
+          return false;
+        }
+      } catch (error) {
+        console.error('❌ Error during undo:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Undo a translateSegment operation
+     * @param {Object} params - Original operation parameters
+     * @returns {boolean} Success status
+     * @private
+     */
+  }, {
+    key: "_undoTranslateSegment",
+    value: function _undoTranslateSegment(params) {
+      var _this$sceneViewer, _centralPlant$manager;
+      var segmentId = params.segmentId,
+        axis = params.axis,
+        value = params.value;
+
+      // Access centralPlant through sceneViewer
+      var centralPlant = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.centralPlant;
+      if (!centralPlant || !centralPlant.translateSegment) {
+        console.error('❌ CentralPlant translateSegment API not available for undo');
+        return false;
+      }
+
+      // Reverse the translation by applying negative value
+      // Note: We temporarily disable history tracking to avoid creating a new history entry
+      var historyManager = (_centralPlant$manager = centralPlant.managers) === null || _centralPlant$manager === void 0 ? void 0 : _centralPlant$manager.operationHistoryManager;
+      var originalAddMethod = historyManager === null || historyManager === void 0 ? void 0 : historyManager.addToOperationHistory;
+
+      // Disable history tracking during undo
+      if (historyManager) {
+        historyManager.addToOperationHistory = function () {
+          return true;
+        };
+      }
+      var success = centralPlant.translateSegment(segmentId, axis, -value);
+
+      // Restore history tracking
+      if (historyManager && originalAddMethod) {
+        historyManager.addToOperationHistory = originalAddMethod;
+      }
+      return success;
+    }
+
+    /**
+     * Undo a translateComponent operation
+     * @param {Object} params - Original operation parameters
+     * @returns {boolean} Success status
+     * @private
+     */
+  }, {
+    key: "_undoTranslateComponent",
+    value: function _undoTranslateComponent(params) {
+      var _this$sceneViewer2, _centralPlant$manager2;
+      var componentId = params.componentId,
+        axis = params.axis,
+        value = params.value;
+      var centralPlant = (_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.centralPlant;
+      if (!centralPlant || !centralPlant.translateComponent) {
+        console.error('❌ CentralPlant translateComponent API not available for undo');
+        return false;
+      }
+
+      // Temporarily disable history tracking
+      var historyManager = (_centralPlant$manager2 = centralPlant.managers) === null || _centralPlant$manager2 === void 0 ? void 0 : _centralPlant$manager2.operationHistoryManager;
+      var originalAddMethod = historyManager === null || historyManager === void 0 ? void 0 : historyManager.addToOperationHistory;
+      if (historyManager) {
+        historyManager.addToOperationHistory = function () {
+          return true;
+        };
+      }
+      var success = centralPlant.translateComponent(componentId, axis, -value);
+      if (historyManager && originalAddMethod) {
+        historyManager.addToOperationHistory = originalAddMethod;
+      }
+      return success;
+    }
+
+    /**
+     * Undo a translateGateway operation
+     * @param {Object} params - Original operation parameters
+     * @returns {boolean} Success status
+     * @private
+     */
+  }, {
+    key: "_undoTranslateGateway",
+    value: function _undoTranslateGateway(params) {
+      var _this$sceneViewer3, _centralPlant$manager3;
+      var gatewayId = params.gatewayId,
+        axis = params.axis,
+        value = params.value;
+      var centralPlant = (_this$sceneViewer3 = this.sceneViewer) === null || _this$sceneViewer3 === void 0 ? void 0 : _this$sceneViewer3.centralPlant;
+      if (!centralPlant || !centralPlant.translateGateway) {
+        console.error('❌ CentralPlant translateGateway API not available for undo');
+        return false;
+      }
+
+      // Temporarily disable history tracking
+      var historyManager = (_centralPlant$manager3 = centralPlant.managers) === null || _centralPlant$manager3 === void 0 ? void 0 : _centralPlant$manager3.operationHistoryManager;
+      var originalAddMethod = historyManager === null || historyManager === void 0 ? void 0 : historyManager.addToOperationHistory;
+      if (historyManager) {
+        historyManager.addToOperationHistory = function () {
+          return true;
+        };
+      }
+      var success = centralPlant.translateGateway(gatewayId, axis, -value);
+      if (historyManager && originalAddMethod) {
+        historyManager.addToOperationHistory = originalAddMethod;
+      }
+      return success;
+    }
+
+    /**
+     * Remove the most recent operation from history
+     * @returns {boolean} Success status
+     * @private
+     */
+  }, {
+    key: "_removeLastOperationFromHistory",
+    value: function _removeLastOperationFromHistory() {
+      try {
+        if (!this._isSessionStorageAvailable()) {
+          return false;
+        }
+        var stored = sessionStorage.getItem(this.storageKey);
+        if (!stored) {
+          return false;
+        }
+        var history = JSON.parse(stored);
+
+        // Remove first item (most recent)
+        if (history.length > 0) {
+          history.shift();
+          sessionStorage.setItem(this.storageKey, JSON.stringify(history));
+          console.log('🗑️ Removed last operation from history');
+          return true;
+        }
+        return false;
+      } catch (error) {
+        console.error('❌ Error removing last operation from history:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Get operation history count
+     * @returns {number} Number of operations in history
+     */
+  }, {
+    key: "getHistoryCount",
+    value: function getHistoryCount() {
+      var history = this.getOperationHistory();
+      return history.length;
+    }
+
+    /**
+     * Set the maximum history size
+     * @param {number} size - Maximum number of operations to store
+     */
+  }, {
+    key: "setMaxHistorySize",
+    value: function setMaxHistorySize(size) {
+      if (typeof size !== 'number' || size < 1) {
+        console.warn('⚠️ Invalid max history size, must be a positive number');
+        return;
+      }
+      this.maxHistorySize = size;
+      console.log("\uD83D\uDCCF Max history size set to ".concat(size));
+
+      // Trim existing history if needed
+      try {
+        if (this._isSessionStorageAvailable()) {
+          var stored = sessionStorage.getItem(this.storageKey);
+          if (stored) {
+            var history = JSON.parse(stored);
+            if (history.length > size) {
+              history = history.slice(0, size);
+              sessionStorage.setItem(this.storageKey, JSON.stringify(history));
+              console.log("\u2702\uFE0F Trimmed history to ".concat(size, " entries"));
+            }
+          }
+        }
+      } catch (error) {
+        console.error('❌ Error trimming history:', error);
+      }
+    }
+
+    /**
+     * Dispose method - clean up resources
+     * @override
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      // Clear any references
+      this.sceneViewer = null;
+
+      // Call parent dispose
+      _superPropGet(OperationHistoryManager, "dispose", this, 3)([]);
+      console.log('🗑️ OperationHistoryManager disposed');
+    }
+  }]);
+}(BaseDisposable);
+
+export { OperationHistoryManager, OperationHistoryManager as default };

package/dist/esm/src/managers/system/settingsManager.js

@@ -7,7 +7,8 @@ import { BaseDisposable } from '../../core/baseDisposable.js';
 var DEFAULT_SETTINGS = {
   scene: {
     autoRotation: false,
-    checkUnderground: true
+    checkUnderground: true,
+    splitSegmentsWithComponentConnectors: true
   },
   viewport: {
     perspectiveFullscreen: true

package/dist/esm/src/utils/objectTypes.js

@@ -17,7 +17,7 @@
  */
 function isComponent(obj) {
   if (!obj || !obj.userData) return false;
-  return obj.userData.objectType === 'component' || obj.userData.objectType !== undefined;
+  return obj.userData.objectType === 'component';
 }
 
 /**
@@ -33,7 +33,7 @@ function isComponent(obj) {
  */
 function isSegment(obj) {
   if (!obj || !obj.userData) return false;
-  return obj.userData.objectType === 'segment' || obj.userData.isPipeSegment === true;
+  return obj.userData.objectType === 'segment';
 }
 
 /**
@@ -49,7 +49,7 @@ function isSegment(obj) {
  */
 function isGateway(obj) {
   if (!obj || !obj.userData) return false;
-  return obj.userData.objectType === 'gateway' || obj.userData.objectType === 'gateway';
+  return obj.userData.objectType === 'gateway';
 }
 
 /**
@@ -69,7 +69,7 @@ function isConnector(obj) {
 }
 
 /**
- * Check if object was declared (from scene definition or manually edited)
+ * Check if object is declared (manually placed/positioned)
  * Declared objects should be preserved during regeneration.
  * 
  * @param {Object} obj - Three.js object to check
@@ -82,7 +82,7 @@ function isConnector(obj) {
  */
 function isDeclared(obj) {
   if (!obj || !obj.userData) return false;
-  return obj.userData.isDeclared === true || obj.userData.origin === 'declared';
+  return obj.userData.isDeclared === true;
 }
 
 /**
@@ -194,7 +194,6 @@ function getObjectTypeName(obj) {
 function markAsDeclared(obj) {
   if (obj && obj.userData) {
     obj.userData.isDeclared = true;
-    obj.userData.origin = 'declared'; // Backward compatibility
   }
 }
 
@@ -211,7 +210,6 @@ function markAsDeclared(obj) {
 function markAsComputed(obj) {
   if (obj && obj.userData) {
     obj.userData.isDeclared = false;
-    obj.userData.origin = 'computed'; // Backward compatibility
   }
 }
 

package/dist/index.d.ts

@@ -9,7 +9,6 @@
 export { CentralPlant } from './core/centralPlant.js';
 export { DebugLogger, logger, transformLogger, pathfinderLogger, modelLogger } from './core/debugLogger.js';
 export { generateUuidFromName, getHardcodedUuid, findObjectByHardcodedUuid } from './core/nameUtils.js';
-export { MathUtils } from './core/mathUtils.js';
 
 // Scene management
 export { SceneInitializationManager } from './managers/scene/sceneInitializationManager.js';
@@ -19,7 +18,7 @@ export { SceneTooltipsManager } from './managers/scene/sceneTooltipsManager.js';
 
 // Component management
 export { ComponentManager } from './managers/components/componentManager.js';
-export { AnimationManager } from './managers/components/animationManager.js';
+export { AnimationManager } from './managers/scene/animationManager.js';
 export { PathfindingManager } from './managers/components/pathfindingManager.js';
 
 // Controls management
@@ -36,6 +35,7 @@ export { loadTextureSetAndCreateMaterial } from './managers/environment/textureC
 export { HotReloadManager } from './managers/system/hotReloadManager.js';
 export { DisposalManager } from './managers/system/disposalManager.js';
 export { PerformanceMonitor } from './managers/system/performanceMonitor.js';
+export { OperationHistoryManager } from './managers/system/operationHistoryManager.js';
 
 // Rendering utilities
 export { default as modelPreloader } from './rendering/modelPreloader.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2112-lab/central-plant",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "description": "Utility modules for the Central Plant Application",
   "main": "dist/bundle/index.js",
   "module": "dist/esm/index.js",