@eodash/eodash 5.6.1 → 5.7.1

package/widgets/EodashMap/methods/index.js

@@ -6,9 +6,12 @@ import { useSTAcStore } from "@/store/stac";
 import { storeToRefs } from "pinia";
 import { isFirstLoad } from "@/utils/states";
 import { useEmitLayersUpdate, useOnLayersUpdate } from "@/composables";
-import { mapPosition } from "@/store/states";
+export { useEmitLayersUpdate, useOnLayersUpdate };
+import { isGlobe, mapPosition } from "@/store/states";
 import { sanitizeBbox } from "@/eodashSTAC/helpers";
 import { transformExtent } from "@eox/map";
+
+export { useMapLoading } from "./use-map-loading";
 /**
  * Holder for previous compare map view as it is overwritten by sync
  * @type { import("ol").View | null} mapElement
@@ -39,14 +42,52 @@ export const useHandleMapMoveEnd = (mapElement, mapPosition) => {
     }
   };
 
+  const handleGlobeMoveEnd = () => {
+    const camera = mapElement.value?.globe?.planet?.camera;
+    const lonLat = camera?.getLonLat();
+    if (!lonLat) return;
+    const { lon, lat, height } = lonLat;
+    if (![lon, lat, height].some(Number.isNaN)) {
+      mapPosition.value = [lon, lat, height];
+    }
+  };
+
+  /** @type {{ events: { off: Function } } | null} */
+  let subscribedCamera = null;
+
+  const subscribeGlobe = (retries = 3) => {
+    if (!isGlobe.value) return; // toggled back out during retry
+    const camera = mapElement.value?.globe?.planet?.camera;
+    if (camera) {
+      if (subscribedCamera === camera) return;
+      camera.events.on("moveend", handleGlobeMoveEnd);
+      subscribedCamera = camera;
+      handleGlobeMoveEnd();
+      return;
+    }
+    if (retries > 0) setTimeout(() => subscribeGlobe(retries - 1), 50);
+  };
+  const unsubscribeGlobe = () => {
+    subscribedCamera?.events.off("moveend", handleGlobeMoveEnd);
+    subscribedCamera = null;
+  };
+
+  const stopGlobeWatch = watch(isGlobe, (globe) =>
+    globe ? subscribeGlobe() : unsubscribeGlobe(),
+  );
+
   onMounted(() => {
-    /** @type {import('ol/Map').default} */
-    (mapElement.value?.map)?.on("moveend", handleMoveEnd);
+    const map = mapElement.value?.map;
+    map?.on("moveend", handleMoveEnd);
+    // Seed mapPosition from the initial view
+    handleMoveEnd(/** @type {any} */ ({ map }));
   });
 
   onUnmounted(() => {
     /** @type {import('ol/Map').default} */
     (mapElement.value?.map)?.un("moveend", handleMoveEnd);
+    unsubscribeGlobe();
+    stopGlobeWatch();
   });
 };
 
