@2112-lab/central-plant 0.1.39 → 0.1.41

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

@@ -0,0 +1,414 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../../_virtual/_rollupPluginBabelHelpers.js');
+var baseDisposable = require('../../core/baseDisposable.js');
+
+/**
+ * OperationHistoryManager handles operation history with sessionStorage persistence
+ */
+var OperationHistoryManager = /*#__PURE__*/function (_BaseDisposable) {
+  function OperationHistoryManager(sceneViewer) {
+    var _this;
+    _rollupPluginBabelHelpers.classCallCheck(this, OperationHistoryManager);
+    _this = _rollupPluginBabelHelpers.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
+   */
+  _rollupPluginBabelHelpers.inherits(OperationHistoryManager, _BaseDisposable);
+  return _rollupPluginBabelHelpers.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
+      _rollupPluginBabelHelpers.superPropGet(OperationHistoryManager, "dispose", this, 3)([]);
+      console.log('🗑️ OperationHistoryManager disposed');
+    }
+  }]);
+}(baseDisposable.BaseDisposable);
+
+exports.OperationHistoryManager = OperationHistoryManager;
+exports["default"] = OperationHistoryManager;

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

@@ -11,7 +11,8 @@ var baseDisposable = require('../../core/baseDisposable.js');
 var DEFAULT_SETTINGS = {
   scene: {
     autoRotation: false,
-    checkUnderground: true
+    checkUnderground: true,
+    splitSegmentsWithComponentConnectors: true
   },
   viewport: {
     perspectiveFullscreen: true

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

@@ -21,7 +21,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
  */
 function isComponent(obj) {
   if (!obj || !obj.userData) return false;
-  return obj.userData.objectType === 'component' || obj.userData.objectType !== undefined;
+  return obj.userData.objectType === 'component';
 }
 
 /**
@@ -37,7 +37,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';
 }
 
 /**
@@ -53,7 +53,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';
 }
 
 /**
@@ -73,7 +73,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
@@ -86,7 +86,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;
 }
 
 /**
@@ -198,7 +198,6 @@ function getObjectTypeName(obj) {
 function markAsDeclared(obj) {
   if (obj && obj.userData) {
     obj.userData.isDeclared = true;
-    obj.userData.origin = 'declared'; // Backward compatibility
   }
 }
 
@@ -215,7 +214,6 @@ function markAsDeclared(obj) {
 function markAsComputed(obj) {
   if (obj && obj.userData) {
     obj.userData.isDeclared = false;
-    obj.userData.origin = 'computed'; // Backward compatibility
   }
 }
 

package/dist/esm/src/core/centralPlant.js

@@ -15,7 +15,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.1.39
+   * @version 0.1.41
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.
@@ -311,6 +311,51 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
       return this.internals.translateGateway(gatewayId, axis, value);
     }
 
+    /**
+     * Split a pipe segment in half at its midpoint
+     * @param {string} segmentId - The UUID of the segment to split
+     * @returns {Object|null} Object with {segment1, segment2} or null on failure
+     * @description Splits a selected pipe segment into two equal halves at its midpoint.
+     * Each resulting segment is automatically manualized (converted to manual/declared status).
+     * The original segment is removed and replaced with two new segments that maintain
+     * the same orientation and material properties. Paths are regenerated after splitting
+     * to ensure proper connections.
+     * @example
+     * // Split a segment when selected via transform controls
+     * const result = centralPlant.splitSegment('Segment-12345');
+     * if (result) {
+     *   console.log('Segment split into:', result.segment1.uuid, result.segment2.uuid);
+     * }
+     * 
+     * @since 0.1.37
+     */
+  }, {
+    key: "splitSegment",
+    value: function splitSegment(segmentId) {
+      var _this$sceneViewer$man;
+      if (!this.sceneViewer || !((_this$sceneViewer$man = this.sceneViewer.managers) !== null && _this$sceneViewer$man !== void 0 && _this$sceneViewer$man.sceneOperationsManager)) {
+        console.warn('⚠️ splitSegment(): Scene viewer or scene operations manager not available');
+        return null;
+      }
+      if (!segmentId) {
+        console.error('❌ splitSegment(): No segment ID provided');
+        return null;
+      }
+      try {
+        var result = this.sceneViewer.managers.sceneOperationsManager.splitSegment(segmentId, this.sceneViewer.currentSceneData);
+        if (result) {
+          console.log('✅ splitSegment(): Segment split successfully');
+          return result;
+        } else {
+          console.warn('⚠️ splitSegment(): Split operation returned null');
+          return null;
+        }
+      } catch (error) {
+        console.error('❌ splitSegment(): Error splitting segment:', error);
+        return null;
+      }
+    }
+
     /**
      * Rotate a component by componentId
      * @param {string} componentId - The UUID of the component to rotate
@@ -1592,8 +1637,8 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "generatePath",
     value: function generatePath(fromConnectorId, toConnectorId) {
-      var _this$sceneViewer$man;
-      if (!this.sceneViewer || !((_this$sceneViewer$man = this.sceneViewer.managers) !== null && _this$sceneViewer$man !== void 0 && _this$sceneViewer$man.pathfinding)) {
+      var _this$sceneViewer$man2;
+      if (!this.sceneViewer || !((_this$sceneViewer$man2 = this.sceneViewer.managers) !== null && _this$sceneViewer$man2 !== void 0 && _this$sceneViewer$man2.pathfinding)) {
         return null;
       }
       try {