@2112-lab/central-plant 0.1.0

package/dist/cjs/src/disposalManager.js

@@ -0,0 +1,185 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
+var THREE = require('three');
+var debugLogger = require('./debugLogger.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
+
+/**
+ * Dispose a Three.js object including geometry, material, and textures
+ */
+function disposeObject(object) {
+  if (!object) return;
+
+  // Dispose geometry
+  if (object.geometry) {
+    object.geometry.dispose();
+  }
+
+  // Dispose material(s)
+  if (object.material) {
+    if (Array.isArray(object.material)) {
+      object.material.forEach(function (material) {
+        return disposeMaterial(material);
+      });
+    } else {
+      disposeMaterial(object.material);
+    }
+  }
+
+  // Dispose any children
+  if (object.children && object.children.length > 0) {
+    // Work with a copy of the children array to avoid issues during iteration
+    var children = _rollupPluginBabelHelpers.toConsumableArray(object.children);
+    children.forEach(function (child) {
+      return disposeObject(child);
+    });
+  }
+}
+
+/**
+ * Dispose a Three.js material and its textures
+ */
+function disposeMaterial(material) {
+  if (!material) return;
+
+  // Dispose textures
+  Object.keys(material).forEach(function (key) {
+    var value = material[key];
+    if (value && value instanceof THREE__namespace.Texture) {
+      value.dispose();
+    }
+  });
+
+  // Dispose the material itself
+  material.dispose();
+}
+
+/**
+ * Clean up a Three.js scene
+ */
+function cleanupScene(scene) {
+  if (!scene) {
+    debugLogger.logger.warn('Cannot cleanup: scene not provided');
+    return;
+  }
+
+  // Dispose all objects in the scene
+  while (scene.children.length > 0) {
+    var object = scene.children[0];
+    scene.remove(object);
+    disposeObject(object);
+  }
+  debugLogger.logger.info('Scene cleared and disposed');
+}
+
+/**
+ * Clean up a Three.js renderer
+ */
+function cleanupRenderer(renderer) {
+  if (!renderer) {
+    debugLogger.logger.warn('Cannot cleanup: renderer not provided');
+    return;
+  }
+  renderer.dispose();
+
+  // Remove from DOM if possible
+  var canvas = renderer.domElement;
+  if (canvas && canvas.parentNode) {
+    canvas.parentNode.removeChild(canvas);
+  }
+  debugLogger.logger.info('Renderer disposed');
+}
+
+/**
+ * Clean up Nuxt-specific event listeners
+ */
+function cleanupNuxtEventListeners() {
+  if (typeof window === 'undefined' || !window.$nuxt) {
+    return;
+  }
+
+  // Clean up any registered event listeners
+  if (window.$nuxt.$off) {
+    // This is a simple placeholder - actual implementation would need to track
+    // specific listeners that were registered
+    debugLogger.logger.info('Nuxt event listeners cleaned up');
+  }
+}
+
+/**
+ * Comprehensive cleanup of Three.js resources
+ */
+function cleanupThreeJsResources(component) {
+  if (!component) return;
+
+  // Stop animation if it's running
+  if (component.stopAnimation) {
+    component.stopAnimation();
+  }
+
+  // Clean up controls
+  if (component.controls) {
+    if (component.controls.dispose) {
+      component.controls.dispose();
+    }
+    component.controls = null;
+  }
+
+  // Clean up scene
+  if (component.scene) {
+    cleanupScene(component.scene);
+    component.scene = null;
+  }
+
+  // Clean up renderer
+  if (component.renderer) {
+    cleanupRenderer(component.renderer);
+    component.renderer = null;
+  }
+
+  // Clean up camera
+  component.camera = null;
+
+  // Cleanup other resources
+  component.textureLoader = null;
+  component.gltfLoader = null;
+  debugLogger.logger.info('All Three.js resources cleaned up');
+}
+var disposalManager = {
+  disposeObject: disposeObject,
+  disposeMaterial: disposeMaterial,
+  cleanupScene: cleanupScene,
+  cleanupRenderer: cleanupRenderer,
+  cleanupNuxtEventListeners: cleanupNuxtEventListeners,
+  cleanupThreeJsResources: cleanupThreeJsResources
+};
+
+exports.cleanupNuxtEventListeners = cleanupNuxtEventListeners;
+exports.cleanupRenderer = cleanupRenderer;
+exports.cleanupScene = cleanupScene;
+exports.cleanupThreeJsResources = cleanupThreeJsResources;
+exports["default"] = disposalManager;
+exports.disposeMaterial = disposeMaterial;
+exports.disposeObject = disposeObject;