@2112-lab/central-plant 0.1.1 → 0.1.2

package/dist/cjs/src/index.js

@@ -9,50 +9,15 @@ var disposalManager = require('./disposalManager.js');
 var environmentManager = require('./environmentManager.js');
 var hotReloadManager = require('./hotReloadManager.js');
 var keyboardControlsManager = require('./keyboardControlsManager.js');
-var modelPreloader$1 = require('./modelPreloader.js');
 var nameUtils = require('./nameUtils.js');
 var pathfindingManager = require('./pathfindingManager.js');
 var performanceMonitor = require('./performanceMonitor.js');
 var sceneExportManager = require('./sceneExportManager.js');
 var sceneInitializationManager = require('./sceneInitializationManager.js');
-var sceneOperationsManager = require('./sceneOperationsManager.js');
 var textureConfig = require('./textureConfig.js');
 var transformControlsManager = require('./transformControlsManager.js');
-var Pathfinder = require('./Pathfinder.js');
-var ConnectionManager = require('./ConnectionManager.js');
 
-/**
- * @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');
- */
-// Use the explicit modelPreloader object as the named export
-var modelPreloader = modelPreloader$1.modelPreloader;
+// Import all utility modules
 
 /**
  * Central API object that provides access to all utility modules
@@ -64,17 +29,13 @@ var modelPreloader = modelPreloader$1.modelPreloader;
  * @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,
@@ -84,17 +45,13 @@ var CentralPlantUtils = {
   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
+  transformControls: transformControlsManager
 };
 
 exports.animationManager = animationManager;
@@ -113,16 +70,10 @@ exports.generateUuidFromName = nameUtils.generateUuidFromName;
 exports.getHardcodedUuid = nameUtils.getHardcodedUuid;
 exports.nameUtils = nameUtils;
 exports.pathfindingManager = pathfindingManager;
-exports.performanceMonitor = performanceMonitor;
 exports.getSceneExportManager = sceneExportManager.getSceneExportManager;
 exports.sceneExportManager = sceneExportManager;
 exports.sceneInitializationManager = sceneInitializationManager;
-exports.getSceneOperationsManager = sceneOperationsManager.getSceneOperationsManager;
-exports.sceneOperationsManager = sceneOperationsManager;
 exports.textureConfig = textureConfig;
 exports.getTransformControlsManager = transformControlsManager.getTransformControlsManager;
 exports.transformControlsManager = transformControlsManager;
-exports.Pathfinder = Pathfinder;
-exports.ConnectionManager = ConnectionManager;
 exports["default"] = CentralPlantUtils;
-exports.modelPreloader = modelPreloader;

package/dist/cjs/src/pathfindingManager.js

@@ -4,8 +4,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
 var THREE = require('three');
-var Pathfinder = require('./Pathfinder.js');
+var index_esm = require('../node_modules/@2112-lab/pathfinder/dist/index.esm.js');
 var debugLogger = require('./debugLogger.js');
+var nameUtils = require('./nameUtils.js');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -31,11 +32,9 @@ var PathfindingManager = /*#__PURE__*/function () {
   function PathfindingManager(component) {
     _rollupPluginBabelHelpers.classCallCheck(this, PathfindingManager);
     this.component = component;
+    this.pathfinder = null;
     this.crosscubeTextureSet = null;
     this.pathfinderVersionInfo = null;
-
-    // Initialize pathfinder
-    this.pathfinder = new Pathfinder["default"](component === null || component === void 0 ? void 0 : component.sceneData);
   }
 
   /**
@@ -137,41 +136,27 @@ var PathfindingManager = /*#__PURE__*/function () {
         return _rollupPluginBabelHelpers.regenerator().w(function (_context3) {
           while (1) switch (_context3.n) {
             case 0:
-              if (Pathfinder["default"]) {
-                _context3.n = 1;
-                break;
-              }
-              _context3.n = 1;
-              return importPathfinder();
-            case 1:
               component = this.component;
               this.crosscubeTextureSet = crosscubeTextureSet;
 
               // Log pathfinder version information
-              _context3.n = 2;
+              _context3.n = 1;
               return this.logPathfinderVersion('Scene Loading');
-            case 2:
-              this.pathfinder = new Pathfinder["default"](data);
-              if (component) component.pathfinder = this.pathfinder;
+            case 1:
+              this.pathfinder = new index_esm.Pathfinder(data);
+              component.pathfinder = this.pathfinder;
 
               // Add debugging for pathfinder input
               console.log('🔍 PATHFINDER DEBUGGING:');
               console.log('🔗 Connections:', data.connections);
               console.log('🏗️ Scene structure:', JSON.parse(JSON.stringify((_data$scene = data.scene) === null || _data$scene === void 0 ? void 0 : _data$scene.object)));
-
-              // Ensure connections exist before finding paths
-              if (!(!data.connections || !Array.isArray(data.connections))) {
-                _context3.n = 3;
-                break;
-              }
-              console.warn('⚠️ No connections found in scene data, skipping path finding');
-              return _context3.a(2, []);
-            case 3:
               paths = this.pathfinder.findPaths();
               console.log('Found paths:', paths);
 
               // Create pipe paths with materials
-              return _context3.a(2, this.createPipePaths(paths, crosscubeTextureSet));
+              this.createPipePaths(paths, crosscubeTextureSet);
+            case 2:
+              return _context3.a(2);
           }
         }, _callee3, this);
       }));