@@ -61,6 +102,7 @@ export const useHandleMapMoveEnd = (mapElement, mapPosition) => {
  * @param {import("vue").Ref<import("@eox/map").EOxMap| null>} partnerMap
  * @param {boolean} zoomToExtent
  * @param {import("vue").Ref<import("stac-ts").StacItem | import("stac-ts").StacLink | null>} [selectedItem]
+ * @param {Record<string, any>[]} [defaultBaseLayers]
  */
 export const useInitMap = (
   mapElement,
@@ -71,6 +113,7 @@ export const useInitMap = (
   partnerMap,
   zoomToExtent,
   selectedItem,
+  defaultBaseLayers,
 ) => {
   log.debug(
     "InitMap",
@@ -83,6 +126,10 @@ export const useInitMap = (
   const watching = selectedItem
     ? [selectedIndicator, datetime, selectedItem]
     : [selectedIndicator, datetime];
+  // Tags datetime values we set ourselves so the watcher skips its own echo.
+  /** @type {string | null} */
+  let internalDatetime = null;
+
   const stopIndicatorWatcher = watch(
     watching,
     async (updated, previous) => {
@@ -96,6 +143,28 @@ export const useInitMap = (
         );
 
       if (updatedStac) {
+        const isSameStac = updatedStac?.id === previousStac?.id;
+        const isSameItem = updatedItem?.id === previousItem?.id;
+
+        // Item deselect: overview render is owned by the item catalog widget.
+        const isItemDeselect =
+          previousItem &&
+          !updatedItem &&
+          isSameStac &&
+          updatedTime === previousTime;
+        if (isItemDeselect) return;
+
+        // Re-fire from our own datetime.value write, skip and clear
+        const isOwnDatetimeUpdate =
+          internalDatetime !== null &&
+          updatedTime === internalDatetime &&
+          isSameStac &&
+          isSameItem;
+        if (isOwnDatetimeUpdate) {
+          internalDatetime = null;
+          return;
+        }
+
         log.debug(
           "Selected Indicator watch triggered",
           updatedStac,
@@ -139,13 +208,14 @@ export const useInitMap = (
             updatedStac,
             eodashCols,
             updatedItem ?? updatedTime,
+            defaultBaseLayers,
           );
+
           log.debug(
             "Assigned layers after changing time only",
             JSON.parse(JSON.stringify(layersCollection)),
           );
           mapLayers.value = layersCollection;
-
           useEmitLayersUpdate(
             mapElement.value?.id === "compare"
               ? "compareTime:updated"
@@ -162,27 +232,38 @@ export const useInitMap = (
         if (interval && interval.length > 0 && interval[0].length > 1) {
           // @ts-expect-error this is the defined STAC structure
           endInterval = new Date(interval[0][1]);
+          // If end interval is in the future, set to now,
+          // for item fetching based on search endpoint
+          if (endInterval.getTime() > Date.now()) {
+            endInterval = new Date();
+          }
           log.debug(
             "Indicator load: found stac extent, setting time to latest value",
             endInterval,
           );
         }
+        let resolvedTime = updatedItem ?? updatedTime;
         if (
           !updatedItem &&
           endInterval !== null &&
           endInterval.toISOString() !== datetime.value &&
           !isFirstLoad.value
         ) {
-          datetime.value = endInterval.toISOString();
+          resolvedTime = endInterval.toISOString();
+          internalDatetime = resolvedTime;
+          datetime.value = resolvedTime;
         } else if (isFirstLoad.value && !datetime.value && endInterval) {
-          datetime.value = endInterval.toISOString();
+          resolvedTime = endInterval.toISOString();
+          internalDatetime = resolvedTime;
+          datetime.value = resolvedTime;
         }
 
         /** @type {Record<string,any>[]} */
         layersCollection = await createLayersConfig(
           updatedStac,
           eodashCols,
-          updatedItem ?? updatedTime,
+          updatedItem ?? resolvedTime,
+          defaultBaseLayers,
         );
 
         if (zoomToExtent) {
@@ -251,7 +332,7 @@ export const useUpdateTooltipProperties = (
    * @param {string} evt */
   const listenTo = (evt) =>
     enableCompare ? evt.includes("compare") : !evt.includes("compare");
-  useOnLayersUpdate(async (evt, _payload) => {
+  useOnLayersUpdate(async (evt) => {
     if (!listenTo(evt)) {
       return;
     }

package/widgets/EodashMap/methods/use-map-loading.js

@@ -0,0 +1,52 @@
+import { onUnmounted, watch } from "vue";
+import { loading } from "@/store/states";
+
+/**
+ * Tracks map loading state at the source level via `loading.activeLoads`,
+ * the same counter used by the axios plugin. Re-attaches source listeners
+ * whenever eox-map fires `layerschanged`, using `getFlatLayersArray`.
+ *
+ * @param {import("vue").Ref<import("@eox/map").EOxMap | null>} mapElement
+ * @param {import("vue").Ref<import("@eox/map").EOxMap | null>} compareMapElement
+ */
+export const useMapLoading = (mapElement, compareMapElement) => {
+  const startHandler = () => {
+    loading.activeLoads++;
+  };
+  const endHandler = () => {
+    loading.activeLoads--;
+  };
+
+  /** @param {import("@eox/map").EOxMap | null} newMapEl */
+  const watcherHandler = (newMapEl) => {
+    if (!newMapEl) return;
+
+    const hasStartListener = newMapEl.map
+      .getListeners("loadstart")
+      ?.some((listner) => listner === startHandler);
+    const hasEndListener = newMapEl.map
+      .getListeners("loadend")
+      ?.some((listner) => listner === endHandler);
+
+    if (!hasStartListener) {
+      newMapEl.map.addEventListener("loadstart", startHandler);
+    }
+    if (!hasEndListener) {
+      newMapEl.map.addEventListener("loadend", endHandler);
+    }
+  };
+  const stopMainWatcher = watch(mapElement, watcherHandler, {
+    immediate: true,
+  });
+  const stopCompareWatcher = watch(compareMapElement, watcherHandler, {
+    immediate: true,
+  });
+
+  onUnmounted(() => {
+    mapElement.value?.map.removeEventListener("loadstart", startHandler);
+    mapElement.value?.map.removeEventListener("loadend", endHandler);
+    stopMainWatcher();
+    stopCompareWatcher();
+    loading.activeLoads = 0;
+  });
+};

package/widgets/EodashProcess/index.vue

@@ -70,6 +70,7 @@ const { enableCompare, vegaEmbedOptions } = defineProps({
     default: false,
   },
   vegaEmbedOptions: {
+    /** @type {import("vue").PropType<import("vega-embed").EmbedOptions>} */
     type: Object,
     default() {
       return { actions: true };
@@ -119,7 +120,7 @@ const jsonformKey = computed(
 
 useInitProcess({
   selectedStac: currentSelectedStac,
-  mapElement: mapElement.value,
+  mapElement,
   jsonformSchema,
   isProcessed,
   processResults,

package/widgets/EodashProcess/methods/async.js

@@ -106,16 +106,27 @@ export async function updateJobsStatus(jobs, indicator) {
     jobsUrls.map((url) =>
       axios
         .get(url, { params: { t: Date.now() } })
-        .then((response) => response.data),
+        .then((response) => response.data)
+        .catch((error) => {
+          if (axios.isAxiosError(error)) {
+            console.warn(
+              `Job URL not accessible: ${url}. Maybe was deleted from the processing endpoint or endpoint is unavailable. Skipping...`,
+            );
+            return null;
+          }
+          throw error;
+        }),
     ),
   );
-  jobResults.sort((a, b) => {
-    return (
-      new Date(b.job_start_datetime).getTime() -
-      new Date(a.job_start_datetime).getTime()
-    );
-  });
-  jobs.value.splice(0, jobs.value.length, ...jobResults);
+  const validResults = jobResults
+    .filter((job) => job !== null)
+    .sort((a, b) => {
+      return (
+        new Date(b.job_start_datetime).getTime() -
+        new Date(a.job_start_datetime).getTime()
+      );
+    });
+  jobs.value.splice(0, jobs.value.length, ...validResults);
 }
 
 /**

package/widgets/EodashProcess/methods/composables.js

@@ -1,8 +1,7 @@
 import { initProcess, updateJsonformIdentifier } from "./handling";
-import { useEventBus } from "@vueuse/core";
-import { nextTick, onMounted, watch } from "vue";
-import { eoxLayersKey } from "@/utils/keys";
+import { nextTick, onMounted, onUnmounted, watch } from "vue";
 import { useOnLayersUpdate } from "@/composables";
+import { getCompareLayers, getLayers } from "@/store/actions";
 /**
  * Composable resposible of timing the Initialization of the process
  *
@@ -15,7 +14,7 @@ import { useOnLayersUpdate } from "@/composables";
  * @param {import("vue").Ref<boolean>} params.isProcessed
  * @param {import("vue").Ref<boolean>} params.loading
  * @param {import("vue").Ref<boolean>} params.isPolling
- * @param {import("@eox/map").EOxMap | null} params.mapElement
+ * @param {import("vue").Ref<import("@eox/map").EOxMap | null>} params.mapElement
  */
 export const useInitProcess = ({
   selectedStac,
@@ -26,60 +25,45 @@ export const useInitProcess = ({
   isPolling,
   mapElement,
 }) => {
-  const layersEvents = useEventBus(eoxLayersKey);
-
   onMounted(async () => {
-    // wait for the layers to be rendered
-    if ((mapElement?.layers.length ?? 0) > 1) {
-      await initProcess({
-        enableCompare: mapElement?.id === "compare",
-        selectedStac,
-        jsonformSchema,
-        isProcessed,
-        processResults,
-        loading,
-        isPolling,
-      });
-    } else {
-      layersEvents.once(async () => {
-        await initProcess({
-          enableCompare: mapElement?.id === "compare",
-          selectedStac,
-          jsonformSchema,
-          isProcessed,
-          loading,
-          processResults,
-          isPolling,
-        });
-      });
-    }
+    await initProcess({
+      enableCompare: mapElement.value?.id === "compare",
+      selectedStac,
+      jsonformSchema,
+      isProcessed,
+      processResults,
+      loading,
+      isPolling,
+      mapElement: mapElement.value,
+    });
   });
-  const enableCompare = mapElement?.id === "compare";
-  const evtKey = enableCompare ? "compareLayers:updated" : "layers:updated";
-  useOnLayersUpdate(async (evt, _payload) => {
-    if (
-      evt == "layertime:updated" ||
-      evt == "compareLayertime:updated" ||
-      evt == "time:updated" ||
-      evt == "compareTime:updated"
-    ) {
-      const shouldMainJsonFormUpdate =
-        ["layertime:updated", "time:updated"].includes(evt) && !enableCompare;
-      const shouldCompareJsonFormUpdate =
-        ["compareLayertime:updated", "compareTime:updated"].includes(evt) &&
-        enableCompare;
-      // we need to update jsonform on time change in cases when the feature selection layer was time-based, so that it attaches to a correct new layer
-      if (shouldMainJsonFormUpdate || shouldCompareJsonFormUpdate) {
-        const newJsonForm = await updateJsonformIdentifier({
-          jsonformSchema: jsonformSchema.value,
-          // @ts-expect-error TODO payload coming from time update events is not an object with layers property
-          newLayers: _payload,
-          enableCompare,
-        });
+
+  useOnLayersUpdate(async (evt) => {
+    const enableCompare = mapElement.value?.id === "compare";
+    const layerUpdatedKey = enableCompare
+      ? "compareLayers:updated"
+      : "layers:updated";
+    const timeUpdatedKeys = enableCompare
+      ? ["compareLayertime:updated", "compareTime:updated"]
+      : ["layertime:updated", "time:updated"];
+
+    if (timeUpdatedKeys.includes(evt)) {
+      // we need to update jsonform on time change in cases
+      // when the feature selection layer was time-based,
+      // so that it attaches to a correct new layer
+      const newJsonForm = await updateJsonformIdentifier({
+        jsonformSchema: jsonformSchema.value,
+        newLayers: enableCompare ? getCompareLayers() : getLayers(),
+        enableCompare,
+        mapElement: mapElement.value,
+      });
+
+      if (newJsonForm) {
         jsonformSchema.value = newJsonForm;
       }
     }
-    if (evt !== evtKey) {
+
+    if (evt !== layerUpdatedKey) {
       return;
     }
     await initProcess({
@@ -90,6 +74,7 @@ export const useInitProcess = ({
       processResults,
       loading,
       isPolling,
+      mapElement: mapElement.value,
     });
   });
 };
@@ -109,38 +94,39 @@ export function useAutoExec(
   startProcess,
 ) {
   /**
-   * @param {CustomEvent} _e
+   * @param {any} _e
    **/
   const onJsonFormChange = async (_e) => {
     await startProcess();
   };
 
-  const addEventListener = async () => {
-    await nextTick(() => {
-      //@ts-expect-error TODO
-      jsonformEl.value?.addEventListener("change", onJsonFormChange);
-    });
-  };
-  const removeEventListener = () => {
-    //@ts-expect-error TODO
-    jsonformEl.value?.removeEventListener("change", onJsonFormChange);
-  };
-
   watch(jsonformSchema, (updatedSchema) => {
     autoExec.value = updatedSchema?.options?.["execute"] || false;
   });
 
-  onMounted(() => {
-    watch(
-      autoExec,
-      async (exec) => {
-        if (exec) {
-          await addEventListener();
-        } else {
-          removeEventListener();
-        }
-      },
-      { immediate: true },
-    );
+  // Re-attach listener whenever the element or autoExec changes
+  const stop = watch(
+    [autoExec, jsonformEl],
+    async ([exec, el], [_prevExec, prevEl]) => {
+      // Cleanup if previous element existed
+      if (prevEl) {
+        prevEl.removeEventListener("change", onJsonFormChange);
+      }
+      // Add if enabled and we have an element
+      if (exec && el) {
+        // remove listener before adding to avoid duplicates in case of element change
+        el.removeEventListener("change", onJsonFormChange);
+        await nextTick();
+        el.addEventListener("change", onJsonFormChange);
+      }
+    },
+    { immediate: true },
+  );
+
+  onUnmounted(() => {
+    if (jsonformEl.value) {
+      jsonformEl.value.removeEventListener("change", onJsonFormChange);
+    }
+    stop();
   });
 }

package/widgets/EodashProcess/methods/custom-endpoints/chart/sentinelhub-endpoint.js

@@ -58,7 +58,7 @@ export async function handleSentinelHubProcess({
   );
 
   // fetch data from sentinel hub
-  return await Promise.all(
+  const results = await Promise.all(
     timePairs.map(([to, from]) => {
       return fetchSentinelHubData({
         url: endpoint,
@@ -67,14 +67,18 @@ export async function handleSentinelHubProcess({
         from,
         to,
         exampleLink: evalScriptLink,
-      }).catch((err) =>
+      }).catch((err) => {
         console.error(
           "[eodash] Error while fetching data from sentinel hub endpoint:",
           err,
-        ),
-      );
+        );
+        return [];
+      });
     }),
-  ).then((data) => data.flat().map((data) => data.outputs.data));
+  )
+    .then((data) => data.filter((result) => result.length > 0))
+    .then((data) => data.flat().map((data) => data.outputs.data));
+  return results;
 }
 
 /**

package/widgets/EodashProcess/methods/custom-endpoints/chart/veda-endpoint.js

@@ -37,7 +37,7 @@ export async function handleVedaEndpoint({
     vedaLink,
   );
   // TODO: convert jsonform bbox type to geojson in the schema to avoid the conversion here
-  return await Promise.all(
+  const results = await Promise.all(
     configs.map(({ endpoint, datetime }) => {
       const url = new URL(vedaEndpoint);
       const key = vedaLink.endpoint === "veda_stac" ? "ids" : "url";
@@ -56,14 +56,17 @@ export async function handleVedaEndpoint({
           fetchedSats.date = datetime;
           return fetchedSats;
         })
-        .catch((resp) =>
+        .catch((resp) => {
           console.error(
             "[eodash] Error while fetching data from veda endpoint:",
             resp,
-          ),
-        );
+          );
+          return null;
+        });
     }),
   );
+  // Filter out the nulls (failed requests) before returning
+  return results.filter((result) => result !== null);
 }
 
 /**