@2112-lab/central-plant 0.2.10 → 0.3.0

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, typeof as _typeof } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { inherits as _inherits, createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, objectSpread2 as _objectSpread2, slicedToArray as _slicedToArray, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, toConsumableArray as _toConsumableArray, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, typeof as _typeof } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
 import { Pathfinder } from '@2112-lab/pathfinder';
 import { BaseDisposable } from '../../core/baseDisposable.js';
@@ -517,6 +517,103 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
       return this.pathDataStore.get(pathId);
     }
 
+    /**
+     * Propagate flowAttributes from the original connection list to any gateway-split
+     * rendered sub-paths in pathDataStore, then apply all flow visualizations.
+     * Called after every pathfinding execution (initial load and transform updates).
+     *
+     * @param {Array} connections - Original connections array (may include flowAttributes)
+     * @param {object} pathfindingResult - Result returned by _executePathfinding
+     * @private
+     */
+  }, {
+    key: "_propagateFlowAttributesAndApplyVisualizations",
+    value: function _propagateFlowAttributesAndApplyVisualizations(connections, pathfindingResult) {
+      var _this5 = this,
+        _this$sceneViewer;
+      if (!Array.isArray(connections) || !pathfindingResult) return;
+
+      // Pass 1: use the explicit gateway connection mappings to build a precise
+      //         original-pathId → Set<renderedPathId> map.
+      var originalToSubPaths = new Map();
+      if (pathfindingResult.gateways) {
+        pathfindingResult.gateways.forEach(function (gateway) {
+          var _ref = gateway.connections || {},
+            removed = _ref.removed,
+            added = _ref.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));
+            });
+          });
+        });
+      }
+      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);
+        subPathIds.forEach(function (subPathId) {
+          var pd = _this5.pathDataStore.get(subPathId);
+          if (pd && Object.keys(pd.flowAttributes).length === 0) {
+            Object.entries(conn.flowAttributes).forEach(function (_ref2) {
+              var _ref3 = _slicedToArray(_ref2, 2),
+                key = _ref3[0],
+                value = _ref3[1];
+              return pd.setFlowAttribute(key, value);
+            });
+          }
+        });
+      });
+
+      // Pass 2: endpoint fallback for Gateway→Gateway intermediate segments and
+      // for paths whose connections were restructured by manualizeSegment/manualizeGateway.
+      // After manualization, currentSceneData.connections no longer contains the original
+      // A→B entry with flowAttributes (it's been split into new sub-connections), so we
+      // seed the endpoint maps from both the connections array AND from existing pathDataStore
+      // entries that already carry flowAttributes — those persist across re-executions.
+      var fromEndpointAttrs = new Map();
+      var toEndpointAttrs = new Map();
+
+      // Seed from persisted pathDataStore entries first (covers post-manualization re-runs)
+      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 to = pathId.slice(sepIdx + 3);
+        if (!fromEndpointAttrs.has(from)) fromEndpointAttrs.set(from, pd.flowAttributes);
+        if (!toEndpointAttrs.has(to)) toEndpointAttrs.set(to, pd.flowAttributes);
+      });
+
+      // Also seed from connections array (covers initial load before pathDataStore has any attrs)
+      connections.forEach(function (conn) {
+        if (!conn.flowAttributes) return;
+        if (!fromEndpointAttrs.has(conn.from)) fromEndpointAttrs.set(conn.from, conn.flowAttributes);
+        if (!toEndpointAttrs.has(conn.to)) toEndpointAttrs.set(conn.to, 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 to = pathId.slice(sepIdx + 3);
+        var attrs = fromEndpointAttrs.get(from) || toEndpointAttrs.get(to);
+        if (attrs) Object.entries(attrs).forEach(function (_ref4) {
+          var _ref5 = _slicedToArray(_ref4, 2),
+            key = _ref5[0],
+            value = _ref5[1];
+          return pd.setFlowAttribute(key, value);
+        });
+      });
+
+      // Apply visualizations
+      (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.pathFlowManager) === null || _this$sceneViewer === void 0 || _this$sceneViewer.applyAllVisualizations();
+    }
+
     /**
      * Initialize pathfinder and create paths
      */
