cesiumjs-anywidget 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

cesiumjs_anywidget/index.js

@@ -3,16 +3,26 @@
 
 // src/cesiumjs_anywidget/js/viewer-init.js
 async function loadCesiumJS() {
+  console.log("[CesiumWidget:ViewerInit] Loading CesiumJS...");
   if (window.Cesium) {
+    console.log("[CesiumWidget:ViewerInit] CesiumJS already loaded, reusing existing instance");
     return window.Cesium;
   }
   const script = document.createElement("script");
   script.src = "https://cesium.com/downloads/cesiumjs/releases/1.135/Build/Cesium/Cesium.js";
+  console.log("[CesiumWidget:ViewerInit] Loading CesiumJS from CDN...");
   await new Promise((resolve, reject) => {
-    script.onload = resolve;
-    script.onerror = reject;
+    script.onload = () => {
+      console.log("[CesiumWidget:ViewerInit] CesiumJS script loaded successfully");
+      resolve();
+    };
+    script.onerror = (error) => {
+      console.error("[CesiumWidget:ViewerInit] Failed to load CesiumJS script:", error);
+      reject(error);
+    };
     document.head.appendChild(script);
   });
+  console.log("[CesiumWidget:ViewerInit] CesiumJS initialized");
   return window.Cesium;
 }
 function createLoadingIndicator(container, hasToken) {
@@ -34,6 +44,7 @@ function createLoadingIndicator(container, hasToken) {
   return loadingDiv;
 }
 function createViewer(container, model, Cesium) {
+  console.log("[CesiumWidget:ViewerInit] Creating viewer with options...");
   const viewerOptions = {
     timeline: model.get("show_timeline"),
     animation: model.get("show_animation"),
@@ -47,17 +58,28 @@ function createViewer(container, model, Cesium) {
     shadows: false,
     shouldAnimate: false
   };
+  console.log("[CesiumWidget:ViewerInit] Viewer options:", viewerOptions);
   if (model.get("enable_terrain")) {
     viewerOptions.terrain = Cesium.Terrain.fromWorldTerrain();
+    console.log("[CesiumWidget:ViewerInit] Terrain enabled");
   }
   const viewer = new Cesium.Viewer(container, viewerOptions);
   viewer.scene.globe.enableLighting = model.get("enable_lighting");
+  console.log("[CesiumWidget:ViewerInit] Viewer created, lighting:", model.get("enable_lighting"));
   return viewer;
 }
 function setupViewerListeners(viewer, model, container, Cesium) {
+  console.log("[CesiumWidget:ViewerInit] Setting up viewer listeners");
+  let isDestroyed = false;
+  let scrubTimeout = null;
   model.on("change:enable_terrain", () => {
+    if (isDestroyed) {
+      console.log("[CesiumWidget:ViewerInit] Skipping enable_terrain change - destroyed");
+      return;
+    }
     if (!viewer)
       return;
+    console.log("[CesiumWidget:ViewerInit] Terrain setting changed:", model.get("enable_terrain"));
     if (model.get("enable_terrain")) {
       viewer.scene.setTerrain(Cesium.Terrain.fromWorldTerrain());
     } else {
@@ -65,32 +87,47 @@ function setupViewerListeners(viewer, model, container, Cesium) {
     }
   });
   model.on("change:enable_lighting", () => {
+    if (isDestroyed)
+      return;
     if (!viewer)
       return;
+    console.log("[CesiumWidget:ViewerInit] Lighting setting changed:", model.get("enable_lighting"));
     viewer.scene.globe.enableLighting = model.get("enable_lighting");
   });
   model.on("change:height", () => {
+    if (isDestroyed)
+      return;
     if (!viewer)
       return;
+    console.log("[CesiumWidget:ViewerInit] Height changed:", model.get("height"));
     container.style.height = model.get("height");
     viewer.resize();
   });
   model.on("change:show_timeline", () => {
+    if (isDestroyed)
+      return;
     if (!viewer || !viewer.timeline)
       return;
+    console.log("[CesiumWidget:ViewerInit] Timeline visibility changed:", model.get("show_timeline"));
     viewer.timeline.container.style.visibility = model.get("show_timeline") ? "visible" : "hidden";
   });
   model.on("change:show_animation", () => {
+    if (isDestroyed)
+      return;
     if (!viewer || !viewer.animation)
       return;
+    console.log("[CesiumWidget:ViewerInit] Animation visibility changed:", model.get("show_animation"));
     viewer.animation.container.style.visibility = model.get("show_animation") ? "visible" : "hidden";
   });
   model.on("change:atmosphere_settings", () => {
+    if (isDestroyed)
+      return;
     if (!viewer || !viewer.scene || !viewer.scene.atmosphere)
       return;
     const settings = model.get("atmosphere_settings");
     if (!settings || Object.keys(settings).length === 0)
       return;
+    console.log("[CesiumWidget:ViewerInit] Atmosphere settings changed:", settings);
     const atmosphere = viewer.scene.atmosphere;
     if (settings.brightnessShift !== void 0) {
       atmosphere.brightnessShift = settings.brightnessShift;
@@ -129,11 +166,14 @@ function setupViewerListeners(viewer, model, container, Cesium) {
     }
   });
   model.on("change:sky_atmosphere_settings", () => {
+    if (isDestroyed)
+      return;
     if (!viewer || !viewer.scene || !viewer.scene.skyAtmosphere)
       return;
     const settings = model.get("sky_atmosphere_settings");
     if (!settings || Object.keys(settings).length === 0)
       return;
+    console.log("[CesiumWidget:ViewerInit] Sky atmosphere settings changed:", settings);
     const skyAtmosphere = viewer.scene.skyAtmosphere;
     if (settings.show !== void 0) {
       skyAtmosphere.show = settings.show;
@@ -178,11 +218,14 @@ function setupViewerListeners(viewer, model, container, Cesium) {
     }
   });
   model.on("change:skybox_settings", () => {
+    if (isDestroyed)
+      return;
     if (!viewer || !viewer.scene || !viewer.scene.skyBox)
       return;
     const settings = model.get("skybox_settings");
     if (!settings || Object.keys(settings).length === 0)
       return;
+    console.log("[CesiumWidget:ViewerInit] SkyBox settings changed:", settings);
     const skyBox = viewer.scene.skyBox;
     if (settings.show !== void 0) {
       skyBox.show = settings.show;
@@ -207,104 +250,155 @@ function setupViewerListeners(viewer, model, container, Cesium) {
     }
   });
   function getCameraState() {
-    const cartographic = viewer.camera.positionCartographic;
-    return {
-      latitude: Cesium.Math.toDegrees(cartographic.latitude),
-      longitude: Cesium.Math.toDegrees(cartographic.longitude),
-      altitude: cartographic.height,
-      heading: Cesium.Math.toDegrees(viewer.camera.heading),
-      pitch: Cesium.Math.toDegrees(viewer.camera.pitch),
-      roll: Cesium.Math.toDegrees(viewer.camera.roll)
-    };
+    if (!viewer || !viewer.camera || !viewer.camera.positionCartographic) {
+      console.warn("[CesiumWidget:ViewerInit] Cannot get camera state - viewer or camera not available");
+      return null;
+    }
+    try {
+      const cartographic = viewer.camera.positionCartographic;
+      return {
+        latitude: Cesium.Math.toDegrees(cartographic.latitude),
+        longitude: Cesium.Math.toDegrees(cartographic.longitude),
+        altitude: cartographic.height,
+        heading: Cesium.Math.toDegrees(viewer.camera.heading),
+        pitch: Cesium.Math.toDegrees(viewer.camera.pitch),
+        roll: Cesium.Math.toDegrees(viewer.camera.roll)
+      };
+    } catch (error) {
+      console.warn("[CesiumWidget:ViewerInit] Error getting camera state:", error);
+      return null;
+    }
   }
   function getClockState() {
-    if (!viewer.clock)
+    if (!viewer || !viewer.clock)
       return null;
-    return {
-      current_time: Cesium.JulianDate.toIso8601(viewer.clock.currentTime),
-      multiplier: viewer.clock.multiplier,
-      is_animating: viewer.clock.shouldAnimate
-    };
+    try {
+      return {
+        current_time: Cesium.JulianDate.toIso8601(viewer.clock.currentTime),
+        multiplier: viewer.clock.multiplier,
+        is_animating: viewer.clock.shouldAnimate
+      };
+    } catch (error) {
+      console.warn("[CesiumWidget:ViewerInit] Error getting clock state:", error);
+      return null;
+    }
   }
   function sendInteractionEvent(type, additionalData = {}) {
+    if (isDestroyed) {
+      console.log("[CesiumWidget:ViewerInit] Skipping interaction event - destroyed:", type);
+      return;
+    }
+    if (!viewer) {
+      console.warn("[CesiumWidget:ViewerInit] Cannot send interaction event - viewer not available");
+      return;
+    }
+    const cameraState = getCameraState();
+    if (!cameraState) {
+      console.warn("[CesiumWidget:ViewerInit] Skipping interaction event - camera state not available");
+      return;
+    }
     const event = {
       type,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      camera: getCameraState(),
+      camera: cameraState,
       clock: getClockState(),
       ...additionalData
     };
-    console.log("[CesiumWidget] Interaction event:", type, event);
+    console.log("[CesiumWidget:ViewerInit] Interaction event:", type, event);
     model.set("interaction_event", event);
     model.save_changes();
   }
   const camera = viewer.camera;
   camera.moveEnd.addEventListener(() => {
+    if (isDestroyed || !viewer)
+      return;
     sendInteractionEvent("camera_move");
   });
   const scene = viewer.scene;
   const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
   handler.setInputAction((click) => {
+    if (isDestroyed || !viewer || !viewer.scene || !viewer.camera)
+      return;
     const pickedData = {};
-    const ray = viewer.camera.getPickRay(click.position);
-    const cartesian = viewer.scene.globe.pick(ray, viewer.scene);
-    if (cartesian) {
-      const cartographic = Cesium.Cartographic.fromCartesian(cartesian);
-      pickedData.picked_position = {
-        latitude: Cesium.Math.toDegrees(cartographic.latitude),
-        longitude: Cesium.Math.toDegrees(cartographic.longitude),
-        altitude: cartographic.height
-      };
+    try {
+      const ray = viewer.camera.getPickRay(click.position);
+      if (ray && viewer.scene.globe) {
+        const cartesian = viewer.scene.globe.pick(ray, viewer.scene);
+        if (cartesian) {
+          const cartographic = Cesium.Cartographic.fromCartesian(cartesian);
+          pickedData.picked_position = {
+            latitude: Cesium.Math.toDegrees(cartographic.latitude),
+            longitude: Cesium.Math.toDegrees(cartographic.longitude),
+            altitude: cartographic.height
+          };
+        }
+      }
+    } catch (error) {
+      console.warn("[CesiumWidget:ViewerInit] Error picking position:", error);
     }
-    const pickedObject = viewer.scene.pick(click.position);
-    if (Cesium.defined(pickedObject) && Cesium.defined(pickedObject.id)) {
-      const entity = pickedObject.id;
-      pickedData.picked_entity = {
-        id: entity.id,
-        name: entity.name || null
-      };
-      if (entity.properties) {
-        const props = {};
-        const propertyNames = entity.properties.propertyNames;
-        if (propertyNames && propertyNames.length > 0) {
-          propertyNames.forEach((name) => {
-            try {
-              props[name] = entity.properties[name].getValue(viewer.clock.currentTime);
-            } catch (e) {
+    try {
+      const pickedObject = viewer.scene.pick(click.position);
+      if (Cesium.defined(pickedObject) && Cesium.defined(pickedObject.id)) {
+        const entity = pickedObject.id;
+        pickedData.picked_entity = {
+          id: entity.id,
+          name: entity.name || null
+        };
+        if (entity.properties) {
+          const props = {};
+          const propertyNames = entity.properties.propertyNames;
+          if (propertyNames && propertyNames.length > 0) {
+            propertyNames.forEach((name) => {
+              try {
+                props[name] = entity.properties[name].getValue(viewer.clock.currentTime);
+              } catch (e) {
+              }
+            });
+            if (Object.keys(props).length > 0) {
+              pickedData.picked_entity.properties = props;
             }
-          });
-          if (Object.keys(props).length > 0) {
-            pickedData.picked_entity.properties = props;
           }
         }
       }
+    } catch (error) {
+      console.warn("[CesiumWidget:ViewerInit] Error picking entity:", error);
     }
     sendInteractionEvent("left_click", pickedData);
   }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
   handler.setInputAction((click) => {
+    if (isDestroyed || !viewer || !viewer.scene || !viewer.camera)
+      return;
     const pickedData = {};
-    const ray = viewer.camera.getPickRay(click.position);
-    const cartesian = viewer.scene.globe.pick(ray, viewer.scene);
-    if (cartesian) {
-      const cartographic = Cesium.Cartographic.fromCartesian(cartesian);
-      pickedData.picked_position = {
-        latitude: Cesium.Math.toDegrees(cartographic.latitude),
-        longitude: Cesium.Math.toDegrees(cartographic.longitude),
-        altitude: cartographic.height
-      };
+    try {
+      const ray = viewer.camera.getPickRay(click.position);
+      if (ray && viewer.scene.globe) {
+        const cartesian = viewer.scene.globe.pick(ray, viewer.scene);
+        if (cartesian) {
+          const cartographic = Cesium.Cartographic.fromCartesian(cartesian);
+          pickedData.picked_position = {
+            latitude: Cesium.Math.toDegrees(cartographic.latitude),
+            longitude: Cesium.Math.toDegrees(cartographic.longitude),
+            altitude: cartographic.height
+          };
+        }
+      }
+    } catch (error) {
+      console.warn("[CesiumWidget:ViewerInit] Error picking position:", error);
     }
     sendInteractionEvent("right_click", pickedData);
   }, Cesium.ScreenSpaceEventType.RIGHT_CLICK);
   if (viewer.timeline) {
     let timelineScrubbing = false;
-    let scrubTimeout = null;
     viewer.clock.onTick.addEventListener(() => {
+      if (isDestroyed)
+        return;
       if (viewer.timeline) {
         if (scrubTimeout) {
           clearTimeout(scrubTimeout);
+          scrubTimeout = null;
         }
         scrubTimeout = setTimeout(() => {
-          if (timelineScrubbing) {
+          if (!isDestroyed && timelineScrubbing) {
             timelineScrubbing = false;
             sendInteractionEvent("timeline_scrub");
           }
@@ -313,13 +407,23 @@ function setupViewerListeners(viewer, model, container, Cesium) {
       }
     });
   }
+  console.log("[CesiumWidget:ViewerInit] Viewer listeners setup complete");
 }
 function setupGeoJSONLoader(viewer, model, Cesium) {
+  console.log("[CesiumWidget:ViewerInit] Setting up GeoJSON loader");
   let geojsonDataSources = [];
-  model.on("change:geojson_data", async () => {
-    if (!viewer || !viewer.dataSources)
+  let isDestroyed = false;
+  async function loadGeoJSONData(flyToData = true) {
+    if (isDestroyed) {
+      console.log("[CesiumWidget:ViewerInit] Skipping geojson_data load - destroyed");
       return;
+    }
+    if (!viewer || !viewer.dataSources) {
+      console.warn("[CesiumWidget:ViewerInit] Cannot load GeoJSON - viewer or dataSources not available");
+      return;
+    }
     const geojsonDataArray = model.get("geojson_data");
+    console.log("[CesiumWidget:ViewerInit] Loading GeoJSON data, count:", geojsonDataArray?.length || 0);
     geojsonDataSources.forEach((dataSource) => {
       if (viewer && viewer.dataSources) {
         viewer.dataSources.remove(dataSource);
@@ -329,6 +433,7 @@ function setupGeoJSONLoader(viewer, model, Cesium) {
     if (geojsonDataArray && Array.isArray(geojsonDataArray)) {
       for (const geojsonData of geojsonDataArray) {
         try {
+          console.log("[CesiumWidget:ViewerInit] Loading GeoJSON dataset...");
           const dataSource = await Cesium.GeoJsonDataSource.load(geojsonData, {
             stroke: Cesium.Color.HOTPINK,
             fill: Cesium.Color.PINK.withAlpha(0.5),
@@ -337,18 +442,28 @@ function setupGeoJSONLoader(viewer, model, Cesium) {
           if (viewer && viewer.dataSources) {
             viewer.dataSources.add(dataSource);
             geojsonDataSources.push(dataSource);
+            console.log("[CesiumWidget:ViewerInit] GeoJSON dataset loaded successfully");
           }
         } catch (error) {
-          console.error("Error loading GeoJSON:", error);
+          console.error("[CesiumWidget:ViewerInit] Error loading GeoJSON:", error);
         }
       }
-      if (geojsonDataSources.length > 0 && viewer && viewer.flyTo) {
+      if (flyToData && geojsonDataSources.length > 0 && viewer && viewer.flyTo) {
+        console.log("[CesiumWidget:ViewerInit] Flying to GeoJSON data");
         viewer.flyTo(geojsonDataSources[0]);
       }
     }
-  });
+  }
+  model.on("change:geojson_data", () => loadGeoJSONData(true));
+  const initialData = model.get("geojson_data");
+  if (initialData && Array.isArray(initialData) && initialData.length > 0) {
+    console.log("[CesiumWidget:ViewerInit] Loading initial GeoJSON data...");
+    loadGeoJSONData(true);
+  }
   return {
     destroy: () => {
+      console.log("[CesiumWidget:ViewerInit] Destroying GeoJSON loader");
+      isDestroyed = true;
       geojsonDataSources.forEach((dataSource) => {
         if (viewer) {
           viewer.dataSources.remove(dataSource);
@@ -359,11 +474,20 @@ function setupGeoJSONLoader(viewer, model, Cesium) {
   };
 }
 function setupCZMLLoader(viewer, model, Cesium) {
+  console.log("[CesiumWidget:ViewerInit] Setting up CZML loader");
   let czmlDataSources = [];
-  model.on("change:czml_data", async () => {
-    if (!viewer || !viewer.dataSources)
+  let isDestroyed = false;
+  async function loadCZMLData(flyToData = true) {
+    if (isDestroyed) {
+      console.log("[CesiumWidget:ViewerInit] Skipping czml_data load - destroyed");
       return;
+    }
+    if (!viewer || !viewer.dataSources) {
+      console.warn("[CesiumWidget:ViewerInit] Cannot load CZML - viewer or dataSources not available");
+      return;
+    }
     const czmlDataArray = model.get("czml_data");
+    console.log("[CesiumWidget:ViewerInit] Loading CZML data, count:", czmlDataArray?.length || 0);
     czmlDataSources.forEach((dataSource) => {
       if (viewer && viewer.dataSources) {
         viewer.dataSources.remove(dataSource);
@@ -374,23 +498,36 @@ function setupCZMLLoader(viewer, model, Cesium) {
       for (const czmlData of czmlDataArray) {
         if (Array.isArray(czmlData) && czmlData.length > 0) {
           try {
+            console.log("[CesiumWidget:ViewerInit] Loading CZML document with", czmlData.length, "packets...");
             const dataSource = await Cesium.CzmlDataSource.load(czmlData);
             if (viewer && viewer.dataSources) {
               viewer.dataSources.add(dataSource);
               czmlDataSources.push(dataSource);
+              console.log("[CesiumWidget:ViewerInit] CZML document loaded successfully, entities:", dataSource.entities.values.length);
             }
           } catch (error) {
-            console.error("Error loading CZML:", error);
+            console.error("[CesiumWidget:ViewerInit] Error loading CZML:", error);
           }
+        } else {
+          console.warn("[CesiumWidget:ViewerInit] Skipping invalid CZML data (not an array or empty):", czmlData);
         }
       }
-      if (czmlDataSources.length > 0 && viewer && viewer.flyTo) {
+      if (flyToData && czmlDataSources.length > 0 && viewer && viewer.flyTo) {
+        console.log("[CesiumWidget:ViewerInit] Flying to CZML data");
         viewer.flyTo(czmlDataSources[0]);
       }
     }
-  });
+  }
+  model.on("change:czml_data", () => loadCZMLData(true));
+  const initialData = model.get("czml_data");
+  if (initialData && Array.isArray(initialData) && initialData.length > 0) {
+    console.log("[CesiumWidget:ViewerInit] Loading initial CZML data...");
+    loadCZMLData(true);
+  }
   return {
     destroy: () => {
+      console.log("[CesiumWidget:ViewerInit] Destroying CZML loader");
+      isDestroyed = true;
       czmlDataSources.forEach((dataSource) => {
         if (viewer) {
           viewer.dataSources.remove(dataSource);
@@ -404,28 +541,48 @@ function setupCZMLLoader(viewer, model, Cesium) {
 // src/cesiumjs_anywidget/js/camera-sync.js
 function initializeCameraSync(viewer, model) {
   const Cesium = window.Cesium;
-  let cameraUpdateTimeout;
+  let cameraUpdateTimeout = null;
+  let isDestroyed = false;
+  console.log("[CesiumWidget:CameraSync] Initializing camera synchronization");
   function updateCameraFromModel() {
-    if (!viewer)
+    if (isDestroyed) {
+      console.log("[CesiumWidget:CameraSync] Skipping updateCameraFromModel - module destroyed");
       return;
+    }
+    if (!viewer) {
+      console.warn("[CesiumWidget:CameraSync] updateCameraFromModel called but viewer is null");
+      return;
+    }
     const lat = model.get("latitude");
     const lon = model.get("longitude");
     const alt = model.get("altitude");
     const heading = Cesium.Math.toRadians(model.get("heading"));
     const pitch = Cesium.Math.toRadians(model.get("pitch"));
     const roll = Cesium.Math.toRadians(model.get("roll"));
+    console.log("[CesiumWidget:CameraSync] Updating camera from model:", { lat, lon, alt });
     viewer.camera.setView({
       destination: Cesium.Cartesian3.fromDegrees(lon, lat, alt),
       orientation: { heading, pitch, roll }
     });
   }
   function updateModelFromCamera() {
-    if (!viewer)
+    if (isDestroyed) {
+      console.log("[CesiumWidget:CameraSync] Skipping updateModelFromCamera - module destroyed");
       return;
+    }
+    if (!viewer) {
+      console.warn("[CesiumWidget:CameraSync] updateModelFromCamera called but viewer is null");
+      return;
+    }
     const position = viewer.camera.positionCartographic;
     const heading = viewer.camera.heading;
     const pitch = viewer.camera.pitch;
     const roll = viewer.camera.roll;
+    console.log("[CesiumWidget:CameraSync] Updating model from camera:", {
+      lat: Cesium.Math.toDegrees(position.latitude),
+      lon: Cesium.Math.toDegrees(position.longitude),
+      alt: position.height
+    });
     model.set("latitude", Cesium.Math.toDegrees(position.latitude));
     model.set("longitude", Cesium.Math.toDegrees(position.longitude));
     model.set("altitude", position.height);
@@ -435,9 +592,17 @@ function initializeCameraSync(viewer, model) {
     model.save_changes();
   }
   function handleCameraChanged() {
-    clearTimeout(cameraUpdateTimeout);
+    if (isDestroyed) {
+      console.log("[CesiumWidget:CameraSync] Skipping handleCameraChanged - module destroyed");
+      return;
+    }
+    if (cameraUpdateTimeout) {
+      clearTimeout(cameraUpdateTimeout);
+    }
     cameraUpdateTimeout = setTimeout(() => {
-      updateModelFromCamera();
+      if (!isDestroyed) {
+        updateModelFromCamera();
+      }
     }, 500);
   }
   updateCameraFromModel();
@@ -449,10 +614,15 @@ function initializeCameraSync(viewer, model) {
   model.on("change:pitch", updateCameraFromModel);
   model.on("change:roll", updateCameraFromModel);
   model.on("change:camera_command", () => {
+    if (isDestroyed) {
+      console.log("[CesiumWidget:CameraSync] Skipping camera_command - module destroyed");
+      return;
+    }
     const command = model.get("camera_command");
     if (!command || !command.command || !command.timestamp)
       return;
     const cmd = command.command;
+    console.log("[CesiumWidget:CameraSync] Executing camera command:", cmd, command);
     try {
       switch (cmd) {
         case "flyTo":
@@ -545,17 +715,25 @@ function initializeCameraSync(viewer, model) {
     updateCameraFromModel,
     updateModelFromCamera,
     destroy: () => {
-      clearTimeout(cameraUpdateTimeout);
+      console.log("[CesiumWidget:CameraSync] Destroying camera sync module");
+      isDestroyed = true;
+      if (cameraUpdateTimeout) {
+        clearTimeout(cameraUpdateTimeout);
+        cameraUpdateTimeout = null;
+      }
       viewer.camera.changed.removeEventListener(handleCameraChanged);
+      console.log("[CesiumWidget:CameraSync] Camera sync module destroyed");
     }
   };
 }
 
 // src/cesiumjs_anywidget/js/measurement-tools.js
 function initializeMeasurementTools(viewer, model, container) {
+  console.log("[CesiumWidget:MeasurementTools] Initializing measurement tools");
   const Cesium = window.Cesium;
   let measurementHandler = null;
   let editHandler = null;
+  let isDestroyed = false;
   let measurementState = {
     mode: null,
     points: [],
@@ -777,6 +955,7 @@ function initializeMeasurementTools(viewer, model, container) {
     };
   }
   function clearAllMeasurements() {
+    console.log("[CesiumWidget:MeasurementTools] Clearing all measurements");
     measurementState.entities.forEach((e) => viewer.entities.remove(e));
     measurementState.labels.forEach((l) => viewer.entities.remove(l));
     measurementState.polylines.forEach((p) => viewer.entities.remove(p));
@@ -1123,6 +1302,7 @@ function initializeMeasurementTools(viewer, model, container) {
   }
   function updateMeasurementsList() {
     const results = model.get("measurement_results") || [];
+    console.log("[CesiumWidget:MeasurementTools] Updating measurements list, count:", results.length);
     const listContent = document.getElementById("measurements-list-content");
     if (!listContent) {
       console.warn("[CesiumWidget] Measurements list content element not found in DOM");
@@ -1488,6 +1668,7 @@ function initializeMeasurementTools(viewer, model, container) {
     }
   }
   function enableMeasurementMode(mode) {
+    console.log("[CesiumWidget:MeasurementTools] Enabling measurement mode:", mode);
     if (measurementHandler) {
       measurementHandler.destroy();
       measurementHandler = null;
@@ -1676,31 +1857,50 @@ function initializeMeasurementTools(viewer, model, container) {
     });
   }
   model.on("change:measurement_mode", () => {
+    if (isDestroyed) {
+      console.log("[CesiumWidget:MeasurementTools] Skipping measurement_mode change - destroyed");
+      return;
+    }
     const mode = model.get("measurement_mode");
+    console.log("[CesiumWidget:MeasurementTools] Measurement mode changed:", mode);
     enableMeasurementMode(mode);
   });
   model.on("change:measurement_results", () => {
+    if (isDestroyed) {
+      console.log("[CesiumWidget:MeasurementTools] Skipping measurement_results change - destroyed");
+      return;
+    }
     const results = model.get("measurement_results") || [];
+    console.log("[CesiumWidget:MeasurementTools] Measurement results changed, count:", results.length);
     if (results.length === 0) {
       clearAllMeasurements();
     }
     updateMeasurementsList();
   });
   model.on("change:load_measurements_trigger", () => {
+    if (isDestroyed)
+      return;
     const triggerData = model.get("load_measurements_trigger");
+    console.log("[CesiumWidget:MeasurementTools] Load measurements trigger:", triggerData);
     if (triggerData && triggerData.measurements) {
       loadAndDisplayMeasurements(triggerData.measurements);
       updateMeasurementsList();
     }
   });
   model.on("change:focus_measurement_trigger", () => {
+    if (isDestroyed)
+      return;
     const triggerData = model.get("focus_measurement_trigger");
+    console.log("[CesiumWidget:MeasurementTools] Focus measurement trigger:", triggerData);
     if (triggerData && typeof triggerData.index === "number") {
       focusOnMeasurement(triggerData.index);
     }
   });
   model.on("change:show_measurement_tools", () => {
+    if (isDestroyed)
+      return;
     const show = model.get("show_measurement_tools");
+    console.log("[CesiumWidget:MeasurementTools] Show measurement tools:", show);
     toolbarDiv.style.display = show ? "flex" : "none";
     editorPanel.style.display = show ? editorPanel.style.display : "none";
     if (!show && editState.enabled) {
@@ -1709,7 +1909,10 @@ function initializeMeasurementTools(viewer, model, container) {
     }
   });
   model.on("change:show_measurements_list", () => {
+    if (isDestroyed)
+      return;
     const show = model.get("show_measurements_list");
+    console.log("[CesiumWidget:MeasurementTools] Show measurements list:", show);
     measurementsListPanel.style.display = show ? "block" : "none";
   });
   toolbarDiv.style.display = model.get("show_measurement_tools") ? "flex" : "none";
@@ -1719,6 +1922,8 @@ function initializeMeasurementTools(viewer, model, container) {
     enableMeasurementMode,
     clearAllMeasurements,
     destroy: () => {
+      console.log("[CesiumWidget:MeasurementTools] Destroying measurement tools");
+      isDestroyed = true;
       if (measurementHandler) {
         measurementHandler.destroy();
       }
@@ -1726,6 +1931,7 @@ function initializeMeasurementTools(viewer, model, container) {
       if (toolbarDiv.parentNode) {
         toolbarDiv.remove();
       }
+      console.log("[CesiumWidget:MeasurementTools] Measurement tools destroyed");
     }
   };
 }
@@ -1733,15 +1939,22 @@ function initializeMeasurementTools(viewer, model, container) {
 // src/cesiumjs_anywidget/js/index.js
 window.CESIUM_BASE_URL = "https://cesium.com/downloads/cesiumjs/releases/1.135/Build/Cesium/";
 async function render({ model, el }) {
+  console.log("[CesiumWidget] Starting render");
+  console.log("[CesiumWidget] Loading CesiumJS...");
   const Cesium = await loadCesiumJS();
+  console.log("[CesiumWidget] CesiumJS loaded successfully");
   const container = document.createElement("div");
   container.style.width = "100%";
   container.style.height = model.get("height");
   container.style.position = "relative";
   el.appendChild(container);
+  console.log("[CesiumWidget] Container created with height:", model.get("height"));
   const ionToken = model.get("ion_access_token");
   if (ionToken) {
     Cesium.Ion.defaultAccessToken = ionToken;
+    console.log("[CesiumWidget] Ion access token set");
+  } else {
+    console.warn("[CesiumWidget] No Ion access token provided");
   }
   const loadingDiv = createLoadingIndicator(container, !!ionToken);
   let viewer = null;
@@ -1751,37 +1964,57 @@ async function render({ model, el }) {
   let czmlLoader = null;
   (async () => {
     try {
+      console.log("[CesiumWidget] Creating Cesium Viewer...");
       viewer = createViewer(container, model, Cesium);
+      console.log("[CesiumWidget] Cesium Viewer created successfully");
       if (loadingDiv.parentNode) {
         loadingDiv.remove();
       }
+      console.log("[CesiumWidget] Initializing camera synchronization...");
       cameraSync = initializeCameraSync(viewer, model);
+      console.log("[CesiumWidget] Camera synchronization initialized");
+      console.log("[CesiumWidget] Initializing measurement tools...");
       measurementTools = initializeMeasurementTools(viewer, model, container);
+      console.log("[CesiumWidget] Measurement tools initialized");
+      console.log("[CesiumWidget] Setting up viewer listeners...");
       setupViewerListeners(viewer, model, container, Cesium);
+      console.log("[CesiumWidget] Viewer listeners set up");
+      console.log("[CesiumWidget] Setting up GeoJSON loader...");
       geoJsonLoader = setupGeoJSONLoader(viewer, model, Cesium);
+      console.log("[CesiumWidget] GeoJSON loader set up");
+      console.log("[CesiumWidget] Setting up CZML loader...");
       czmlLoader = setupCZMLLoader(viewer, model, Cesium);
+      console.log("[CesiumWidget] CZML loader set up");
+      console.log("[CesiumWidget] Initialization complete");
     } catch (error) {
-      console.error("Error initializing CesiumJS viewer:", error);
+      console.error("[CesiumWidget] Error initializing CesiumJS viewer:", error);
       loadingDiv.textContent = `Error: ${error.message}`;
       loadingDiv.style.background = "rgba(255,0,0,0.8)";
     }
   })();
   return () => {
+    console.log("[CesiumWidget] Starting cleanup...");
     if (cameraSync) {
+      console.log("[CesiumWidget] Destroying camera sync...");
       cameraSync.destroy();
     }
     if (measurementTools) {
+      console.log("[CesiumWidget] Destroying measurement tools...");
       measurementTools.destroy();
     }
     if (geoJsonLoader) {
+      console.log("[CesiumWidget] Destroying GeoJSON loader...");
       geoJsonLoader.destroy();
     }
     if (czmlLoader) {
+      console.log("[CesiumWidget] Destroying CZML loader...");
       czmlLoader.destroy();
     }
     if (viewer) {
+      console.log("[CesiumWidget] Destroying viewer...");
       viewer.destroy();
     }
+    console.log("[CesiumWidget] Cleanup complete");
   };
 }
 var js_default = { render };

{cesiumjs_anywidget-0.4.0.dist-info → cesiumjs_anywidget-0.5.0.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: cesiumjs-anywidget
-Version: 0.4.0
+Version: 0.5.0
 Summary: A Jupyter widget for CesiumJS 3D globe visualization using anywidget
 Project-URL: Homepage, https://github.com/Alex-PLACET/cesiumjs_anywidget
 Project-URL: Repository, https://github.com/Alex-PLACET/cesiumjs_anywidget
-Author: Alex PLACET
+Author: Alexis Placet
 License:                                  Apache License
                                    Version 2.0, January 2004
                                 http://www.apache.org/licenses/

cesiumjs_anywidget-0.5.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+cesiumjs_anywidget/__init__.py,sha256=9WVcAtreHgk6C5clPG6sZy4m7s5AIbGU1DJ4oDpx3Is,165
+cesiumjs_anywidget/styles.css,sha256=kt2i9fJuM6gaR7WkoQ2VGGoHzhqy6RpJVK2xwMKPV70,689
+cesiumjs_anywidget/widget.py,sha256=_7uXX7B3KsOg_3QrMDfV0pZ8BGA-6coFnZ7_gTI3nck,39104
+cesiumjs_anywidget/index.js,sha256=SRVdkrR2QHSnlXBcHvk5jZFOlWVX6GKXaluB5RPl1kA,79662
+cesiumjs_anywidget-0.5.0.dist-info/METADATA,sha256=EIQjpI0HVMin-MZZSOLBbtngZFU4_bis2DQ3S9lNb2I,24780
+cesiumjs_anywidget-0.5.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cesiumjs_anywidget-0.5.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cesiumjs_anywidget-0.5.0.dist-info/RECORD,,

cesiumjs_anywidget-0.4.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-cesiumjs_anywidget/__init__.py,sha256=9WVcAtreHgk6C5clPG6sZy4m7s5AIbGU1DJ4oDpx3Is,165
-cesiumjs_anywidget/styles.css,sha256=kt2i9fJuM6gaR7WkoQ2VGGoHzhqy6RpJVK2xwMKPV70,689
-cesiumjs_anywidget/widget.py,sha256=_7uXX7B3KsOg_3QrMDfV0pZ8BGA-6coFnZ7_gTI3nck,39104
-cesiumjs_anywidget/index.js,sha256=SrJ9F9xHdfvbz5CkP_ydspiDaPU6vp74vxtUv-RVimE,68405
-cesiumjs_anywidget-0.4.0.dist-info/METADATA,sha256=NwADYoiPPp4RLblmHCM5_mhak_cCB7ptC4iN0NXVZTY,24778
-cesiumjs_anywidget-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-cesiumjs_anywidget-0.4.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-cesiumjs_anywidget-0.4.0.dist-info/RECORD,,