@@ -181,6 +166,7 @@ var PathfindingManager = /*#__PURE__*/function () {
       return initializePathfinder;
     }()
     /**
+       /**
      * Remove all existing paths from the scene
      */
     )
@@ -188,38 +174,30 @@ var PathfindingManager = /*#__PURE__*/function () {
     key: "removeAllPaths",
     value: function removeAllPaths() {
       var component = this.component;
-      if (!component || !component.scene) {
-        return;
-      }
       console.log("removeAllPaths started");
       var objectsToRemove = [];
-
-      // Find all path objects in the scene
-      component.scene.traverse(function (child) {
-        if (child.userData && child.userData.isPathObject) {
-          objectsToRemove.push(child);
+      component.scene.traverse(function (obj) {
+        // Check the name property instead of uuid, as UUIDs are auto-generated
+        if (obj.name && obj.name.includes("Polyline")) {
+          console.log("removeAllPaths ".concat(obj.name, " (uuid: ").concat(obj.uuid, ") found"));
+          objectsToRemove.push(obj);
         }
       });
-
-      // Remove all found path objects
-      objectsToRemove.forEach(function (object) {
-        object.parent.remove(object);
-
-        // Dispose of geometries and materials
-        if (object.geometry) {
-          object.geometry.dispose();
-        }
-        if (object.material) {
-          if (Array.isArray(object.material)) {
-            object.material.forEach(function (material) {
-              return material.dispose();
+      for (var _i = 0, _objectsToRemove = objectsToRemove; _i < _objectsToRemove.length; _i++) {
+        var obj = _objectsToRemove[_i];
+        component.scene.remove(obj);
+        if (obj.geometry) obj.geometry.dispose();
+        if (obj.material) {
+          if (Array.isArray(obj.material)) {
+            obj.material.forEach(function (mat) {
+              return mat.dispose();
             });
           } else {
-            object.material.dispose();
+            obj.material.dispose();
           }
         }
-      });
-      console.log("Removed ".concat(objectsToRemove.length, " path objects"));
+      }
+      console.log("\u2705 Removed ".concat(objectsToRemove.length, " polyline objects from scene"));
     }
 
     /**
@@ -228,14 +206,44 @@ var PathfindingManager = /*#__PURE__*/function () {
   }, {
     key: "createPipeMaterial",
     value: function createPipeMaterial(crosscubeTextureSet, pathIndex) {
-      var color = this.getPathColor(pathIndex);
-      var material = new THREE__namespace.MeshStandardMaterial({
-        color: new THREE__namespace.Color(color),
-        roughness: 0.3,
-        metalness: 0.8,
-        envMap: crosscubeTextureSet ? crosscubeTextureSet.envMap : null
-      });
-      return material;
+      if (crosscubeTextureSet) {
+        var materialProps = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, crosscubeTextureSet.config.materialProps), {}, {
+          color: this.getPathColor(pathIndex),
+          map: crosscubeTextureSet.textures.diffuse,
+          normalMap: crosscubeTextureSet.textures.normal,
+          roughnessMap: crosscubeTextureSet.textures.roughness,
+          metalness: 0.2,
+          roughness: 0.9,
+          clearcoat: 0.2,
+          clearcoatRoughness: 0.2,
+          envMapIntensity: 0.6,
+          reflectivity: 0.4
+        });
+
+        // Handle normalScale conversion to Vector2
+        if (materialProps.normalScale && Array.isArray(materialProps.normalScale)) {
+          materialProps.normalScale = _rollupPluginBabelHelpers.construct(THREE__namespace.Vector2, _rollupPluginBabelHelpers.toConsumableArray(materialProps.normalScale));
+        }
+        var material = new THREE__namespace.MeshPhysicalMaterial(materialProps);
+
+        // Configure texture wrapping and repeat
+        var pipeTextures = [material.map, material.normalMap, material.roughnessMap].filter(Boolean);
+        pipeTextures.forEach(function (texture) {
+          texture.wrapS = texture.wrapT = THREE__namespace.RepeatWrapping;
+          texture.repeat.set(crosscubeTextureSet.config.repeat.x * 2, crosscubeTextureSet.config.repeat.y * 2);
+        });
+        return material;
+      } else {
+        return new THREE__namespace.MeshPhysicalMaterial({
+          color: this.getPathColor(pathIndex),
+          metalness: 0.9,
+          roughness: 0.7,
+          clearcoat: 0.1,
+          clearcoatRoughness: 0.3,
+          envMapIntensity: 1.5,
+          reflectivity: 0.3
+        });
+      }
     }
 
     /**
@@ -246,76 +254,250 @@ var PathfindingManager = /*#__PURE__*/function () {
     value: function createPipePaths(paths, crosscubeTextureSet) {
       var _this = this;
       var component = this.component;
-      if (!component || !component.scene) {
-        console.warn('Cannot create pipe paths: component or scene not available');
-        return [];
-      }
+      paths.forEach(function (pathData, index) {
+        if (pathData.path) {
+          var polyline = new THREE__namespace.Object3D();
+          polyline.name = "Polyline ".concat(pathData.from, "-").concat(pathData.to);
+          var pipeRadius = 0.1;
+          var pipeMaterial = _this.createPipeMaterial(crosscubeTextureSet, index);
+          for (var j = 0; j < pathData.path.length - 1; j++) {
+            var start = pathData.path[j];
+            var end = pathData.path[j + 1];
+            var direction = new THREE__namespace.Vector3().subVectors(end, start);
+            var length = direction.length();
+            var cylinderGeometry = new THREE__namespace.CylinderGeometry(pipeRadius, pipeRadius, length, 8, 1, false);
+            var cylinder = new THREE__namespace.Mesh(cylinderGeometry, pipeMaterial);
+            cylinder.position.copy(start).add(end).multiplyScalar(0.5);
+            var quaternion = new THREE__namespace.Quaternion();
+            var up = new THREE__namespace.Vector3(0, 1, 0);
+            quaternion.setFromUnitVectors(up, direction.normalize());
+            cylinder.quaternion.copy(quaternion);
+            cylinder.castShadow = true;
+            cylinder.receiveShadow = true;
+            polyline.add(cylinder);
 
-      // Remove existing paths before creating new ones
-      this.removeAllPaths();
-      var pipeObjects = [];
-      paths.forEach(function (path, pathIndex) {
-        if (!path || !path.points || path.points.length < 2) {
-          console.warn('Invalid path data, skipping:', path);
-          return;
+            // Add junction spheres at 90-degree turns
+            if (j < pathData.path.length - 2) {
+              var nextStart = pathData.path[j + 1];
+              var nextEnd = pathData.path[j + 2];
+              var currentDir = direction.normalize();
+              var nextDir = new THREE__namespace.Vector3().subVectors(nextEnd, nextStart).normalize();
+              var angle = Math.acos(currentDir.dot(nextDir));
+              if (Math.abs(angle - Math.PI / 2) < 0.1) {
+                var sphereGeometry = new THREE__namespace.SphereGeometry(pipeRadius, 16, 16);
+                var sphere = new THREE__namespace.Mesh(sphereGeometry, pipeMaterial);
+                sphere.position.copy(end);
+                sphere.castShadow = true;
+                sphere.receiveShadow = true;
+                polyline.add(sphere);
+              }
+            }
+          }
+          polyline.name = "Polyline";
+          component.scene.add(polyline);
         }
-        try {
-          var material = _this.createPipeMaterial(crosscubeTextureSet, pathIndex);
+      });
+    }
 
-          // Create a path from the points
-          var points = path.points.map(function (point) {
-            return new THREE__namespace.Vector3(point.x, point.y, point.z);
-          });
-          var curve = new THREE__namespace.CatmullRomCurve3(points);
+    /**
+     * Recompute world bounding boxes after transforms
+     */
+  }, {
+    key: "recomputeWorldBoundingBoxes",
+    value: function recomputeWorldBoundingBoxes(currentSceneData) {
+      var component = this.component;
+      component.scene.traverse(function (object) {
+        if (object.isMesh) {
+          // Find the corresponding JSON object
+          var jsonObject = null;
+          var _findJsonObject = function findJsonObject(children) {
+            var _iterator = _rollupPluginBabelHelpers.createForOfIteratorHelper(children),
+              _step;
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var _object$userData, _child$userData;
+                var child = _step.value;
+                // Enhanced matching logic with hardcoded UUID priority
 
-          // Create the pipe geometry
-          var pipeRadius = 0.15;
-          var radialSegments = 8;
-          var tubularSegments = points.length * 3;
-          var geometry = new THREE__namespace.TubeGeometry(curve, tubularSegments, pipeRadius, radialSegments, false);
+                // Strategy 1: Direct hardcoded UUID match (HIGHEST PRIORITY)
+                if (child.uuid === object.uuid || child.uuid === ((_object$userData = object.userData) === null || _object$userData === void 0 ? void 0 : _object$userData.originalUuid) || object.uuid === ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.originalUuid)) {
+                  return child;
+                }
 
-          // Create the mesh
-          var pipe = new THREE__namespace.Mesh(geometry, material);
+                // Strategy 2: Name-based UUID match (FALLBACK)
+                if (object.name && child.name) {
+                  var objectGeneratedUuid = nameUtils.generateUuidFromName(object.name);
+                  var childGeneratedUuid = nameUtils.generateUuidFromName(child.name);
+                  if (objectGeneratedUuid === childGeneratedUuid || objectGeneratedUuid === child.uuid || childGeneratedUuid === object.uuid) {
+                    return child;
+                  }
+                }
 
-          // Add metadata
-          pipe.userData = {
-            isPathObject: true,
-            pathIndex: pathIndex,
-            connectionId: path.connectionId,
-            startComponentId: path.startComponentId,
-            endComponentId: path.endComponentId
+                // Strategy 3: Name match
+                if (object.name && child.name && object.name === child.name) {
+                  return child;
+                }
+
+                // Recursively search children
+                if (child.children) {
+                  console.log("child children found in:", child);
+                  var found = _findJsonObject(child.children);
+                  if (found) return found;
+                }
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+            return null;
           };
+          jsonObject = _findJsonObject(currentSceneData.scene.object.children);
+          if (jsonObject) {
+            // Compute world bounding box
+            var boundingBox = new THREE__namespace.Box3().setFromObject(object);
 
-          // Add to scene
-          component.scene.add(pipe);
-          pipeObjects.push(pipe);
-        } catch (error) {
-          console.error('Error creating pipe for path:', path, error);
+            // Store in JSON userData for pathfinder
+            if (!jsonObject.userData) jsonObject.userData = {};
+            jsonObject.userData.worldBoundingBox = {
+              min: boundingBox.min.toArray(),
+              max: boundingBox.max.toArray()
+            };
+            console.log("Added world bounding box for ".concat(jsonObject.name, ":"), jsonObject.userData.worldBoundingBox);
+          }
         }
       });
-      return pipeObjects;
     }
-  }]);
-}();
+    /**
+     * Update pathfinding with new connections data
+     */
+  }, {
+    key: "updatePathfindingWithConnections",
+    value: (function () {
+      var _updatePathfindingWithConnections = _rollupPluginBabelHelpers.asyncToGenerator(/*#__PURE__*/_rollupPluginBabelHelpers.regenerator().m(function _callee4(newConnections) {
+        var _component$currentSce, _component$currentSce2, _component$currentSce3, _updatedSceneData$sce;
+        var component, updatedSceneData, paths;
+        return _rollupPluginBabelHelpers.regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              component = this.component; // Check if we have current scene data to work with
+              if (component.currentSceneData) {
+                _context4.n = 1;
+                break;
+              }
+              console.warn('⚠️ No current scene data available for pathfinder update');
+              return _context4.a(2, false);
+            case 1:
+              // Remove all existing paths from the scene
+              this.removeAllPaths();
+              console.log('🔄 Updating pathfinder with new connections:', newConnections);
+              console.log('🔍 Current scene data structure:', {
+                hasConnections: !!component.currentSceneData.connections,
+                connectionsCount: ((_component$currentSce = component.currentSceneData.connections) === null || _component$currentSce === void 0 ? void 0 : _component$currentSce.length) || 0,
+                hasScene: !!component.currentSceneData.scene,
+                hasSceneObject: !!((_component$currentSce2 = component.currentSceneData.scene) !== null && _component$currentSce2 !== void 0 && _component$currentSce2.object),
+                childrenCount: ((_component$currentSce3 = component.currentSceneData.scene) === null || _component$currentSce3 === void 0 || (_component$currentSce3 = _component$currentSce3.object) === null || _component$currentSce3 === void 0 || (_component$currentSce3 = _component$currentSce3.children) === null || _component$currentSce3 === void 0 ? void 0 : _component$currentSce3.length) || 0
+              });
 
-// Create a singleton instance
-var pathfindingManager = null;
+              // Create a deep copy of the current scene data to avoid mutations
+              updatedSceneData = JSON.parse(JSON.stringify(component.currentSceneData)); // Update the connections in the copied scene data
+              updatedSceneData.connections = _rollupPluginBabelHelpers.toConsumableArray(newConnections);
+              console.log('🔍 Updated scene data for pathfinder:', {
+                connectionsCount: updatedSceneData.connections.length,
+                connections: updatedSceneData.connections,
+                hasScene: !!updatedSceneData.scene,
+                childrenCount: ((_updatedSceneData$sce = updatedSceneData.scene) === null || _updatedSceneData$sce === void 0 || (_updatedSceneData$sce = _updatedSceneData$sce.object) === null || _updatedSceneData$sce === void 0 || (_updatedSceneData$sce = _updatedSceneData$sce.children) === null || _updatedSceneData$sce === void 0 ? void 0 : _updatedSceneData$sce.length) || 0
+              });
 
-/**
- * Get the global pathfinding manager instance
- */
-function getPathfindingManager() {
-  var component = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-  if (!pathfindingManager || component && pathfindingManager.component !== component) {
-    pathfindingManager = new PathfindingManager(component);
-  }
-  return pathfindingManager;
-}
-var pathfindingManager$1 = {
-  PathfindingManager: PathfindingManager,
-  getPathfindingManager: getPathfindingManager
-};
+              // Log pathfinder version for connection updates
+              _context4.n = 2;
+              return this.logPathfinderVersion('Connections Update');
+            case 2:
+              // Create new pathfinder instance with updated data
+              this.pathfinder = new index_esm.Pathfinder(updatedSceneData);
+              component.pathfinder = this.pathfinder;
+
+              // Find new paths with updated connections
+              paths = this.pathfinder.findPaths();
+              console.log('🔍 Found paths with updated connections:', {
+                pathCount: paths.length,
+                paths: paths.map(function (p) {
+                  var _p$path;
+                  return {
+                    from: p.from,
+                    to: p.to,
+                    hasPath: !!p.path,
+                    pathLength: ((_p$path = p.path) === null || _p$path === void 0 ? void 0 : _p$path.length) || 0
+                  };
+                })
+              });
+
+              // Create pipe paths with materials
+              this.createPipePaths(paths, this.crosscubeTextureSet);
+
+              // Update the component's current scene data to reflect the changes
+              component.currentSceneData = updatedSceneData;
+              console.log('✅ Pathfinding updated successfully with new connections');
+              return _context4.a(2, true);
+          }
+        }, _callee4, this);
+      }));
+      function updatePathfindingWithConnections(_x3) {
+        return _updatePathfindingWithConnections.apply(this, arguments);
+      }
+      return updatePathfindingWithConnections;
+    }()
+    /**
+     * Update pathfinding after object transforms
+     */
+    )
+  }, {
+    key: "updatePathfindingAfterTransform",
+    value: (function () {
+      var _updatePathfindingAfterTransform = _rollupPluginBabelHelpers.asyncToGenerator(/*#__PURE__*/_rollupPluginBabelHelpers.regenerator().m(function _callee5(currentSceneData) {
+        var paths;
+        return _rollupPluginBabelHelpers.regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              // Remove all existing paths from the scene
+              this.removeAllPaths();
+              console.log('🔄 Starting pathfinding with updated scene data...');
+
+              // Log pathfinder version for transform updates
+              _context5.n = 1;
+              return this.logPathfinderVersion('Transform Update');
+            case 1:
+              this.pathfinder = new index_esm.Pathfinder(currentSceneData);
+              this.component.pathfinder = this.pathfinder;
+              paths = this.pathfinder.findPaths();
+              console.log('Found paths:', paths);
+
+              // Create pipe paths with materials
+              this.createPipePaths(paths, this.crosscubeTextureSet);
+            case 2:
+              return _context5.a(2);
+          }
+        }, _callee5, this);
+      }));
+      function updatePathfindingAfterTransform(_x4) {
+        return _updatePathfindingAfterTransform.apply(this, arguments);
+      }
+      return updatePathfindingAfterTransform;
+    }()
+    /**
+     * Dispose of pathfinding resources
+     */
+    )
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.removeAllPaths();
+      this.pathfinder = null;
+      this.crosscubeTextureSet = null;
+      this.pathfinderVersionInfo = null;
+      debugLogger.logger.info('PathfindingManager disposed');
+    }
+  }]);
+}();
 
 exports.PathfindingManager = PathfindingManager;