@@ -524,9 +621,8 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "initializePathfinder",
     value: (function () {
       var _initializePathfinder = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(data, crosscubeTextureSet) {
-        var _this5 = this,
-          _this$sceneViewer;
-        var pathfindingResult, originalToSubPaths, fromEndpointAttrs, flowMgr;
+        var _this6 = this;
+        var pathfindingResult;
         return _regenerator().w(function (_context2) {
           while (1) switch (_context2.n) {
             case 0:
@@ -539,11 +635,11 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
                 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];
+                    var pd = _this6._getOrCreatePathData(pathId, conn.from, conn.to);
+                    Object.entries(conn.flowAttributes).forEach(function (_ref6) {
+                      var _ref7 = _slicedToArray(_ref6, 2),
+                        key = _ref7[0],
+                        value = _ref7[1];
                       pd.setFlowAttribute(key, value);
                     });
                     console.log("\uD83C\uDF0A Loaded flowAttributes for path \"".concat(pathId, "\":"), conn.flowAttributes);
@@ -559,82 +655,7 @@ 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();
-              }
+              this._propagateFlowAttributesAndApplyVisualizations(data.connections, pathfindingResult);
 
               // Update connections with rewired connections
               if (pathfindingResult.rewiredConnections) {
@@ -760,6 +781,9 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               });
             case 2:
               result = _context3.v;
+              // Re-apply flow attribute colors (new materials are created on each execution)
+              this._propagateFlowAttributesAndApplyVisualizations(currentSceneData.connections, result);
+
               // Cache fingerprint + result for next comparison
               this._lastPathfindingFingerprint = fingerprint;
               this._lastPathfindingResult = result;

package/dist/esm/src/managers/scene/sceneOperationsManager.js

@@ -1747,7 +1747,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       if (typeof window !== 'undefined') {
         isDev = window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1';
       }
-      if (isDev && segment.material) {
+      if (isDev && process.env.DISABLE_MANUALIZED_SEGMENT_COLORING !== 'true' && segment.material) {
         segment.material.color.setHex(0x0000ff); // Blue
         console.log('🎨 Set manual segment material color to blue (dev mode)');
       }
@@ -1778,7 +1778,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       console.log('🔌 Created connectors:', connectors);
 
       // In dev mode, enlarge connectors by 1.5x and turn them red
-      if (isDev) {
+      if (isDev && process.env.DISABLE_MANUALIZED_SEGMENT_COLORING !== 'true') {
         connectors.forEach(function (connector) {
           if (connector) {
             connector.scale.set(1.25, 1.25, 1.25);

package/dist/index.d.ts

@@ -184,3 +184,122 @@ export * as Numerics from './data/numerics.js';
 // Analysis utilities
 export * as Analysis from './analysis/analysis.js';
 export * as Testing from './analysis/testing.js';
+
+// ─── Cache management ─────────────────────────────────────────────────────────
+
+export interface CacheExpiryConfig {
+  MODELS: number
+  TEXTURES: number
+  JSON: number
+  COMPONENT_DICTIONARY: number
+  SCENE_DATA: number
+  THUMBNAILS: number
+  SKYBOXES: number
+  USER_CONTENT: number
+  TEMPORARY: number
+  DEFAULT: number
+}
+
+export declare const CACHE_EXPIRY: CacheExpiryConfig
+export declare const CACHE_NAME_PREFIX: string
+export declare const GLOBAL_CACHE_NAME: string
+
+export interface CacheStatsItem {
+  url: string
+  sourceKey?: string
+  s3Key?: string
+  size: number
+  sizeMB: string
+  type: string
+  cachedTime: number
+  age: number
+  isLocal?: boolean
+}
+
+export interface CacheStatsResult {
+  count: number
+  totalSize: number
+  totalSizeMB: string
+  items: CacheStatsItem[]
+}
+
+export interface CacheGlobalStats {
+  hits: number
+  misses: number
+  errors: number
+  totalBytesServed: number
+  totalBytesCached: number
+  startTime: number
+  hitRate: string
+  totalMBServed: string
+  totalMBCached: string
+  uptimeMinutes: string
+}
+
+export declare class CacheManager {
+  stats: { hits: number; misses: number; errors: number; totalBytesServed: number; totalBytesCached: number; startTime: number }
+  configure(options: { getUser?: () => Promise<any>; onError?: (error: Error) => void }): void
+  getExpiryForPath(path: string, assetType?: string | null): number
+  resetIdentity(): void
+  getCacheName(): Promise<string>
+  execute(options: { cacheKey: string; sourceKey?: string; expiryMs: number; fetcher: () => Promise<any>; processor: (response: any) => Promise<any>; metadata?: Record<string, string>; logType?: string }): Promise<any>
+  getGlobalStats(): CacheGlobalStats
+  resetStats(): void
+  clearCache(specificKey?: string | null, clearAllUsers?: boolean): Promise<boolean>
+  cleanExpired(): Promise<number>
+  cleanInvalid(): Promise<number>
+  has(cacheKey: string, expiryMs?: number | null): Promise<boolean>
+  get(cacheKey: string, expiryMs?: number | null, processor?: (response: Response) => Promise<any>): Promise<any>
+  delete(cacheKey: string): Promise<boolean>
+  deleteCache(cacheName: string): Promise<boolean>
+  getDetailedStats(allUsers?: boolean): Promise<CacheStatsResult | { caches: any[]; totalCaches: number; grandTotalSizeMB: string }>
+}
+
+export declare const cacheManager: CacheManager
+
+export declare function resetCacheIdentity(): void
+export declare function getGlobalCacheStats(): CacheGlobalStats
+export declare function resetGlobalCacheStats(): void
+export declare function getCurrentCacheName(): Promise<string>
+export declare function cleanExpiredCache(): Promise<number>
+export declare function cleanInvalidCacheEntries(): Promise<number>
+export declare function getCacheStats(allUsers?: boolean): Promise<CacheStatsResult>
+export declare function getUserOnlyCacheStats(allUsers?: boolean): Promise<CacheStatsResult>
+export declare function getGlobalOnlyCacheStats(): Promise<CacheStatsResult>
+export declare function clearS3Cache(specificKey?: string | null, clearAllUsers?: boolean): Promise<boolean>
+export declare function getAllCacheKeys(): Promise<Set<string>>
+export declare function switchCachePartition(isAuthenticated: boolean): Promise<{ oldCacheName: string; newCacheName: string; deletedPartition: string | null; deleted: boolean } | { error: string }>
+
+export declare function getCachedS3Object(s3Key: string, storageOptions?: Record<string, any>, expiryMs?: number | null): Promise<Blob>
+export declare function getCachedS3ObjectURL(s3Key: string, storageOptions?: Record<string, any>, expiryMs?: number | null): Promise<string>
+export declare function preloadS3Objects(s3Keys: string[], storageOptions?: Record<string, any>): Promise<{ success: number; failed: number; errors: Array<{ key: string; error: string }> }>
+export declare function getCachedS3Json(s3Key: string, storageOptions?: Record<string, any>, expiryMs?: number | null): Promise<any>
+export declare function getCachedLocalJson(localPath: string, expiryMs?: number | null): Promise<any>
+export declare function getCachedLocalFile(url: string, expiryMs?: number | null): Promise<Blob>
+export declare function getCachedLocalFileURL(url: string, expiryMs?: number | null): Promise<string>
+export declare function preloadLocalFiles(urls: string[]): Promise<{ success: number; failed: number; errors: Array<{ url: string; error: string }> }>
+
+export declare function cacheJsonData(key: string, data: any, expiryMs?: number): Promise<boolean>
+export declare function getCachedJsonData(key: string, expiryMs?: number): Promise<any>
+export declare function removeCachedJsonData(key: string): Promise<boolean>
+
+export declare function getThumbnailKey(asset: { thumbnailS3Path?: string; s3Path?: string; uuid?: string; id?: string }): string | null
+export declare function isThumbnailCached(asset: { isS3Component?: boolean; source?: string; scope?: string; thumbnailS3Path?: string; s3Path?: string; uuid?: string; id?: string }): Promise<boolean>
+export declare function isCached(s3Key: string, expiryMs?: number | null): Promise<boolean>
+export declare function getCacheExpiryForPath(path: string, assetType?: string | null): number
+export declare function formatCacheExpiry(ms: number): string
+
+export declare class S3MetadataCacheService {
+  getAll(): Promise<any[]>
+  getMetadata(): Promise<{ version: number; components: any[]; timestamp: number }>
+  addComponent(component: { id?: string; uuid?: string; [key: string]: any }): Promise<boolean>
+  removeComponent(identifier: string): Promise<boolean>
+  clear(): Promise<boolean>
+  hasComponent(identifier: string): Promise<boolean>
+  refresh(): Promise<any[]>
+  setAll(components: any[]): Promise<boolean>
+}
+
+export declare const s3MetadataCache: S3MetadataCacheService
+
+export declare function measureS3Transfer(operation: string, asyncFn: () => Promise<any>, fileSize?: number | null): Promise<any>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2112-lab/central-plant",
-  "version": "0.2.10",
+  "version": "0.3.0",
   "description": "Utility modules for the Central Plant Application",
   "main": "dist/bundle/index.js",
   "module": "dist/esm/src/index.js",
@@ -32,6 +32,7 @@
   "license": "MIT",
   "dependencies": {
     "@2112-lab/pathfinder": "^1.0.38",
+    "aws-amplify": "^5.3.33",
     "stats.js": "^0.17.0",
     "three": "^0.177.0"
   },