@eodash/eodash 5.3.3 → 5.4.0

package/dist/types/core/client/eodashSTAC/EodashCollection.d.ts

@@ -9,13 +9,21 @@ export class EodashCollection {
         type: string;
         source: {
             type: string;
-            url: string;
-            projection: string;
+            url: string | undefined;
+            format: {
+                type: string;
+                dataProjection: string;
+            };
             attributions: unknown;
         };
         properties: {
             layerConfig?: {
                 style: import("../types").EodashStyleJson | undefined;
+            } | {
+                style: import("../types").EodashStyleJson | undefined;
+                schema: any;
+                legend: any;
+                type: string;
             } | undefined;
             id: string;
             title: string;
@@ -27,16 +35,18 @@ export class EodashCollection {
         type: string;
         source: {
             type: string;
-            url: string | undefined;
-            format: {
-                type: string;
-                dataProjection: string | undefined;
-            };
-            attributions: {}[];
+            projection: string;
+            attributions: unknown;
+            url: string;
         };
         properties: {
             layerConfig?: {
                 style: import("../types").EodashStyleJson | undefined;
+            } | {
+                style: import("../types").EodashStyleJson | undefined;
+                schema: any;
+                legend: any;
+                type: string;
             } | undefined;
             id: string;
             title: string;
@@ -51,12 +61,19 @@ export class EodashCollection {
             sources: {
                 url: string;
                 attributions: unknown;
+            } | {
+                url: string;
+                attributions: unknown;
             }[];
         };
         properties: {
             id: string;
             title: string;
-            layerConfig: Record<string, unknown> | undefined;
+            layerConfig: Record<string, unknown> | {
+                schema: any;
+                legend: any;
+                type: string;
+            } | undefined;
             layerDatetime: Record<string, unknown> | undefined;
         };
         style: import("../types").EodashStyleJson | undefined;
@@ -122,13 +139,12 @@ export class EodashCollection {
     createLayersJson: (itemOrDate?: import("stac-ts").StacItem | import("stac-ts").StacLink | Date) => Promise<Record<string, any>[]>;
     /**
      * @param {import("stac-ts").StacItem} item
-     * @param {string} itemUrl
      * @param {string} title
      * @param {boolean} isObservationPoint
      * @param {string} [itemDatetime]
      * @returns {Promise<Record<string,any>[]>} layers
      * */
-    buildJsonArray(item: import("stac-ts").StacItem, itemUrl: string, title: string, isObservationPoint: boolean, itemDatetime?: string): Promise<Record<string, any>[]>;
+    buildJsonArray(item: import("stac-ts").StacItem, title: string, isObservationPoint: boolean, itemDatetime?: string): Promise<Record<string, any>[]>;
     fetchCollection(): Promise<import("stac-ts").StacCollection>;
     /**
      * Returns all item links sorted by datetime ascendingly

package/dist/types/core/client/eodashSTAC/createLayers.d.ts

@@ -2,25 +2,31 @@
  * @param {string} collectionId
  * @param {string} title
  * @param {Record<string,import("stac-ts").StacAsset>} assets
- * @param {import("stac-ts").StacItem } item
- * @param {import("../types").EodashStyleJson} [style]
- * @param {Record<string, unknown>} [layerConfig]
+ * @param {import("stac-ts").StacItem | import("stac-ts").StacCollection } stacObject
  * @param {Record<string, unknown>} [layerDatetime]
  * @param {object | null} [extraProperties]
  **/
-export function createLayersFromAssets(collectionId: string, title: string, assets: Record<string, import("stac-ts").StacAsset>, item: import("stac-ts").StacItem, style?: import("../types").EodashStyleJson, layerConfig?: Record<string, unknown>, layerDatetime?: Record<string, unknown>, extraProperties?: object | null): Promise<({
+export function createLayersFromAssets(collectionId: string, title: string, assets: Record<string, import("stac-ts").StacAsset>, stacObject: import("stac-ts").StacItem | import("stac-ts").StacCollection, layerDatetime?: Record<string, unknown>, extraProperties?: object | null): Promise<({
     interactions: never[];
     style?: import("../types").EodashStyleJson | undefined;
     type: string;
     source: {
         type: string;
-        url: string;
-        projection: string;
+        url: string | undefined;
+        format: {
+            type: string;
+            dataProjection: string;
+        };
         attributions: unknown;
     };
     properties: {
         layerConfig?: {
             style: import("../types").EodashStyleJson | undefined;
+        } | {
+            style: import("../types").EodashStyleJson | undefined;
+            schema: any;
+            legend: any;
+            type: string;
         } | undefined;
         id: string;
         title: string;
@@ -32,16 +38,18 @@ export function createLayersFromAssets(collectionId: string, title: string, asse
     type: string;
     source: {
         type: string;
-        url: string | undefined;
-        format: {
-            type: string;
-            dataProjection: string | undefined;
-        };
-        attributions: {}[];
+        projection: string;
+        attributions: unknown;
+        url: string;
     };
     properties: {
         layerConfig?: {
             style: import("../types").EodashStyleJson | undefined;
+        } | {
+            style: import("../types").EodashStyleJson | undefined;
+            schema: any;
+            legend: any;
+            type: string;
         } | undefined;
         id: string;
         title: string;
@@ -56,23 +64,22 @@ export function createLayersFromAssets(collectionId: string, title: string, asse
         sources: {
             url: string;
             attributions: unknown;
+        } | {
+            url: string;
+            attributions: unknown;
         }[];
     };
     properties: {
         id: string;
         title: string;
-        layerConfig: Record<string, unknown> | undefined;
+        layerConfig: Record<string, unknown> | {
+            schema: any;
+            legend: any;
+            type: string;
+        } | undefined;
         layerDatetime: Record<string, unknown> | undefined;
     };
     style: import("../types").EodashStyleJson | undefined;
 })[]>;
-/**
- * Implementation of a function that creates a layer from the render extention
- * @param {import("stac-ts").StacCollection | undefined | null} collection
- * @param {import("stac-ts").StacItem | undefined | null} item
- * @param {string} rasterURL
- * @param {Record<string, any>} [extraProperties]
- * @returns {import("@eox/map/src/layers").EOxLayerType<"Tile","XYZ">[]}
- */
-export function createLayerFromRender(rasterURL: string, collection: import("stac-ts").StacCollection | undefined | null, item: import("stac-ts").StacItem | undefined | null, extraProperties?: Record<string, any>): import("@eox/map/src/layers").EOxLayerType<"Tile", "XYZ">[];
-export function createLayersFromLinks(collectionId: string, title: string, item: import("stac-ts").StacItem, itemUrl: string, layerDatetime?: Record<string, any>, extraProperties?: object | null): Promise<Record<string, any>[]>;
+export function createLayersFromLinks(collectionId: string, title: string, item: import("stac-ts").StacItem, layerDatetime?: Record<string, any>, extraProperties?: object | null, collection?: import("stac-ts").StacCollection): Promise<Record<string, any>[]>;
+export function createLayerFromRender(rasterURL: string, collection: import("stac-ts").StacCollection | undefined | null, item: import("stac-ts").StacItem | undefined | null, extraProperties?: Record<string, any>): Promise<import("@eox/map/src/layers").EOxLayerType<"Tile", "XYZ">[]>;

package/dist/types/core/client/eodashSTAC/helpers.d.ts

@@ -14,13 +14,14 @@ export function generateFeatures(links?: import("stac-ts").StacLink[], extraProp
     features: import("geojson").Feature<import("geojson").Geometry, import("geojson").GeoJsonProperties>[];
 };
 /**
- * Sperates and extracts layerConfig (jsonform schema & legend) from a style json
+ * Spearates and extracts layerConfig (jsonform schema & legend) from a style json
  *
  * @param {string} collectionId
  *  @param { import("../types").EodashStyleJson} [style]
  * @param {Record<string,any>} [rasterJsonform]
+ * @param {string} [layerConfigType]
  * */
-export function extractLayerConfig(collectionId: string, style?: import("../types").EodashStyleJson, rasterJsonform?: Record<string, any>): {
+export function extractLayerConfig(collectionId: string, style?: import("../types").EodashStyleJson, rasterJsonform?: Record<string, any>, layerConfigType?: string): {
     layerConfig: {
         schema: any;
         legend: any;
@@ -92,9 +93,14 @@ export function fetchApiItems(itemsUrl: string, query?: string, limit?: number,
  * @returns {object}
  */
 export function extractLayerLegend(collection: import("stac-ts").StacCollection | undefined | null): object;
+/**
+ * @param { import ("stac-ts").StacLink } link
+ * @returns {object}
+ */
+export function extractEoxLegendLink(link: import("stac-ts").StacLink): object;
 export function sanitizeBbox(bbox: number[]): number[];
 export function extractRoles(properties: Record<string, any>, linkOrAsset: import("stac-ts").StacLink | import("stac-ts").StacAsset): Record<string, any>;
-export function fetchStyle(item: import("stac-ts").StacItem, itemUrl: string, key?: string | undefined): Promise<{
+export function fetchStyle(stacObject: import("stac-ts").StacItem | import("stac-ts").StacCollection, linkKey?: string | undefined, assetKey?: string | undefined): Promise<{
     "fill-color"?: import("ol/style/flat.js").ColorExpression | undefined;
     "fill-pattern-src"?: import("ol/style/flat.js").StringExpression | undefined;
     "fill-pattern-size"?: import("ol/style/flat.js").SizeExpression | undefined;
@@ -481,7 +487,7 @@ export function fetchStyle(item: import("stac-ts").StacItem, itemUrl: string, ke
         decimals?: number;
     }[];
 } | undefined>;
-export function fetchAllStyles(item: import("stac-ts").StacItem, itemUrl: string): Promise<Array<import("../types").EodashStyleJson>>;
+export function fetchAllStyles(stacObject: import("stac-ts").StacItem | import("stac-ts").StacCollection): Promise<Array<import("../types").EodashStyleJson>>;
 export function getProjectionCode(projection?: string | number | {
     name: string;
     def: string;

package/dist/types/core/client/types.d.ts

@@ -383,7 +383,7 @@ export type EodashRasterJSONForm = {
     legend?: import("@eox/layercontrol/src/components/layer-config.js").EOxLayerControlLayerConfig["layerConfig"]["legend"];
 };
 /** @ignore */
-export type LayersEventBusKeys = "layers:updated" | "time:updated" | "process:updated" | "compareLayers:updated" | "compareTime:updated" | "compareProcess:updated";
+export type LayersEventBusKeys = "layers:updated" | "time:updated" | "process:updated" | "layertime:updated" | "compareLayers:updated" | "compareTime:updated" | "compareProcess:updated" | "compareLayertime:updated";
 /** @ignore */
 export interface SearchParams {
     /** Collection IDs to search within */

package/dist/types/widgets/EodashMap/EodashMapBtns.vue.d.ts

@@ -9,6 +9,7 @@ declare const _default: import("vue").DefineComponent<{}, {
     backToPOIs: boolean;
     enableSearch: boolean;
     enableZoom: boolean;
+    searchParams: boolean | Record<string, any>;
     $props: {
         compareIndicators?: boolean | {
             compareTemplate?: string;
@@ -20,6 +21,7 @@ declare const _default: import("vue").DefineComponent<{}, {
         backToPOIs?: boolean | undefined;
         enableSearch?: boolean | undefined;
         enableZoom?: boolean | undefined;
+        searchParams?: boolean | Record<string, any> | undefined;
     };
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/types/widgets/EodashMap/index.vue.d.ts

@@ -10,6 +10,7 @@ declare const _default: import("vue").DefineComponent<{}, {
         enableChangeProjection?: boolean;
         enableBackToPOIs?: boolean;
         enableSearch?: boolean;
+        searchParams?: object;
         enableZoom?: boolean;
         enableCompareIndicators?: boolean | {
             compareTemplate?: string;
@@ -72,6 +73,7 @@ declare const _default: import("vue").DefineComponent<{}, {
             enableChangeProjection?: boolean;
             enableBackToPOIs?: boolean;
             enableSearch?: boolean;
+            searchParams?: object;
             enableZoom?: boolean;
             enableCompareIndicators?: boolean | {
                 compareTemplate?: string;

package/dist/types/widgets/EodashProcess/methods/handling.d.ts

@@ -25,6 +25,19 @@ export function initProcess({ selectedStac, jsonformEl, jsonformSchema, chartSpe
     isPolling: import("vue").Ref<boolean>;
     enableCompare: boolean;
 }): Promise<void>;
+/**
+ * Update the jsonform schema to have the correct layer id from the map
+ *
+ * @export
+ * @async
+ * @param {Object} params
+ * @param {import("vue").Ref<Record<string,any> | null>} params.jsonformSchema params.jsonformSchema
+ * @param {Record<string, any>[] | undefined} params.newLayers params.newLayers
+ */
+export function updateJsonformIdentifier({ jsonformSchema, newLayers }: {
+    jsonformSchema: import("vue").Ref<Record<string, any> | null>;
+    newLayers: Record<string, any>[] | undefined;
+}): Promise<void>;
 /**
  *
  * @param {object} params

package/dist/types/widgets/EodashProcess/methods/utils.d.ts

@@ -59,4 +59,5 @@ export function extractAsyncResults(resultItem: import("../../EodashProcess/type
  */
 export function updateJsonformSchemaTarget(jsonformSchema: import("json-schema").JSONSchema7 | null | undefined): import("json-schema").JSONSchema7 | null | undefined;
 export function download(fileName: string, content: string | Record<string, any>): void;
+export function getDrawToolsProperty(jsonformSchema: any): string | undefined;
 export function applyProcessLayersToMap(mapElement: import("@eox/map").EOxMap | null, processLayers: import("@eox/map").EoxLayer[]): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eodash/eodash",
-  "version": "5.3.3",
+  "version": "5.4.0",
   "type": "module",
   "types": "./dist/types/core/client/types.d.ts",
   "files": [

package/templates/expert.js

@@ -35,6 +35,10 @@ export default {
           },
           enableBackToPOIs: true,
           enableSearch: true,
+          // searchParams: {
+          //   countrycode: "gb,ie,fr"
+          //   bounds: "-84.26514,41.58998,-77.54150,46.14246"
+          // },
         },
         btnsPosition: {
           x: "12/9/9",

package/widgets/EodashMap/EodashMapBtns.vue

@@ -69,6 +69,7 @@
       v-if="mapEl && enableSearch"
       :for="mapEl"
       :endpoint="opencageUrl"
+      :params="searchParams"
       class="geosearch-detached"
       label="Search"
       small
@@ -131,6 +132,7 @@ const {
   backToPOIs,
   enableSearch,
   enableZoom,
+  searchParams,
 } = defineProps({
   exportMap: {
     type: Boolean,
@@ -157,6 +159,10 @@ const {
     type: Boolean,
     default: true,
   },
+  searchParams: {
+    type: [Boolean, Object],
+    default: true,
+  },
   enableZoom: {
     type: Boolean,
     default: true,
@@ -263,11 +269,20 @@ const opencageUrl = `https://api.opencagedata.com/geocode/v1/json?key=${opencage
 
 <style scoped>
 @import url("@eox/ui/style.css");
+/* Make sure panel does pass click event through */
+.map-buttons {
+  pointer-events: none !important;
+}
 
 .map-buttons button {
+  pointer-events: auto !important;
   margin-bottom: 5px;
   background-color: var(--primary);
 }
+/* Make sure buttons have pointer event */
+.geosearch-detached {
+  pointer-events: auto !important;
+}
 
 /* Container constraints removal */
 eox-geosearch {

package/widgets/EodashMap/index.vue

@@ -60,6 +60,7 @@
         "
         :enableZoom="(indicator || compareIndicator || poi) ? btnsProps.enableZoom : false
         "
+        :searchParams="btnsProps.searchParams"
       />
     </div>
   </span>
@@ -136,6 +137,7 @@ const props = defineProps({
      * enableChangeProjection?: boolean;
      * enableBackToPOIs?: boolean;
      * enableSearch?: boolean;
+     * searchParams?: object;
      * enableZoom?: boolean;
      * enableCompareIndicators?: boolean | {
      *   compareTemplate?:string;
@@ -151,6 +153,7 @@ const props = defineProps({
       enableBackToPOIs: true,
       enableSearch: true,
       enableZoom: true,
+      searchParams: {},
     }),
   },
 });
@@ -192,6 +195,7 @@ const btnsProps = computed(() => ({
   backToPOIs: props.btns.enableBackToPOIs ?? true,
   enableSearch: props.btns.enableSearch ?? true,
   enableZoom: props.btns.enableZoom ?? true,
+  searchParams: props.btns.searchParams,
 }));
 
 // Prepare containers for scale line and cursor coordinates

package/widgets/EodashMap/methods/create-layers-config.js

@@ -52,6 +52,29 @@ export const createLayersConfig = async (
     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;
+          } 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

package/widgets/EodashProcess/index.vue

@@ -59,7 +59,7 @@ import {
   chartEl,
   compareChartEl,
 } from "@/store/states";
-import { download } from "./methods/utils";
+import { download, getDrawToolsProperty } from "./methods/utils";
 import { compareJobs, jobs } from "./states";
 import { mdiCogPlayOutline, mdiDownloadCircleOutline } from "@mdi/js";
 
@@ -155,14 +155,6 @@ const downloadResults = () => {
 };
 
 const startProcess = async () => {
-  /** @param {*} jsonformSchema */
-  const getDrawToolsProperty = (jsonformSchema) => {
-    for (const property in jsonformSchema.properties) {
-      if (jsonformSchema.properties[property]?.options?.drawtools) {
-        return property;
-      }
-    }
-  };
   const drawToolsProperty = getDrawToolsProperty(jsonformSchema.value);
   const propertyIsEmpty =
     drawToolsProperty &&

package/widgets/EodashProcess/methods/composables.js

@@ -1,4 +1,4 @@
-import { initProcess } from "./handling";
+import { initProcess, updateJsonformIdentifier } from "./handling";
 import { useEventBus } from "@vueuse/core";
 import { nextTick, onMounted, watch } from "vue";
 import { eoxLayersKey } from "@/utils/keys";
@@ -67,6 +67,18 @@ export const useInitProcess = ({
   const evtKey =
     mapElement?.id === "compare" ? "compareLayers:updated" : "layers:updated";
   useOnLayersUpdate(async (evt, _payload) => {
+    if (
+      evt == "layertime:updated" ||
+      evt == "compareLayertime:updated" ||
+      evt == "time:updated" ||
+      evt == "compareTime:updated"
+    ) {
+      await updateJsonformIdentifier({
+        jsonformSchema,
+        // @ts-expect-error TODO payload coming from time update events is not an object with layers property
+        newLayers: _payload,
+      });
+    }
     if (evt !== evtKey) {
       return;
     }

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

@@ -19,7 +19,7 @@ export async function handleVedaEndpoint({
   enableCompare = false,
 }) {
   const vedaLink = links.find(
-    (link) => link.rel === "service" && link.endpoint === "veda",
+    (link) => link.rel === "service" && (link.endpoint === "veda" || link.endpoint === "veda_stac"),
   );
   if (!vedaLink) {
     return;
@@ -32,12 +32,17 @@ export async function handleVedaEndpoint({
   const configs = await fetchVedaCOGsConfig(
     selectedStac,
     enableCompare ? currentCompareUrl.value : currentUrl.value,
+    vedaLink,
   );
   // TODO: convert jsonform bbox type to geojson in the schema to avoid the conversion here
   return await Promise.all(
     configs.map(({ endpoint, datetime }) => {
+      const url = new URL(vedaEndpoint);
+      const key = vedaLink.endpoint === "veda_stac" ? "ids" : "url";
+      url.searchParams.set(key, endpoint);
+
       return axios
-        .post(vedaEndpoint + `?url=${endpoint}`, {
+        .post(url.toString(), {
           ...{
             type: "Feature",
             properties: {},
@@ -63,8 +68,9 @@ export async function handleVedaEndpoint({
  * Fetches the COGs endpoints from the STAC collections
  * @param {import("stac-ts").StacCollection} selectedStac
  * @param {string} absoluteUrl
+ * @param {import("stac-ts").StacLink} vedaLink
  */
-async function fetchVedaCOGsConfig(selectedStac, absoluteUrl) {
+async function fetchVedaCOGsConfig(selectedStac, absoluteUrl, vedaLink) {
   // retrieve the collections from the indicator
   const collectionLinks = selectedStac.links.filter(
     (link) => link.rel == "child",
@@ -110,10 +116,13 @@ async function fetchVedaCOGsConfig(selectedStac, absoluteUrl) {
     );
     const itemLinks = collection.links.filter((link) => link.rel == "item");
     configs.push(
-      ...itemLinks.map((link) => ({
-        endpoint: /** @type {string} */ (link["cog_href"]),
+      ...itemLinks.map((link) => {
+        const endpoint = /** @type {string} */ (vedaLink.endpoint === "veda_stac" ? link.id : link["cog_href"]);
+        return {
+        endpoint,
         datetime: /** @type string **/ (link[datetimeProperty]),
-      })),
+      }
+    })
     );
   }
 

package/widgets/EodashProcess/methods/handling.js

@@ -3,6 +3,7 @@ import {
   applyProcessLayersToMap,
   extractGeometries,
   getBboxProperty,
+  getDrawToolsProperty,
   updateJsonformSchemaTarget,
 } from "./utils";
 import {
@@ -18,6 +19,7 @@ import { handleLayersCustomEndpoints } from "./custom-endpoints/layers";
 import { handleChartCustomEndpoints } from "./custom-endpoints/chart";
 import { useSTAcStore } from "@/store/stac";
 import { useGetSubCodeId } from "@/composables";
+import { getLayers } from "@/store/actions";
 
 /**
  * Fetch and set the jsonform schema to initialize the process
@@ -70,6 +72,13 @@ export async function initProcess({
 
   await jsonformEl.value?.editor.destroy();
   if (updatedJsonform) {
+    // make sure correct target layer id is used in jsonform
+    if (updatedJsonform.properties?.feature?.options?.drawtools?.layerId) {
+      await updateJsonformIdentifier({
+        jsonformSchema,
+        newLayers: await getLayers(),
+      });
+    }
     if (enableCompare) {
       updatedJsonform = updateJsonformSchemaTarget(updatedJsonform);
     }
@@ -77,6 +86,74 @@ export async function initProcess({
   }
 }
 
+/**
+ * Update the jsonform schema to have the correct layer id from the map
+ *
+ * @export
+ * @async
+ * @param {Object} params
+ * @param {import("vue").Ref<Record<string,any> | null>} params.jsonformSchema params.jsonformSchema
+ * @param {Record<string, any>[] | undefined} params.newLayers params.newLayers
+ */
+export async function updateJsonformIdentifier({ jsonformSchema, newLayers }) {
+  const form = jsonformSchema.value;
+  if (!form) {
+    return;
+  }
+  const drawToolsProperty = getDrawToolsProperty(form);
+  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.layers) {
+          // @ts-expect-error TODO payload coming from time update events is not an object with layers property
+          traverseLayers(layer);
+        } else {
+          if (layer.properties?.id?.startsWith(layerId)) {
+            matchedLayerId = layer.properties.id;
+            break;
+          }
+        }
+      }
+    };
+    traverseLayers(layers);
+    if (matchedLayerId) {
+      form.properties.feature.options.drawtools.layerId = matchedLayerId;
+      // trigger jsonform update in next tick
+      jsonformSchema.value = null;
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      jsonformSchema.value = form;
+    } else {
+      throw new Error(
+        `Could not find matching layer for processing form with id: ${layerId}`,
+      );
+    }
+  }
+}
+
 /**
  *
  * @param {object} params

package/widgets/EodashProcess/methods/utils.js

@@ -508,6 +508,16 @@ export function extractAsyncResults(resultItem) {
   }
   return extracted;
 }
+
+/** @param {*} jsonformSchema */
+export const getDrawToolsProperty = (jsonformSchema) => {
+  for (const property in jsonformSchema.properties) {
+    if (jsonformSchema.properties[property]?.options?.drawtools) {
+      return property;
+    }
+  }
+};
+
 /**
  * @param {import("@eox/map").EOxMap | null} mapElement
  * @param {import("@eox/map").EoxLayer[]} processLayers