@2112-lab/central-plant 0.2.8 → 0.2.10

package/dist/esm/src/managers/pathfinding/PathRenderingManager.js

@@ -18,16 +18,58 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
       emissive: 0
     });
     _this.registerDisposable(_this._gatewayGeometry, _this._gatewayMaterial);
+
+    /**
+     * Map of pathId -> THREE.Material for per-path color control.
+     * pathId format: "${from}-->${to}"
+     * All segments within a path share the same material instance.
+     * @type {Map<string, THREE.Material>}
+     */
+    _this._pathMaterials = new Map();
     return _this;
   }
 
   /**
-   * Get path colors for visual distinction
-   * @param {number} index - Path index
-   * @returns {string} Hex color string
+   * Dispose all tracked per-path materials and clear the map.
+   * Called at the start of createPipePaths to clean up stale materials.
+   * @private
    */
   _inherits(PathRenderingManager, _BaseDisposable);
   return _createClass(PathRenderingManager, [{
+    key: "_clearPathMaterials",
+    value: function _clearPathMaterials() {
+      this._pathMaterials.forEach(function (mat) {
+        return mat.dispose();
+      });
+      this._pathMaterials.clear();
+    }
+
+    /**
+     * Update the color of all pipe segments belonging to a specific path.
+     * Operates on the shared per-path material — no scene traversal needed.
+     *
+     * @param {string} from - Source connector ID
+     * @param {string} to - Target connector ID
+     * @param {string|number} color - Any value accepted by THREE.Color.set()
+     */
+  }, {
+    key: "updatePathColor",
+    value: function updatePathColor(from, to, color) {
+      var pathId = "".concat(from, "-->").concat(to);
+      var mat = this._pathMaterials.get(pathId);
+      if (mat) {
+        mat.color.set(color);
+      } else {
+        console.warn("\u26A0\uFE0F PathRenderingManager.updatePathColor: no material found for path \"".concat(pathId, "\""));
+      }
+    }
+
+    /**
+     * Get path colors for visual distinction
+     * @param {number} index - Path index
+     * @returns {string} Hex color string
+     */
+  }, {
     key: "getPathColor",
     value: function getPathColor(index) {
       var colors = [
@@ -182,7 +224,11 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
       var globalSegmentIndex = maxExistingIndex + 1;
       console.log("\uD83D\uDD22 Starting segment index at ".concat(globalSegmentIndex, " (max existing: ").concat(maxExistingIndex, ")"));
       var pipeRadius = 0.1;
-      var pipeMaterial = this.createPipeMaterial(crosscubeTextureSet);
+      // Base material created once; per-path materials are cloned from it below.
+      var baseMaterial = this.createPipeMaterial(crosscubeTextureSet);
+
+      // Dispose previous path materials (they were attached to now-removed segments)
+      this._clearPathMaterials();
       paths.forEach(function (pathData, index) {
         if (pathData.path && pathData.path.length >= 2) {
           // Convert path points to Vector3 objects for consistent handling
@@ -199,6 +245,12 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             }
           });
 
+          // Create a per-path material clone so each path can have its color updated independently.
+          var pathId = "".concat(pathData.from, "-->").concat(pathData.to);
+          var perPathMaterial = baseMaterial.clone();
+          _this3._pathMaterials.set(pathId, perPathMaterial);
+          console.log("\uD83C\uDFA8 Created per-path material for \"".concat(pathId, "\""));
+
           // Check if endpoints are component connectors (from pathfinder result)
           var fromIsComponentConnector = pathData.fromObjectType === 'component-connector';
           var toIsComponentConnector = pathData.toObjectType === 'component-connector';
@@ -223,13 +275,13 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             var cylinderGeometry = new THREE.CylinderGeometry(pipeRadius, pipeRadius, length, 16, 1, false);
 
             // Determine material (debug red if rectified and in dev mode)
-            var materialToUse = pipeMaterial;
+            var materialToUse = perPathMaterial;
 
             // Check for dev mode (strict localhost only)
             var isDev = typeof window !== 'undefined' && (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1');
             if (isDev && pathData.rectifiedSegments && pathData.rectifiedSegments.includes(j)) {
-              // Create red debug material by cloning the pipe material to match the look
-              materialToUse = pipeMaterial.clone();
+              // Create red debug material by cloning the per-path material to match the look
+              materialToUse = perPathMaterial.clone();
               materialToUse.color.setHex(0xff0000);
               console.log("\uD83C\uDFA8 Coloring rectified segment ".concat(j, " red"));
             }
@@ -291,7 +343,7 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             sceneViewer.scene.add(cylinder);
 
             // Add smooth elbow joints only at actual direction changes (not at every point)
-            _this3.createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, cylinder // Pass the segment so elbow can be added as a child
+            _this3.createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, perPathMaterial, pathData, index, cylinder // Pass the segment so elbow can be added as a child
             );
           }
         }
@@ -396,6 +448,9 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
     value: function dispose() {
       console.log('🗑️ Disposing PathRenderingManager...');
 
+      // Dispose per-path materials
+      this._clearPathMaterials();
+
       // Call parent dispose to clean up registered resources (shared gateway geometry/material)
       _superPropGet(PathRenderingManager, "dispose", this, 3)([]);
 

package/dist/esm/src/managers/pathfinding/pathfindingManager.js

@@ -1,4 +1,4 @@
-import { inherits as _inherits, createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, objectSpread2 as _objectSpread2, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, toConsumableArray as _toConsumableArray, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, slicedToArray as _slicedToArray } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { inherits as _inherits, createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, objectSpread2 as _objectSpread2, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, toConsumableArray as _toConsumableArray, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, slicedToArray as _slicedToArray, typeof as _typeof } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
 import { Pathfinder } from '@2112-lab/pathfinder';
 import { BaseDisposable } from '../../core/baseDisposable.js';
@@ -386,7 +386,11 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "_executePathfinding",
     value: (function () {
       var _executePathfinding2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(sceneData, connections) {
-        var _sceneDataCopy$childr, _sceneDataCopy$childr2, _pathfindingResult$pa, _pathfindingResult$pa2;
+        var _this4 = this,
+          _sceneDataCopy$childr,
+          _sceneDataCopy$childr2,
+          _pathfindingResult$pa,
+          _pathfindingResult$pa2;
         var options,
           _options$context,
           context,
@@ -447,6 +451,15 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
 
               // Create pipe paths with materials using the paths from pathfinder
               this.renderingManager.createPipePaths(pathfindingResult.paths, this.crosscubeTextureSet);
+
+              // ── Stage 3b: Ensure PathData entries exist for all rendered paths ──────
+              // This preserves any flowAttributes already set on existing entries.
+              if (pathfindingResult.paths) {
+                pathfindingResult.paths.forEach(function (path) {
+                  var pathId = "".concat(path.from, "-->").concat(path.to);
+                  _this4._getOrCreatePathData(pathId, path.from, path.to);
+                });
+              }
               timers.pathRendering = performance.now() - renderStart;
 
               // ── Performance Summary ────────────────────────────────────────────
@@ -484,6 +497,26 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
       return this.sceneDataManager.getSimplifiedSceneData();
     }
 
+    /**
+     * Return an existing PathData for pathId from the store, or create and register a new one.
+     * Preserves existing flowAttributes when the entry already exists.
+     *
+     * @param {string} pathId - Canonical path identifier "${from}-->${to}"
+     * @param {string} from - Source connector ID
+     * @param {string} to - Target connector ID
+     * @returns {PathData}
+     * @private
+     */
+  }, {
+    key: "_getOrCreatePathData",
+    value: function _getOrCreatePathData(pathId, from, to) {
+      if (!this.pathDataStore.has(pathId)) {
+        var pd = new PathData(pathId, from, to);
+        this.pathDataStore.set(pathId, pd);
+      }
+      return this.pathDataStore.get(pathId);
+    }
+
     /**
      * Initialize pathfinder and create paths
      */
@@ -491,12 +524,33 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "initializePathfinder",
     value: (function () {
       var _initializePathfinder = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(data, crosscubeTextureSet) {
-        var pathfindingResult;
+        var _this5 = this,
+          _this$sceneViewer;
+        var pathfindingResult, originalToSubPaths, fromEndpointAttrs, flowMgr;
         return _regenerator().w(function (_context2) {
           while (1) switch (_context2.n) {
             case 0:
               this.crosscubeTextureSet = crosscubeTextureSet;
 
+              // ── Pre-load declared flowAttributes from connections JSON ─────────────
+              // This must happen before pathfinding so that PathData entries carrying
+              // flowAttributes are available for visualization right after rendering.
+              if (Array.isArray(data.connections)) {
+                data.connections.forEach(function (conn) {
+                  if (conn.flowAttributes && _typeof(conn.flowAttributes) === 'object') {
+                    var pathId = "".concat(conn.from, "-->").concat(conn.to);
+                    var pd = _this5._getOrCreatePathData(pathId, conn.from, conn.to);
+                    Object.entries(conn.flowAttributes).forEach(function (_ref) {
+                      var _ref2 = _slicedToArray(_ref, 2),
+                        key = _ref2[0],
+                        value = _ref2[1];
+                      pd.setFlowAttribute(key, value);
+                    });
+                    console.log("\uD83C\uDF0A Loaded flowAttributes for path \"".concat(pathId, "\":"), conn.flowAttributes);
+                  }
+                });
+              }
+
               // Use shared pathfinding logic with gateway creation enabled
               _context2.n = 1;
               return this._executePathfinding(data.scene, data.connections, {
@@ -505,6 +559,83 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               });
             case 1:
               pathfindingResult = _context2.v;
+              // ── Propagate flowAttributes to gateway-split rendered paths ──────────
+              // The pathfinder may split a connection A→B through gateway waypoints,
+              // producing sub-paths like A→G and G→B with different pathIds.
+              // We need to copy the original connection's flowAttributes onto every
+              // rendered sub-path entry in pathDataStore so the visualisation can
+              // find them by their rendered pathId.
+              if (Array.isArray(data.connections) && pathfindingResult) {
+                // Pass 1: use the explicit gateway connection mappings to get a precise
+                //         original→sub-path map.
+                originalToSubPaths = new Map(); // origPathId → Set<renderedPathId>
+                if (pathfindingResult.gateways) {
+                  pathfindingResult.gateways.forEach(function (gateway) {
+                    var _ref3 = gateway.connections || {},
+                      removed = _ref3.removed,
+                      added = _ref3.added;
+                    if (!(removed !== null && removed !== void 0 && removed.length) || !(added !== null && added !== void 0 && added.length)) return;
+                    removed.forEach(function (removedConn) {
+                      var origId = "".concat(removedConn.from, "-->").concat(removedConn.to);
+                      if (!originalToSubPaths.has(origId)) originalToSubPaths.set(origId, new Set());
+                      added.forEach(function (addedConn) {
+                        originalToSubPaths.get(origId).add("".concat(addedConn.from, "-->").concat(addedConn.to));
+                      });
+                    });
+                  });
+                }
+                data.connections.forEach(function (conn) {
+                  if (!conn.flowAttributes) return;
+                  var origId = "".concat(conn.from, "-->").concat(conn.to);
+                  var subPathIds = new Set(originalToSubPaths.get(origId) || []);
+                  subPathIds.add(origId); // include the direct path if it wasn't rewired
+
+                  subPathIds.forEach(function (subPathId) {
+                    var pd = _this5.pathDataStore.get(subPathId);
+                    if (pd && Object.keys(pd.flowAttributes).length === 0) {
+                      Object.entries(conn.flowAttributes).forEach(function (_ref4) {
+                        var _ref5 = _slicedToArray(_ref4, 2),
+                          key = _ref5[0],
+                          value = _ref5[1];
+                        pd.setFlowAttribute(key, value);
+                      });
+                      console.log("\uD83C\uDF0A Propagated flowAttributes to sub-path \"".concat(subPathId, "\" from \"").concat(origId, "\""));
+                    }
+                  });
+                });
+
+                // Pass 2: endpoint fallback for any rendered path still missing attributes
+                // (covers Gateway→Gateway intermediate segments not captured by gateway.connections.added)
+                fromEndpointAttrs = new Map(); // connectorId → flowAttributes
+                data.connections.forEach(function (conn) {
+                  if (conn.flowAttributes && !fromEndpointAttrs.has(conn.from)) {
+                    fromEndpointAttrs.set(conn.from, conn.flowAttributes);
+                  }
+                });
+                this.pathDataStore.forEach(function (pd, pathId) {
+                  if (Object.keys(pd.flowAttributes).length > 0) return;
+                  var sepIdx = pathId.indexOf('-->');
+                  if (sepIdx === -1) return;
+                  var from = pathId.slice(0, sepIdx);
+                  var attrs = fromEndpointAttrs.get(from);
+                  if (attrs) {
+                    Object.entries(attrs).forEach(function (_ref6) {
+                      var _ref7 = _slicedToArray(_ref6, 2),
+                        key = _ref7[0],
+                        value = _ref7[1];
+                      return pd.setFlowAttribute(key, value);
+                    });
+                    console.log("\uD83C\uDF0A Endpoint-matched flowAttributes for path \"".concat(pathId, "\""));
+                  }
+                });
+              }
+
+              // ── Apply flow visualizations now that paths are rendered ──────────────
+              flowMgr = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.pathFlowManager;
+              if (flowMgr) {
+                flowMgr.applyAllVisualizations();
+              }
+
               // Update connections with rewired connections
               if (pathfindingResult.rewiredConnections) {
                 // data.connections = pathfindingResult.rewiredConnections;

package/dist/index.d.ts

@@ -82,6 +82,62 @@ export interface IAssetService {
   removeComponentAttachment(options: { componentUuid: string; attachmentId: string }): Promise<SmartComponentAsset>
 }
 
+// ─── Flow attribute types ─────────────────────────────────────────────────────
+
+/** The canonical set of flow-related attribute keys for a path. */
+export declare const FLOW_ATTRIBUTE_KEYS: ['flowDirection', 'flowSpeed', 'flowTemperature', 'flowMaterial']
+
+/** Union type of all valid flow attribute keys. */
+export type FlowAttributeKey = 'flowDirection' | 'flowSpeed' | 'flowTemperature' | 'flowMaterial'
+
+/** Resolved values for all four flow attributes on a path (null = unset). */
+export interface ResolvedFlowAttributes {
+  flowDirection: any | null
+  flowSpeed: any | null
+  flowTemperature: any | null
+  flowMaterial: any | null
+}
+
+/**
+ * Manages flow-related attributes (flowDirection, flowSpeed, flowTemperature,
+ * flowMaterial) for rendered paths at the central-plant level.
+ *
+ * Two layers:
+ *   - Declared  — persisted in PathData.flowAttributes, serialised with the scene
+ *   - Derived   — ephemeral runtime overrides (e.g. driven by I/O device state)
+ *
+ * Resolution: derived > declared > null
+ */
+export declare class PathFlowManager {
+  constructor(sceneViewer: object)
+
+  /** Set a declared (persistent) flow attribute on a path. */
+  setDeclared(pathId: string, key: FlowAttributeKey, value: any): void
+
+  /** Set a derived (runtime) flow attribute on a path. */
+  setDerived(pathId: string, key: FlowAttributeKey, value: any): void
+
+  /**
+   * Clear derived overrides for one path or all paths.
+   * @param pathId - Omit to reset all paths.
+   */
+  resetDerived(pathId?: string): void
+
+  /** Resolve the effective value of a single attribute (derived > declared > null). */
+  resolve(pathId: string, key: FlowAttributeKey): any | null
+
+  /** Resolve all four flow attributes for a path. */
+  resolveAll(pathId: string): ResolvedFlowAttributes
+
+  /** Apply temperature-based colour to the pipe material of a single path. */
+  applyVisualizationForPath(pathId: string): void
+
+  /** Apply temperature-based colour to every known path. */
+  applyAllVisualizations(): void
+
+  dispose(): void
+}
+
 // ─── Re-exports ───────────────────────────────────────────────────────────────
 export { CentralPlant } from './core/centralPlant.js';
 export { DebugLogger, logger, transformLogger, pathfinderLogger, modelLogger } from './core/debugLogger.js';

package/package.json

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