@eodash/eodash 5.6.1 → 5.7.0

package/dist/client/{async-CIbKXEEe.js → async-DSKj6g1f.js}

@@ -1,5 +1,5 @@
-import { t as replaceLayer, b as extractLayerConfig, x as extractLayerLegend, m as mergeGeojsons, d as axios, w as getCompareLayers, v as getLayers, $ as axios$1, I as compareIndicator, F as indicator } from './helpers-DAVGYl_f.js';
-import { S as useEmitLayersUpdate } from './asWebComponent-DfULAbpq.js';
+import { t as replaceLayer, b as extractLayerConfig, w as extractLayerLegend, m as mergeGeojsons, d as axios, Y as getCompareLayers, v as getLayers, $ as axios$1, H as compareIndicator, E as indicator } from './helpers-DjZVl_WF.js';
+import { R as useEmitLayersUpdate } from './asWebComponent-BHWpMuE3.js';
 import { isMulti } from '@eox/jsonform/src/custom-inputs/spatial/utils';
 import log from 'loglevel';
 
@@ -649,16 +649,27 @@ async function updateJobsStatus(jobs, indicator) {
     jobsUrls.map((url) =>
       axios$1
         .get(url, { params: { t: Date.now() } })
-        .then((response) => response.data),
+        .then((response) => response.data)
+        .catch((error) => {
+          if (axios$1.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/dist/client/create-layers-config-CBoYedqB.js

@@ -0,0 +1,182 @@
+import { a1 as EodashCollection } from './asWebComponent-BHWpMuE3.js';
+import log from 'loglevel';
+
+/**
+ * Creates full layer configuration from indicator and time information
+ * @param {import("stac-ts").StacCatalog
+ *   | import("stac-ts").StacCollection
+ *   | import("stac-ts").StacItem
+ *   | null
+ * } selectedIndicator
+ * @param {EodashCollection[]} eodashCols
+ * @param {string | import("stac-ts").StacItem | null} [timeOrItem] - time as a string, or a stac item
+ * @returns {Promise<Record<string, any>[]>}
+ */
+
+const createLayersConfig = async (
+  selectedIndicator,
+  eodashCols,
+  timeOrItem,
+) => {
+  log.debug(
+    "Creating layers config",
+    selectedIndicator,
+    eodashCols,
+    timeOrItem,
+  );
+  const layersCollection = [];
+  const dataLayers = {
+    type: "Group",
+    properties: {
+      id: "AnalysisGroup",
+      title: "Data Layers",
+      layerControlExpand: true,
+    },
+    layers: /** @type {Record<string,any>[]}*/ ([]),
+  };
+
+  for (const ec of eodashCols) {
+    /** @type {Record<string,any>[]} */
+    let layers;
+    if (timeOrItem) {
+      const dateOrItem =
+        typeof timeOrItem === "string" ? new Date(timeOrItem) : timeOrItem;
+      layers = await ec.createLayersJson(dateOrItem);
+    } else {
+      layers = await ec.createLayersJson(undefined);
+    }
+    // Add expand to all analysis layers
+    layers.forEach((dl) => {
+      dl.properties.layerControlExpand = true;
+      dl.properties.layerControlToolsExpand = true;
+    });
+    dataLayers.layers.push(...layers);
+  }
+
+  /* check for roles in indicator links to assign visibility property for the data layers */
+  if (selectedIndicator?.links) {
+    const visibilityLinks = selectedIndicator.links.filter(
+      (link) =>
+        Array.isArray(link.roles) &&
+        (link.roles.includes("disable") || link.roles.includes("hidden")),
+    );
+    if (visibilityLinks.length > 0) {
+      visibilityLinks.forEach((vl) => {
+        const targetLayerId = vl.id;
+        const targetLayer = dataLayers.layers.find(
+          (dl) => dl.properties.id.split(";:;")[0] === targetLayerId,
+        );
+        if (targetLayer) {
+          if (Array.isArray(vl.roles) && vl.roles.includes("disable")) {
+            targetLayer.properties.visible = false;
+            targetLayer.properties.layerControlExpand = false;
+          } else if (Array.isArray(vl.roles) && vl.roles.includes("hidden")) {
+            targetLayer.properties.layerControlHide = true;
+          }
+        }
+      });
+    }
+  }
+  layersCollection.push(dataLayers);
+  const indicatorLayers =
+    //@ts-expect-error indicator is collection
+    await EodashCollection.getIndicatorLayers(selectedIndicator);
+  const observationPointsLayer =
+    EodashCollection.getObservationPointsLayer(eodashCols);
+  if (observationPointsLayer) {
+    dataLayers.layers.push(observationPointsLayer);
+  }
+  const baseLayers = {
+    type: "Group",
+    properties: {
+      id: "BaseLayersGroup",
+      title: "Base Layers",
+    },
+    layers: /** @type {Record<string,any>[]}*/ ([]),
+  };
+
+  const indicatorBaseLayers = indicatorLayers.filter(
+    (l) => l.properties.group === "baselayer",
+  );
+
+  if (indicatorBaseLayers.length) {
+    // Only one baselayer can be set to visible, let's first set all to
+    // false that have not a dedicated property visible, then check
+    // if there are more then one visible and only allow one
+    let counter = 0;
+    let lastPos = 0;
+    for (let indx = 0; indx < indicatorBaseLayers.length; indx++) {
+      const bl = indicatorBaseLayers[indx];
+      if (!("visible" in bl.properties)) {
+        bl.properties.visible = false;
+      }
+
+      if (bl.properties.visible) {
+        counter++;
+        lastPos = indx;
+      }
+    }
+
+    // if none visible set the last one as visible
+    if (counter === 0) {
+      indicatorBaseLayers[0].properties.visible = true;
+    }
+
+    // disable all apart from last
+    if (counter > 0) {
+      indicatorBaseLayers.forEach((bl, indx) => {
+        if (indx !== lastPos) {
+          bl.properties.visible = false;
+        } else {
+          bl.properties.visible = true;
+        }
+      });
+    }
+
+    baseLayers.layers.push(...indicatorBaseLayers);
+
+    // Add exclusive to baselayers and make sure only one is selected
+    baseLayers.layers.forEach((bl) => {
+      bl.properties.layerControlExclusive = true;
+    });
+  } else {
+    // Default to some baselayer
+    baseLayers.layers.push({
+      type: "Tile",
+      properties: {
+        id: "osm",
+        title: "Background",
+        layerControlExclusive: true,
+      },
+      source: {
+        type: "OSM",
+      },
+    });
+  }
+
+  if (baseLayers.layers.length) {
+    layersCollection.unshift(baseLayers);
+  }
+
+  const overlayLayers = {
+    type: "Group",
+    properties: {
+      id: "OverlayGroup",
+      title: "Overlay Layers",
+    },
+    layers: /** @type {Record<string,any>[]}*/ ([]),
+  };
+
+  const indicatorOverlays = indicatorLayers.filter(
+    (l) => l.properties.group === "overlay",
+  );
+
+  if (indicatorOverlays.length) {
+    overlayLayers.layers.push(...indicatorOverlays);
+    layersCollection.push(overlayLayers);
+  }
+
+  return layersCollection;
+};
+
+export { createLayersConfig as c };

package/dist/client/eo-dash.js

@@ -1,2 +1,2 @@
-export { aI as EodashConstructor, aJ as register, aK as store } from './asWebComponent-DfULAbpq.js';
+export { aI as EodashConstructor, aJ as register, aK as store } from './asWebComponent-BHWpMuE3.js';
 import 'vue';

package/dist/client/{forwardRefs-yj3VWOK5.js → forwardRefs-DH51zPUr.js}

@@ -1,6 +1,6 @@
 import { computed, watch, onScopeDispose, nextTick, ref, watchEffect, effectScope, inject, mergeProps, toRef, toValue, shallowRef, onMounted, reactive, provide, toRaw, readonly, warn, onBeforeUnmount, createElementVNode, Fragment, createVNode, Teleport, withDirectives, vShow, Transition } from 'vue';
-import { aq as isOn, ar as eventName, p as propsFactory, as as destructComputed, at as parseAnchor, au as flipSide, av as flipAlign, aw as flipCorner, ax as CircularBuffer, ay as deepEqual, a0 as consoleError, az as getAxis, q as convertToUnit, x as clamp, aA as IN_BROWSER, A as useToggleScope, aB as defer, al as getCurrentInstance, aC as templateRef, aD as matchesSelector, aE as focusableChildren, G as useDisplay, r as makeThemeProps, d as makeDimensionProps, e as makeComponentProps, g as genericComponent, z as useProxiedModel, l as provideTheme, n as useRtl, f as useBackgroundColor, b as useDimension, aF as useRouter, aG as useBackButton, ao as standardEasing, c as useRender, C as omit } from './asWebComponent-DfULAbpq.js';
-import { m as makeTransitionProps, M as MaybeTransition } from './transition-DaOsiD4u.js';
+import { aq as isOn, ar as eventName, p as propsFactory, as as destructComputed, at as parseAnchor, au as flipSide, av as flipAlign, aw as flipCorner, ax as CircularBuffer, ay as deepEqual, $ as consoleError, az as getAxis, q as convertToUnit, x as clamp, aA as IN_BROWSER, A as useToggleScope, aB as defer, al as getCurrentInstance, aC as templateRef, aD as matchesSelector, aE as focusableChildren, G as useDisplay, r as makeThemeProps, d as makeDimensionProps, e as makeComponentProps, g as genericComponent, z as useProxiedModel, l as provideTheme, n as useRtl, f as useBackgroundColor, b as useDimension, aF as useRouter, aG as useBackButton, ao as standardEasing, c as useRender, C as omit } from './asWebComponent-BHWpMuE3.js';
+import { m as makeTransitionProps, M as MaybeTransition } from './transition-OHcz5Qq1.js';
 
 class Box {
   constructor(args) {

package/dist/client/{handling-s8xt2JwF.js → handling-BrcDDlgS.js}

@@ -1,8 +1,8 @@
 import log from 'loglevel';
-import { s as separateEndpointLinks, c as createTiffLayerDefinition, p as pollProcessStatus, e as extractAsyncResults, u as updateJobsStatus, a as creatAsyncProcessLayerDefinitions, b as getBboxProperty, f as generateTimePairs, h as extractGeometries, i as applyProcessLayersToMap, g as getDrawToolsProperties } from './async-CIbKXEEe.js';
-import { d as axios, b as extractLayerConfig, I as compareIndicator, F as indicator, y as extractCollectionUrls, H as currentCompareUrl, G as currentUrl, z as generateLinksFromItems, o as getDatetimeProperty, J as comparePoi, B as datetime, Z as compareChartData, _ as chartData, O as compareChartSpec, N as chartSpec, C as poi, w as getCompareLayers, v as getLayers } from './helpers-DAVGYl_f.js';
+import { s as separateEndpointLinks, c as createTiffLayerDefinition, p as pollProcessStatus, e as extractAsyncResults, u as updateJobsStatus, a as creatAsyncProcessLayerDefinitions, b as getBboxProperty, f as generateTimePairs, h as extractGeometries, i as applyProcessLayersToMap, g as getDrawToolsProperties } from './async-DSKj6g1f.js';
+import { d as axios, b as extractLayerConfig, H as compareIndicator, E as indicator, x as extractCollectionUrls, G as currentCompareUrl, F as currentUrl, y as generateLinksFromItems, o as getDatetimeProperty, I as comparePoi, A as datetime, Z as compareChartData, _ as chartData, N as compareChartSpec, M as chartSpec, B as poi, Y as getCompareLayers, v as getLayers } from './helpers-DjZVl_WF.js';
 import mustache from 'mustache';
-import { T as isFirstLoad, H as useSTAcStore, X as readParquetItems, Y as useGetSubCodeId } from './asWebComponent-DfULAbpq.js';
+import { S as isFirstLoad, H as useSTAcStore, W as readParquetItems, X as useGetSubCodeId } from './asWebComponent-BHWpMuE3.js';
 import { toAbsolute } from 'stac-js/src/http.js';
 
 /**
@@ -933,7 +933,7 @@ async function handleSentinelHubProcess({
     [jsonformValue["start_date"], jsonformValue["end_date"]],
     jsonformValue["distribution"]
   );
-  return await Promise.all(
+  const results = await Promise.all(
     timePairs.map(([to, from]) => {
       return fetchSentinelHubData({
         url: endpoint,
@@ -942,14 +942,16 @@ async function handleSentinelHubProcess({
         from,
         to,
         exampleLink: evalScriptLink
-      }).catch(
-        (err) => console.error(
+      }).catch((err) => {
+        console.error(
           "[eodash] Error while fetching data from sentinel hub endpoint:",
           err
-        )
-      );
+        );
+        return [];
+      });
     })
-  ).then((data) => data.flat().map((data2) => data2.outputs.data));
+  ).then((data) => data.filter((result) => result.length > 0)).then((data) => data.flat().map((data2) => data2.outputs.data));
+  return results;
 }
 async function sentinelHubAuth(clientId, clientSecret) {
   if (!clientId || !clientSecret) {
@@ -1135,7 +1137,7 @@ 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";
@@ -1154,14 +1156,17 @@ 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);
 }
 
 /**
@@ -1292,6 +1297,7 @@ function createCustomChartEndpointsHandler(callbacks) {
  * @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 {boolean} params.enableCompare
  */
 async function initProcess({
@@ -1302,6 +1308,7 @@ async function initProcess({
   loading,
   isPolling,
   enableCompare,
+  mapElement,
 }) {
   const isPoiAlive = enableCompare ? !!comparePoi.value : !!poi.value;
   let updatedJsonform = null;
@@ -1316,6 +1323,27 @@ async function initProcess({
     jsonformSchema.value = null;
     return;
   }
+
+  if (!updatedJsonform) {
+    resetProcess({
+      loading,
+      isProcessed,
+      jsonformSchema,
+      isPolling,
+      processResults,
+      enableCompare,
+    });
+    return;
+  }
+
+  const newJsonForm = await updateJsonformIdentifier({
+    jsonformSchema: updatedJsonform,
+    newLayers: enableCompare ? getCompareLayers() : getLayers(),
+    enableCompare,
+    mapElement,
+  });
+  if (!newJsonForm) return;
+
   resetProcess({
     loading,
     isProcessed,
@@ -1324,99 +1352,109 @@ async function initProcess({
     processResults,
     enableCompare,
   });
+  jsonformSchema.value = newJsonForm;
+}
 
-  if (updatedJsonform) {
-    // make sure correct target layer id is used in jsonform
-    const newJsonForm = await updateJsonformIdentifier({
-      jsonformSchema: updatedJsonform,
-      newLayers: enableCompare ? getCompareLayers() : getLayers(),
-      enableCompare,
-    });
-    // trigger jsonform update in next tick
-    jsonformSchema.value = null;
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    jsonformSchema.value = newJsonForm;
+/**
+ * Recursively search grouped layer tree for a layer whose id starts with the given prefix
+ *
+ * @param {Record<string, any>[]} layers
+ * @param {string} prefix
+ * @returns {string | null}
+ */
+function findLayerIdByPrefix(layers, prefix) {
+  for (const layer of layers) {
+    if (layer.type === "Group" && Array.isArray(layer.layers)) {
+      const found = findLayerIdByPrefix(layer.layers, prefix);
+      if (found) return found;
+    } else if (layer.properties?.id?.startsWith(prefix)) {
+      return layer.properties.id;
+    }
   }
+  return null;
 }
 
 /**
- * Update the jsonform schema to have the correct layer id from the map
+ * Wait until a layer's features are loaded for the drawtools to attach correctly
+ * Resolves immediately if already loaded.
+ *
+ * @param {import("@eox/map").AnyLayerWithSource | null | undefined} layer
+ * @returns {Promise<void>}
+ */
+function waitForLayerRender(layer) {
+  return new Promise((resolve, reject) => {
+    if (!layer || layer.get("type") !== "Vector" || !("getSource" in layer))
+      return resolve();
+    const source = /** @type {import("ol/source/Vector").default} */ (
+      layer.getSource()
+    );
+    if (!source || source.getFeatures().length > 0) return resolve();
+    source.once("featuresloadend", () => resolve());
+    source.once("featuresloaderror", () =>
+      reject(new Error(`Layer ${layer.get("id")} failed to load features`)),
+    );
+  });
+}
+
+/**
+ * Update the jsonform schema to have the correct layer id from the map.
+ * Returns null if any required layerId cannot be resolved (layer not yet in map).
+ * Callers should treat null as "retry when layers:updated fires".
  *
  * @export
- * @async
  * @param {Object} params
- * @param {Record<string,any> | null} params.jsonformSchema params.jsonformSchema
- * @param {Record<string, any>[] | undefined} params.newLayers params.newLayers
- * @param { boolean } params.enableCompare params.enableCompare
- * @returns {Promise<Record<string,any> | null>} updated jsonform schema
+ * @param {Record<string,any> | null} params.jsonformSchema
+ * @param {Record<string, any>[] | undefined} params.newLayers
+ * @param {boolean} params.enableCompare
+ * @param {import("@eox/map").EOxMap | null | undefined} params.mapElement
+ * @returns {Promise<Record<string,any> | null>} updated schema, or null if a layerId could not be resolved
  */
 async function updateJsonformIdentifier({
   jsonformSchema,
   newLayers,
   enableCompare,
+  mapElement,
 }) {
-  const form = jsonformSchema;
-  if (!form) {
-    return null;
-  }
+  if (!jsonformSchema || !newLayers) return null;
+
+  const form = JSON.parse(JSON.stringify(jsonformSchema));
   const drawToolsProperties = getDrawToolsProperties(form);
-  drawToolsProperties.forEach((drawToolsProperty) => {
-    if (
-      drawToolsProperty &&
-      form?.properties[drawToolsProperty]?.options?.drawtools?.for &&
-      enableCompare
-    ) {
-      form.properties[drawToolsProperty].options.drawtools.for =
-        "eox-map#compare";
+  /** @type {Promise<void>[]} */
+  const renderPromises = [];
+
+  for (const drawToolsProperty of drawToolsProperties) {
+    if (!drawToolsProperty) continue;
+
+    const drawtoolsOptions =
+      form?.properties[drawToolsProperty]?.options?.drawtools;
+    if (!drawtoolsOptions) continue;
+
+    if (drawtoolsOptions.for && enableCompare) {
+      drawtoolsOptions.for = "eox-map#compare";
     }
-    if (
-      drawToolsProperty &&
-      newLayers &&
-      form?.properties[drawToolsProperty]?.options?.drawtools?.layerId
-    ) {
-      // get partial or full id and try to match with correct eoxmap layer
-      // check if newLayers is an array or an object with layers property
-      let layers = newLayers;
-      // @ts-expect-error TODO payload coming from time update sometimes is not an object with layers property
-      if (newLayers.layers && Array.isArray(newLayers.layers)) {
-        // @ts-expect-error TODO payload coming from time update sometimes is not an object with layers property
-        layers = newLayers.layers;
-      }
 
-      const layerId =
-        form.properties[drawToolsProperty].options.drawtools.layerId.split(
-          ";:;",
-        )[0];
-      let matchedLayerId = null;
-      // layers are not flat can be grouped, we need to recursively search
-      const traverseLayers = (
-        /** @type {Record<string, any>[] | undefined} */ layersArray,
-      ) => {
-        if (!layersArray) {
-          return;
-        }
-        for (const layer of layersArray) {
-          if (layer.type === "Group" && Array.isArray(layer.layers)) {
-            traverseLayers(layer.layers);
-          } else {
-            if (layer.properties?.id?.startsWith(layerId)) {
-              matchedLayerId = layer.properties.id;
-              break;
-            }
-          }
+    if (drawtoolsOptions.layerId) {
+      let layer = mapElement?.getLayerById(drawtoolsOptions.layerId);
+      if (!layer) {
+        const prefix = drawtoolsOptions.layerId.split(";:;")[0];
+        const resolvedId = findLayerIdByPrefix(newLayers, prefix);
+        if (!resolvedId) {
+          console.warn(
+            `Could not find matching layer for processing form with id: ${prefix}`,
+          );
+          return null;
         }
-      };
-      traverseLayers(layers);
-      if (matchedLayerId) {
-        form.properties[drawToolsProperty].options.drawtools.layerId =
-          matchedLayerId;
-      } else {
-        console.warn(
-          `Could not find matching layer for processing form with id: ${layerId}`,
-        );
+        drawtoolsOptions.layerId = resolvedId;
+        layer = mapElement?.getLayerById(resolvedId);
       }
+      renderPromises.push(waitForLayerRender(layer));
     }
+  }
+
+  await Promise.all(renderPromises).catch((err) => {
+    console.warn("[eodash] layer load failed before jsonform attach:", err);
   });
+
   return form;
 }