-exports["default"] = pathfindingManager$1;
-exports.getPathfindingManager = getPathfindingManager;

package/dist/esm/_virtual/_rollupPluginBabelHelpers.js

@@ -37,6 +37,13 @@ function _asyncToGenerator(n) {
 function _classCallCheck(a, n) {
   if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
 }
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
 function _defineProperties(e, r) {
   for (var t = 0; t < r.length; t++) {
     var o = r[t];
@@ -104,6 +111,14 @@ function _defineProperty(e, r, t) {
     writable: !0
   }) : e[r] = t, e;
 }
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
 function _iterableToArray(r) {
   if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
 }
@@ -288,6 +303,11 @@ function _regeneratorValues(e) {
   }
   throw new TypeError(typeof e + " is not iterable");
 }
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
 function _slicedToArray(r, e) {
   return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
 }
@@ -308,15 +328,6 @@ function _toPropertyKey(t) {
   var i = _toPrimitive(t, "string");
   return "symbol" == typeof i ? i : i + "";
 }
-function _typeof(o) {
-  "@babel/helpers - typeof";
-
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-    return typeof o;
-  } : function (o) {
-    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-  }, _typeof(o);
-}
 function _unsupportedIterableToArray(r, a) {
   if (r) {
     if ("string" == typeof r) return _arrayLikeToArray(r, a);
@@ -325,4 +336,4 @@ function _unsupportedIterableToArray(r, a) {
   }
 }
 
-export { _arrayLikeToArray as arrayLikeToArray, _arrayWithHoles as arrayWithHoles, _arrayWithoutHoles as arrayWithoutHoles, _asyncToGenerator as asyncToGenerator, _classCallCheck as classCallCheck, _createClass as createClass, _createForOfIteratorHelper as createForOfIteratorHelper, _defineProperty as defineProperty, _iterableToArray as iterableToArray, _iterableToArrayLimit as iterableToArrayLimit, _nonIterableRest as nonIterableRest, _nonIterableSpread as nonIterableSpread, _objectSpread2 as objectSpread2, _regenerator as regenerator, _regeneratorDefine as regeneratorDefine, _regeneratorValues as regeneratorValues, _slicedToArray as slicedToArray, _toConsumableArray as toConsumableArray, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey, _typeof as typeof, _unsupportedIterableToArray as unsupportedIterableToArray };
+export { _arrayLikeToArray as arrayLikeToArray, _arrayWithHoles as arrayWithHoles, _arrayWithoutHoles as arrayWithoutHoles, _asyncToGenerator as asyncToGenerator, _classCallCheck as classCallCheck, _construct as construct, _createClass as createClass, _createForOfIteratorHelper as createForOfIteratorHelper, _defineProperty as defineProperty, _isNativeReflectConstruct as isNativeReflectConstruct, _iterableToArray as iterableToArray, _iterableToArrayLimit as iterableToArrayLimit, _nonIterableRest as nonIterableRest, _nonIterableSpread as nonIterableSpread, _objectSpread2 as objectSpread2, _regenerator as regenerator, _regeneratorDefine as regeneratorDefine, _regeneratorValues as regeneratorValues, _setPrototypeOf as setPrototypeOf, _slicedToArray as slicedToArray, _toConsumableArray as toConsumableArray, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey, _unsupportedIterableToArray as unsupportedIterableToArray };